Come abbinare, ma non catturare, parte di una regex?

Ho un elenco di stringhe. Alcuni di loro sono nella forma 123-...456. La parte variabile "..." può essere:

• la stringa "mela" seguita da un trattino, ad es 123-apple-456
• la stringa "banana" seguita da un trattino, ad es 123-banana-456
• una stringa vuota, ad es. 123-456(nota che c'è solo un trattino)

Qualsiasi parola diversa da "mela" o "banana" non è valida.

Per questi tre casi, vorrei abbinare rispettivamente "mela", "banana" e "". Nota che non voglio mai catturare il trattino, ma voglio sempre abbinarlo . Se la stringa non ha la forma 123-...456descritta sopra, allora non c'è alcuna corrispondenza.

Come scrivo un'espressione regolare per farlo? Supponiamo che abbia un sapore che consenta lookahead, lookbehind, lookaround e gruppi non catturanti.

L'osservazione chiave qui è che quando hai "mela" o "banana", devi anche avere il trattino finale, ma non vuoi abbinarlo. E quando abbini la stringa vuota, non devi avere il trattino finale. Una regex che incapsula questa affermazione sarà quella giusta, credo.

L'unico modo per non catturare qualcosa è usare le asserzioni look-around :

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

Perché anche con i gruppi non acquisiti(?:…) l'intera espressione regolare acquisisce i contenuti corrispondenti. Ma questa espressione regolare corrisponde solo appleo bananase è preceduta da 123-e seguita da -456, oppure corrisponde alla stringa vuota se è preceduta da 123-e seguita da 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|
-------------------------------------------------------------------------

Aggiornamento: grazie a Germán Rodríguez Herrera!

In javascript prova: /123-(apple(?=-)|banana(?=-)|(?!-))-?456/

Ricorda che il risultato è nel gruppo 1

Debuggex Demo

Provare:

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

Che corrisponderà apple, bananao una stringa vuota, e in seguito ci saranno 0 o 1 trattini. Ho sbagliato a non avere bisogno di un gruppo di cattura. Sciocco me

Ho modificato una delle risposte (di @ op1ekun):

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

Il motivo è che anche la risposta di @ op1ekun corrisponde "123-apple456", senza il trattino dopo apple.

Prova questo:

/\d{3}-(?:(apple|banana)-)?\d{3}/

Una variante dell'espressione di @Gumbo che utilizza \Kper reimpostare le posizioni delle partite per impedire l'inclusione di blocchi numerici nella partita. Utilizzabile con regex PCRE.

123-\K(?:(?:apple|banana)(?=-456)|456\K)

gli incontri:

Match 1  apple
Match 2  banana
Match 3

Di gran lunga il più semplice (funziona per Python) è '123-(apple|banana)-?456'.