Comment faire correspondre, mais pas de capture, partie d'une regex?

J'ai une liste de chaînes de caractères. Certains d'entre eux sont de la forme 123-...456. La partie variable "..." peut être:

  • la chaîne "apple" suivi d'un tiret, par exemple 123-apple-456
  • la chaîne "banane" suivi d'un tiret, par exemple 123-banana-456
  • une chaîne vide, par exemple 123-456 (remarque il n'y a qu'un trait d'union)

Un mot autre que "apple" ou "banane" n'est pas valide.

Pour ces trois cas, je voudrais correspondre à "apple", "banane", et "", respectivement. Notez que je ne veux plus jamais capture le trait d'union, mais je veux toujours match il. Si la chaîne n'est pas de la forme 123-...456 comme décrit ci-dessus, alors il n'y a aucune correspondance.

Comment puis-je écrire une expression régulière pour ce faire? Supposons que j'ai une saveur qui permet d'anticipation, lookbehind, lookaround, et non de capturer les groupes.

L'observation essentielle ici est que lorsque vous avez "apple" ou "banane", vous doit également avoir de fin du trait d'union, mais vous ne voulez pas pour le match. Et quand vous êtes correspondant à la chaîne vide, vous ne doit pas avoir de fin du trait d'union. Une regex qui encapsule cette affirmation sera la bonne, je pense.

  • Vous voulez correspondre à tout, sauf pour les traits d'union?
InformationsquelleAutor David Stone | 2010-10-13
  1. 211

    Le seul moyen de ne pas saisir quelque chose est à l'aide de regardez autour affirmations:

    (?<=123-)((apple|banana)(?=-456)|(?=456))

    Parce que même avec non-capture de groupes de (?:...) l'ensemble de l'expression régulière capte leurs appariés contenu. Mais cette expression régulière correspond à seulement apple ou banana si il est précédé par 123- et suivie par -456, ou elle correspond à la chaîne vide si il est précédé par 123- et suivie par 456.

    |Lookaround  |    Name      |        What it Does                       |
-----------------------------------------------------------------------
|(?=foo)     |   Lookahead  | Asserts that what immediately FOLLOWS the |
|            |              |  current position in the string is foo    |
-------------------------------------------------------------------------
|(?<=foo)    |   Lookbehind | Asserts that what immediately PRECEDES the|
|            |              |  current position in the string is foo    |
-------------------------------------------------------------------------
|(?!foo)     |   Negative   | Asserts that what immediately FOLLOWS the |
|            |   Lookahead  |  current position in the string is NOT foo|
-------------------------------------------------------------------------
|(?<!foo)    |   Negative   | Asserts that what immediately PRECEDES the|
|            |   Lookbehind |  current position in the string is NOT foo|
-------------------------------------------------------------------------
    • +1 — Dans ce cas, vous pouvez contourner ce problème en utilisant le groupe 1 plutôt que le groupe 0, mais c'est un excellent (et subtil!) la distinction.
    • Vierge: Il est certainement dépend de la façon dont “match” et “capture” sont interprétés.
    • Pas de prise en charge en JavaScript, ouais! serait agréable d'avoir un JS méthode favorable, mais pas mal du tout, +0.5 (arrondi vers le haut ;D )
    • Aimez regarder autour affirmations! Ces grands travaux avec Ruby ainsi.
    InformationsquelleAutor Gumbo
  2. 13

    Mise à jour: Grâce à Germán Rodríguez Herrera!

    En javascript essayer: /123-(apple(?=-)|banana(?=-)|(?!-))-?456/

    Rappelez-vous que le résultat est dans le groupe 1

    Debuggex Démo

    InformationsquelleAutor op1ekun
  3. 8

    Essayer: 

    123-(?:(apple|banana|)-|)456

    Qui correspondent à apple, banana, ou une chaîne vide, et à la suite il y aura un 0 ou un 1 des traits d'union. J'ai eu tort de ne pas avoir besoin d'une capture d'un groupe. Je suis bête.

    • Ce n'est pas correcte, car elle correspond, par exemple, "123-noix de coco-456".
    • Pensais que tu voulais plus générale...fixe.
    • ceci correspondra à '123--456'
    InformationsquelleAutor Thomas
  4. 4

    J'ai modifié l'une des réponses (par @op1ekun):

    123-(apple(?=-)|banana(?=-)|(?!-))-?456

    La raison en est que la réponse de @op1ekun correspond également à "123-apple456", sans le trait d'union après apple.

    InformationsquelleAutor Germán Rodríguez Herrera
  5. 2

    Essayez ceci:

    /\d{3}-(?:(apple|banana)-)?\d{3}/
    • Ce n'est pas correcte, car elle correspond, par exemple, "123-noix de coco-456".
    • comment est-ce différent de votre "banane" par exemple?
    • J' que voulez capturer apple ou banana ou "". Toutes les autres valeurs ne sont pas valides, comme je l'ai dit.
    • sry, dans ce cas: /\d{3}-(?:(pomme|banane)-)?\d{3}/
    • Ce que cet exemple montre qu'il est possible d'avoir une capture d'un groupe sans l'aide d'anticipation et lookbehind.
    InformationsquelleAutor slosd
  6. -2

    De loin la plus simple (pour python) est '123-(apple|banana)-?456'.

    • Cela pourrait correspondre à 123-apple456 de sorte qu'il n'est pas correct.
    InformationsquelleAutor johmsp