Come negare una parola specifica nell'espressione regolare?

Question

So che posso annullare il gruppo di caratteri come in [^bar] ma ho bisogno di un'espressione regolare in cui la negazione si applica alla parola specifica - quindi nel mio esempio come faccio a negare un effettivo "bar" e non "any chars in bar"?

Answer 1

Un ottimo modo per farlo è quello di utilizzare negative lookahead:

^(?!.*bar).*$ 

Answer 2

Si potrebbe utilizzare un negative look-ahead or look-behind:

^(?!.*?bar).* 
^(.(?<!bar))*?$ 

Oppure utilizzare solo nozioni di base:

^(?:[^b]+|b(?:$|[^a]|a(?:$|[^r])))*$ 

Questi tutti i match tutto ciò che non contiene bar.

Answer 3

A meno che le prestazioni non siano di estrema importanza, spesso è più semplice eseguire i risultati con un secondo passaggio, ignorando quelli che corrispondono alle parole che si desidera negare.

Le espressioni regolari di solito indicano che si sta eseguendo script o qualche tipo di attività a bassa prestazione, quindi è possibile trovare una soluzione facile da leggere, facile da comprendere e di facile manutenzione.

Answer 4

La regex seguente farà ciò che si desidera (purché siano supportati lookbehind e lookaheads negativi), facendo corrispondere le cose correttamente; l'unico problema è che combina i singoli caratteri (ad esempio, ogni corrispondenza è un singolo carattere piuttosto che tutti i caratteri tra due "barre" consecutive), con il conseguente potenziale di un sovraccarico elevato se si lavora con stringhe molto lunghe.

b(?!ar)|(?<!b)a|a(?!r)|(?<!ba)r|[^bar] 

Answer 5

solo pensato di qualcos'altro che potrebbe essere fatto. È molto diverso dalla mia prima risposta, in quanto non utilizza espressioni regolari, quindi ho deciso di fare un secondo post di risposta.

Utilizzare il metodo corrispondente alla stringa split() nella stringa con la parola da escludere come argomento su cosa dividere. Un esempio di utilizzo di Python:

>>> text = 'barbarasdbarbar 1234egb ar bar32 sdfbaraadf' 
>>> text.split('bar') 
['', '', 'asd', '', ' 1234egb ar ', '32 sdf', 'aadf'] 

La cosa bella di fare in questo modo, in Python, almeno (non ricordo se la funzionalità sarebbe lo stesso, per esempio, Visual Basic o Java), è che ti consente di sapere indirettamente quando "barra" è stata ripetuta nella stringa a causa del fatto che le stringhe vuote tra "barre" sono incluse nell'elenco dei risultati (anche se la stringa vuota all'inizio è dovuta al fatto che esiste una "barra" "all'inizio della stringa). Se non lo desideri, puoi semplicemente rimuovere le stringhe vuote dall'elenco.

Answer 6

mi sono imbattuto in questo thread del forum durante il tentativo di individuare una regex per la seguente dichiarazione inglese:

Dato una stringa di input, match tuttoa meno questa stringa di input è esattamente 'bar'; per esempio voglio abbinare 'barriera' e 'disbar' così come 'foo'.

Ecco l'espressione regolare che mi è venuta

^(bar.+|(?!bar).*)$ 

traduzione

Il mio inglese del regex è "hanno la stringa se inizia con 'bar' e ha almeno un altro personaggio, o se il stringa non iniziare con 'bar'

Answer 7

ho avuto una lista di nomi di file, e ho voluto escludere alcune quelli, con questo tipo di comportamento (Ruby):.

files = [ 
    'mydir/states.rb',  # don't match these 
    'countries.rb', 
    'mydir/states_bkp.rb', # match these 
    'mydir/city_states.rb' 
] 
excluded = ['states', 'countries'] 

# set my_rgx here 

result = WankyAPI.filter(files, my_rgx) # I didn't write WankyAPI... 
assert result == ['mydir/city_states.rb', 'mydir/states_bkp.rb'] 

Ecco la mia soluzione:

excluded_rgx = excluded.map{|e| e+'\.'}.join('|') 
my_rgx = /(^|\/)((?!#{excluded_rgx})[^\.\/]*)\.rb$/ 

mie ipotesi per questa applicazione:

• La stringa da escludere è all'inizio dell'ingresso, o immediatamente dopo una barra.
• Le stringhe consentite terminano con .rb.
• I nomi file consentiti non hanno un carattere . prima dello .rb.

Answer 8

La risposta accettata è buona, ma in realtà è un aggiramento per la mancanza di un operatore di negazione di sottoespressione semplice nelle espressioni regex. Questo è il motivo delle uscite grep --invert-match. Quindi in * nix, puoi ottenere il risultato desiderato usando pipe e una seconda regex.

grep 'something I want' | grep --invert-match 'but not these ones' 

Ancora una soluzione, ma forse più facile da ricordare.

Answer 9

Soluzione:

^(?!.*STRING1|.*STRING2|.*STRING3).*$ 

xxxxxx OK

xxxSTRING1xxx KO (è se si desidera)

xxxSTRING2xxx KO (è se si desidera)

xxxSTRING3xxx KO (è se si desidera)

Answer 10

spero per completare la risposta

Come il Chris specificato Regex Tutorial è un miglior risorsa per imparare regex.

Tuttavia, ha davvero consumato il tempo di leggere.

Faccio un cheatsheet per la convenienza mnemonica.
[], (), {} leader di ogni classe che è facile da ricordare.

Regex = 
{'single_character': ['[]', '.', {'negate':'^'}], 
'capturing_group' : ['()', '|', '\\', 'backreferences and named group'], 
'repetition'  : ['{}', '*', '+', '?', 'greedy v.s. lazy'], 
'anchor'   : ['^', '\b', '$'], 
'non_printable' : ['\n', '\t', '\r', '\f', '\v'], 
'shorthand'  : ['\d', '\w', '\s'], 
}