So che è possibile abbinare una parola e quindi invertire le partite usando altri strumenti (ad es grep -v.). Tuttavia, è possibile abbinare le righe che non contengono una parola specifica, ad esempio hedeusando un'espressione regolare?

Ingresso:

hoho
hihi
haha
hede

Codice:

grep "<Regex for 'doesn't contain hede'>" input

Uscita desiderata:

hoho
hihi
haha

L'idea che regex non supporti la corrispondenza inversa non è del tutto vera. È possibile simulare questo comportamento utilizzando gli sguardi negativi:

^((?!hede).)*$

La regex sopra corrisponderà a qualsiasi stringa o riga senza interruzione di riga, non contenente la (sotto) stringa 'hede'. Come già detto, questo non è qualcosa regex è "buono" a (o dovrebbe fare), ma ancora, è possibile.

E se è necessario abbinare anche i caratteri di interruzione di riga, utilizzare il modificatore DOT-ALL (il trailing snel seguente modello):

/^((?!hede).)*$/s

o usalo in linea:

/(?s)^((?!hede).)*$/

(dove /.../sono i delimitatori regex, ovvero non fanno parte del modello)

Se il modificatore DOT-ALL non è disponibile, è possibile simulare lo stesso comportamento con la classe di caratteri [\s\S]:

/^((?!hede)[\s\S])*$/

Spiegazione

Una stringa è solo un elenco di ncaratteri. Prima e dopo ogni carattere, c'è una stringa vuota. Quindi un elenco di ncaratteri avrà n+1stringhe vuote. Considera la stringa "ABhedeCD":

    ┌──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┐
S = │e1│ A │e2│ B │e3│ h │e4│ e │e5│ d │e6│ e │e7│ C │e8│ D │e9│
    └──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┘

index    0      1      2      3      4      5      6      7

dove esono le stringhe vuote. Il regex (?!hede).guarda avanti per vedere se non ci sono sottostringhe "hede"da vedere, e se questo è il caso (così si vede qualcos'altro), allora il .(punto) corrisponderà a qualsiasi carattere tranne un'interruzione di riga. I look-around sono anche chiamati asserzioni di larghezza zero perché non consumano alcun personaggio. Asseriscono / convalidano solo qualcosa.

Quindi, nel mio esempio, ogni stringa vuota viene prima convalidata per vedere se non c'è "hede"davanti, prima che un carattere venga consumato dal .(punto). La regex (?!hede).farà che solo una volta, per cui è avvolto in un gruppo, e ripetuto zero o più volte: ((?!hede).)*. Infine, l'inizio e la fine dell'input sono ancorati per assicurarsi che l'intero input venga consumato:^((?!hede).)*$

Come si può vedere, l'ingresso "ABhedeCD"non riuscirà perché il e3, l'espressione regolare (?!hede)non riesce (non v'è "hede" più avanti!).

Nota che la soluzione non inizia con "hede" :

^(?!hede).*$

è generalmente molto più efficiente della soluzione per non contenere "hede" :

^((?!hede).)*$

Il primo cerca "hede" solo nella prima posizione della stringa di input, piuttosto che in ogni posizione.

Se lo stai usando per grep, puoi usare grep -v hedetutte le righe che non contengono hede.

ETA Oh, rileggere la domanda, grep -vè probabilmente quello che intendevi per "opzioni degli strumenti".

Risposta:

^((?!hede).)*$

Spiegazione:

^l'inizio della stringa, (raggruppa e acquisisci a \ 1 (0 o più volte (corrispondente alla maggior quantità possibile)),
(?!guarda avanti per vedere se non c'è,

hede la tua corda,

)fine del look-ahead, .qualsiasi carattere tranne \ n,
)*fine di \ 1 (Nota: poiché si sta utilizzando un quantificatore in questa acquisizione, solo l'ULTIMA ripetizione del modello acquisito verrà memorizzata in \ 1)
$prima di un \ n facoltativo, e la fine della stringa

Le risposte fornite sono perfettamente valide, solo un punto accademico:

Le espressioni regolari nel significato di informatica teorica NON SONO IN GRADO di farlo in questo modo. Per loro doveva essere simile a questo:

^([^h].*$)|(h([^e].*$|$))|(he([^h].*$|$))|(heh([^e].*$|$))|(hehe.+$) 

Questo fa solo una partita COMPLETA. Farlo per le partite secondarie sarebbe persino più imbarazzante.

Se si desidera che il test regex fallisca solo se l' intera stringa corrisponde, funzionerà quanto segue:

^(?!hede$).*

es. - Se vuoi consentire tutti i valori tranne "foo" (cioè "foofoo", "barfoo" e "foobar" passeranno, ma "foo" fallirà), usa: ^(?!foo$).*

Naturalmente, se stai verificando l' uguaglianza esatta , una soluzione generale migliore in questo caso è quella di verificare l'uguaglianza delle stringhe, vale a dire

myStr !== 'foo'

Potresti anche mettere la negazione fuori dal test se hai bisogno di funzionalità regex (qui, insensibilità al maiuscolo e intervallo):

!/^[a-f]oo$/i.test(myStr)

La soluzione regex nella parte superiore di questa risposta può essere utile, tuttavia, nelle situazioni in cui è richiesto un test regex positivo (forse da un'API).

FWIW, poiché le lingue regolari (ovvero le lingue razionali) sono chiuse in modo complementare, è sempre possibile trovare un'espressione regolare (aka espressione razionale) che nega un'altra espressione. Ma non molti strumenti implementano questo.

Vcsn supporta questo operatore (che indica {c}, postfisso).

Per prima cosa definisci il tipo delle tue espressioni: le etichette sono letter ( lal_char) tra cui scegliere aad zesempio (definire l'alfabeto quando si lavora con la complementazione è, ovviamente, molto importante), e il "valore" calcolato per ogni parola è solo un booleano : truela parola è accettata false, respinta.

In Python:

In [5]: import vcsn
        c = vcsn.context('lal_char(a-z), b')
        c
Out[5]: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z} → 𝔹

quindi inserisci la tua espressione:

In [6]: e = c.expression('(hede){c}'); e
Out[6]: (hede)^c

converti questa espressione in un automa:

In [7]: a = e.automaton(); a

infine, converti questo automa in una semplice espressione.

In [8]: print(a.expression())
        \e+h(\e+e(\e+d))+([^h]+h([^e]+e([^d]+d([^e]+e[^]))))[^]*

dove di +solito è indicato |, \eindica la parola vuota e di [^]solito è scritto .(qualsiasi carattere). Quindi, con un po 'di riscrittura ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*.

Puoi vedere questo esempio qui e provare Vcsn online lì .

Ecco una buona spiegazione del perché non è facile negare una regex arbitraria. Devo concordare con le altre risposte, però: se questa è qualcosa di diverso da una domanda ipotetica, allora una regex non è la scelta giusta qui.

Con lookahead negativo, l'espressione regolare può corrispondere a qualcosa che non contiene un modello specifico. Questa è la risposta e spiegata da Bart Kiers. Grande spiegazione!

Tuttavia, con la risposta di Bart Kiers, la parte lookahead metterà alla prova da 1 a 4 caratteri in avanti mentre si abbina un singolo personaggio. Possiamo evitarlo e lasciare che la parte lookahead verifichi l'intero testo, assicurandoci che non ci sia 'hede', e quindi la parte normale (. *) Può mangiare l'intero testo in una sola volta.

Ecco la regex migliorata:

/^(?!.*?hede).*$/

Si noti che il quantificatore (*?) Pigro nella parte negativa del lookahead è facoltativo, è possibile utilizzare invece (*) quantificatore avido, a seconda dei dati: se 'hede' è presente e nella metà iniziale del testo, il quantificatore pigro può essere più veloce; altrimenti, il quantificatore avido sarà più veloce. Tuttavia, se "hede" non è presente, entrambi sarebbero ugualmente lenti.

Ecco il codice demo .

Per ulteriori informazioni su lookahead, consulta il fantastico articolo: Mastering Lookahead e Lookbehind .

Inoltre, controlla RegexGen.js , un generatore di espressioni regolari JavaScript che aiuta a costruire espressioni regolari complesse. Con RegexGen.js, puoi costruire il regex in un modo più leggibile:

var _ = regexGen;

var regex = _(
    _.startOfLine(),             
    _.anything().notContains(       // match anything that not contains:
        _.anything().lazy(), 'hede' //   zero or more chars that followed by 'hede',
                                    //   i.e., anything contains 'hede'
    ), 
    _.endOfLine()
);

Punti di riferimenti

Ho deciso di valutare alcune delle Opzioni presentate e di confrontare le loro prestazioni, nonché di utilizzare alcune nuove funzionalità. Benchmarking su .NET Regex Engine: http://regexhero.net/tester/

Testo di riferimento:

Le prime 7 righe non devono corrispondere, poiché contengono l'espressione cercata, mentre le 7 righe inferiori devono corrispondere!

Regex Hero is a real-time online Silverlight Regular Expression Tester.
XRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex HeroRegex HeroRegex HeroRegex HeroRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her Regex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.Regex Hero
egex Hero egex Hero egex Hero egex Hero egex Hero egex Hero Regex Hero is a real-time online Silverlight Regular Expression Tester.
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRegex Hero is a real-time online Silverlight Regular Expression Tester.

Regex Her
egex Hero
egex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her is a real-time online Silverlight Regular Expression Tester.
Nobody is a real-time online Silverlight Regular Expression Tester.
Regex Her o egex Hero Regex  Hero Reg ex Hero is a real-time online Silverlight Regular Expression Tester.

risultati:

I risultati sono Iterazioni al secondo come mediana di 3 corse - Numero più grande = Migliore

01: ^((?!Regex Hero).)*$                    3.914   // Accepted Answer
02: ^(?:(?!Regex Hero).)*$                  5.034   // With Non-Capturing group
03: ^(?>[^R]+|R(?!egex Hero))*$             6.137   // Lookahead only on the right first letter
04: ^(?>(?:.*?Regex Hero)?)^.*$             7.426   // Match the word and check if you're still at linestart
05: ^(?(?=.*?Regex Hero)(?#fail)|.*)$       7.371   // Logic Branch: Find Regex Hero? match nothing, else anything

P1: ^(?(?=.*?Regex Hero)(*FAIL)|(*ACCEPT))  ?????   // Logic Branch in Perl - Quick FAIL
P2: .*?Regex Hero(*COMMIT)(*FAIL)|(*ACCEPT) ?????   // Direct COMMIT & FAIL in Perl

Poiché .NET non supporta i verbi di azione (* FAIL, ecc.) Non ho potuto testare le soluzioni P1 e P2.

Sommario:

Ho provato a testare la maggior parte delle soluzioni proposte, alcune ottimizzazioni sono possibili per certe parole. Ad esempio, se le prime due lettere della stringa di ricerca non sono uguali, la risposta 03 può essere espansa fino ^(?>[^R]+|R+(?!egex Hero))*$a ottenere un piccolo guadagno in termini di prestazioni.

Ma la soluzione complessiva più leggibile e più saggia in termini di prestazioni sembra essere 05 usando un'istruzione condizionale o 04 con il quantificatore possessivo. Penso che le soluzioni Perl dovrebbero essere ancora più veloci e più facilmente leggibili.

Non regex, ma ho trovato logico e utile usare greps seriali con pipe per eliminare il rumore.

per esempio. cerca un file di configurazione di apache senza tutti i commenti

grep -v '\#' /opt/lampp/etc/httpd.conf      # this gives all the non-comment lines

e

grep -v '\#' /opt/lampp/etc/httpd.conf |  grep -i dir

La logica di grep seriale è (non un commento) e (corrisponde a dir)

con questo, eviti di testare un lookahead su ogni posizione:

/^(?:[^h]+|h++(?!ede))*+$/

equivalente a (per .net):

^(?>(?:[^h]+|h+(?!ede))*)$

Vecchia risposta:

/^(?>[^h]+|h+(?!ede))*$/

Quanto (?:(?!hede).)*sopra è ottimo perché può essere ancorato.

^(?:(?!hede).)*$               # A line without hede

foo(?:(?!hede).)*bar           # foo followed by bar, without hede between them

Ma in questo caso sarebbe sufficiente:

^(?!.*hede)                    # A line without hede

Questa semplificazione è pronta per l'aggiunta di clausole "AND":

^(?!.*hede)(?=.*foo)(?=.*bar)   # A line with foo and bar, but without hede
^(?!.*hede)(?=.*foo).*bar       # Same

Ecco come lo farei:

^[^h]*(h(?!ede)[^h]*)*$

Accurato e più efficiente delle altre risposte. Implementa la tecnica di efficienza "svolgendo il ciclo" di Friedl e richiede molto meno backtracking.

Se si desidera abbinare un personaggio per negare una parola simile a negare la classe di caratteri:

Ad esempio, una stringa:

<?
$str="aaa        bbb4      aaa     bbb7";
?>

Non usare:

<?
preg_match('/aaa[^bbb]+?bbb7/s', $str, $matches);
?>

Uso:

<?
preg_match('/aaa(?:(?!bbb).)+?bbb7/s', $str, $matches);
?>

Si noti che "(?!bbb)."non è né lookbehind né lookahead, è lookcurrent, ad esempio:

"(?=abc)abcde", "(?!abc)abcde"

Una, a mio avviso, variante più leggibile della risposta principale:

^(?!.*hede)

Fondamentalmente, "abbina all'inizio della riga se e solo se non ha" hede "al suo interno", quindi il requisito tradotto quasi direttamente in regex.

Naturalmente, è possibile avere più requisiti di errore:

^(?!.*(hede|hodo|hada))

Dettagli: L'ancoraggio ^ assicura che il motore regex non riprovi la corrispondenza in ogni posizione della stringa, che corrisponderebbe a ogni stringa.

L'ancora ^ all'inizio è pensata per rappresentare l'inizio della linea. Lo strumento grep fa corrispondere ciascuna riga una alla volta, in contesti in cui lavori con una stringa multilinea, puoi usare il flag "m":

/^(?!.*hede)/m # JavaScript syntax

o

(?m)^(?!.*hede) # Inline flag

L'OP non ha specificato o Tagil post per indicare il contesto (linguaggio di programmazione, editor, strumento) all'interno del quale verrà utilizzato Regex.

Per me, a volte ho bisogno di farlo mentre modifico un file usando Textpad.

Textpad supporta alcuni Regex, ma non supporta lookahead o lookbehind, quindi richiede alcuni passaggi.

Se sto cercando di conservare tutte le righe che NON contengono la stringa hede, lo farei in questo modo:

1. Cerca / sostituisci l'intero file per aggiungere un "Tag" univoco all'inizio di ogni riga contenente qualsiasi testo.

    Search string:^(.)  
    Replace string:<@#-unique-#@>\1  
    Replace-all  

2. Elimina tutte le righe che contengono la stringa hede( la stringa di sostituzione è vuota):

    Search string:<@#-unique-#@>.*hede.*\n  
    Replace string:<nothing>  
    Replace-all  

3. A questo punto, tutte le righe rimanenti NON contengono la stringa hede. Rimuovi il "Tag" univoco da tutte le righe (la stringa di sostituzione è vuota):

    Search string:<@#-unique-#@>
    Replace string:<nothing>  
    Replace-all  

Ora hai il testo originale con tutte le righe che contengono la stringa hederimossa.

Se sto cercando di fare qualcos'altro solo per le righe che NON contengono la stringa hede, lo farei in questo modo:

1. Cerca / sostituisci l'intero file per aggiungere un "Tag" univoco all'inizio di ogni riga contenente qualsiasi testo.

    Search string:^(.)  
    Replace string:<@#-unique-#@>\1  
    Replace-all  

2. Per tutte le righe che contengono la stringa hede, rimuovere il "Tag" univoco:

    Search string:<@#-unique-#@>(.*hede)
    Replace string:\1  
    Replace-all  

3. A questo punto, tutte le righe che iniziano con il "Tag" univoco, NON contengono la stringa hede. Ora posso fare il mio Something Else solo con quelle righe.

4. Al termine, rimuovo il "Tag" univoco da tutte le righe (la stringa di sostituzione è vuota):

    Search string:<@#-unique-#@>
    Replace string:<nothing>  
    Replace-all  

Poiché nessun altro ha dato una risposta diretta alla domanda che è stata posta , lo farò.

La risposta è che con POSIX grepè impossibile soddisfare letteralmente questa richiesta:

grep "<Regex for 'doesn't contain hede'>" input

Il motivo è che POSIX grepdeve funzionare solo con le espressioni regolari di base , che semplicemente non sono abbastanza potenti per eseguire tale compito (non sono in grado di analizzare le lingue regolari, a causa della mancanza di alternanza e parentesi).

Tuttavia, GNU grepimplementa estensioni che lo consentono. In particolare, \|è l'operatore di alternanza nell'implementazione di BRE delle GNU \(e \)sono le parentesi. Se il tuo motore di espressioni regolari supporta l'alternanza, le espressioni di parentesi negative, le parentesi e la stella di Kleene ed è in grado di ancorare all'inizio e alla fine della stringa, questo è tutto ciò che serve per questo approccio. Si noti tuttavia che gli insiemi negativi [^ ... ]sono molto convenienti in aggiunta a quelli, perché altrimenti, è necessario sostituirli con un'espressione del modulo (a|b|c| ... )che elenca tutti i caratteri che non sono nell'insieme, che è estremamente noioso e eccessivamente lungo, ancor più se l'intero set di caratteri è Unicode.

Con GNU grep, la risposta sarebbe qualcosa del tipo:

grep "^\([^h]\|h\(h\|eh\|edh\)*\([^eh]\|e[^dh]\|ed[^eh]\)\)*\(\|h\(h\|eh\|edh\)*\(\|e\|ed\)\)$" input

(trovato con Graal e alcune ulteriori ottimizzazioni fatte a mano).

Puoi anche utilizzare uno strumento che implementa le espressioni regolari estese , come egrep, per eliminare le barre rovesciate:

egrep "^([^h]|h(h|eh|edh)*([^eh]|e[^dh]|ed[^eh]))*(|h(h|eh|edh)*(|e|ed))$" input

Ecco uno script per testarlo (nota che genera un file testinput.txtnella directory corrente):

#!/bin/bash
REGEX="^\([^h]\|h\(h\|eh\|edh\)*\([^eh]\|e[^dh]\|ed[^eh]\)\)*\(\|h\(h\|eh\|edh\)*\(\|e\|ed\)\)$"

# First four lines as in OP's testcase.
cat > testinput.txt <<EOF
hoho
hihi
haha
hede

h
he
ah
head
ahead
ahed
aheda
ahede
hhede
hehede
hedhede
hehehehehehedehehe
hedecidedthat
EOF
diff -s -u <(grep -v hede testinput.txt) <(grep "$REGEX" testinput.txt)

Nel mio sistema stampa:

Files /dev/fd/63 and /dev/fd/62 are identical

come previsto.

Per coloro che sono interessati ai dettagli, la tecnica utilizzata è quella di convertire l'espressione regolare che corrisponde alla parola in un automa finito, quindi invertire l'automa cambiando ogni stato di accettazione in non accettazione e viceversa, quindi riconvertendo il FA risultante in un'espressione regolare.

Infine, come tutti hanno notato, se il tuo motore di espressione regolare supporta lookahead negativo, questo semplifica molto l'attività. Ad esempio, con GNU grep:

grep -P '^((?!hede).)*$' input

Aggiornamento: Di recente ho trovato l'eccellente libreria FormalTheory di Kendall Hopkins , scritta in PHP, che offre una funzionalità simile a Grail. Usandolo e un semplificatore scritto da me stesso, sono stato in grado di scrivere un generatore online di espressioni regolari negative con una frase di input (solo caratteri alfanumerici e spaziali attualmente supportati): http://www.formauri.es/personal/ pgimeno / misc / non-match-regex /

Per hedeesso produce:

^([^h]|h(h|e(h|dh))*([^eh]|e([^dh]|d[^eh])))*(h(h|e(h|dh))*(ed?)?)?$

che equivale a quanto sopra.

Dall'introduzione di ruby-2.4.1, possiamo usare il nuovo operatore assente nelle espressioni regolari di Ruby

dal documento ufficiale

(?~abc) matches: "", "ab", "aab", "cccc", etc.
It doesn't match: "abc", "aabc", "ccccabc", etc.

Quindi, nel tuo caso, ^(?~hede)$fa il lavoro per te

2.4.1 :016 > ["hoho", "hihi", "haha", "hede"].select{|s| /^(?~hede)$/.match(s)}
 => ["hoho", "hihi", "haha"]

Tramite il verbo PCRE (*SKIP)(*F)

^hede$(*SKIP)(*F)|^.*$

Ciò salta completamente la riga che contiene la stringa esatta hedee corrisponde a tutte le righe rimanenti.

DEMO

Esecuzione delle parti:

Consideriamo il regex sopra suddividendolo in due parti.

1. Parte prima del |simbolo. La parte non deve essere abbinata .

   ^hede$(*SKIP)(*F)

2. Parte dopo il |simbolo. La parte deve essere abbinata .

   ^.*$

PARTE 1

Il motore Regex inizierà la sua esecuzione dalla prima parte.

^hede$(*SKIP)(*F)

Spiegazione:

• ^ Afferma che siamo all'inizio.
• hede Corrisponde alla stringa hede
• $ Afferma che siamo alla fine della linea.

Quindi la riga che contiene la stringa hedeverrebbe abbinata. Quando il motore regex vede il seguente verbo (*SKIP)(*F)( Nota: potresti scrivere (*F)come(*FAIL) ), salta e fa fallire la corrispondenza. |chiamato alterazione o operatore logico OR aggiunto accanto al verbo PCRE che inturn corrisponde a tutti i confini esistenti tra ogni singolo carattere su tutte le righe tranne la riga contiene la stringa esatta hede. Guarda la demo qui . Cioè, cerca di abbinare i caratteri della stringa rimanente. Ora la regex nella seconda parte verrebbe eseguita.

PARTE 2

^.*$

Spiegazione:

• ^ Afferma che siamo all'inizio. cioè, corrisponde a tutti gli inizi della linea tranne quello nella hedelinea. Guarda la demo qui .

• .*Nella modalità multilinea, .corrisponderebbe a qualsiasi carattere tranne i caratteri di ritorno a capo o a capo. E *ripeterebbe il carattere precedente zero o più volte. Quindi .*corrisponderebbe all'intera linea. Guarda la demo qui .

  Ehi, perché hai aggiunto. * Invece di. +?

  Perché .*corrisponderebbe a una riga vuota ma .+non corrisponderà a uno spazio vuoto. Vogliamo abbinare tutte le linee tranne hede, ci può essere una possibilità di linee vuote anche nell'input. quindi devi usare .*invece di .+. .+ripeterebbe il personaggio precedente una o più volte. Vedi le .*corrispondenze una riga vuota qui .

• $ L'ancoraggio di fine linea non è necessario qui.

Potrebbe essere più gestibile per due regex nel codice, uno per eseguire la prima corrispondenza, e quindi se corrisponde eseguire la seconda regex per verificare i casi anomali che si desidera bloccare, ad esempio ^.*(hede).*avere una logica appropriata nel codice.

OK, ammetto che questa non è in realtà una risposta alla domanda postata e potrebbe anche utilizzare un po 'più di elaborazione rispetto a una singola regex. Ma per gli sviluppatori che sono venuti qui alla ricerca di una rapida soluzione di emergenza per un caso anomalo, questa soluzione non deve essere trascurata.

Un'altra opzione è quella di aggiungere un aspetto positivo e verificare se si hehetrova in qualsiasi punto della riga di input, quindi lo negheremmo, con un'espressione simile a:

^(?!(?=.*\bhede\b)).*$

con limiti di parole.

L'espressione è spiegata nel pannello in alto a destra di regex101.com , se si desidera esplorarlo / semplificarlo / modificarlo, e in questo collegamento , è possibile vedere come corrisponderebbe con alcuni input di esempio, se lo si desidera.

Circuito RegEx

jex.im visualizza le espressioni regolari:

Il linguaggio TXR supporta la negazione regex.

$ txr -c '@(repeat)
@{nothede /~hede/}
@(do (put-line nothede))
@(end)'  Input

Un esempio più complicato: abbina tutte le righe che iniziano ae finiscono con z, ma non contengono la sottostringa hede:

$ txr -c '@(repeat)
@{nothede /a.*z&~.*hede.*/}
@(do (put-line nothede))
@(end)' -
az         <- echoed
az
abcz       <- echoed
abcz
abhederz   <- not echoed; contains hede
ahedez     <- not echoed; contains hede
ace        <- not echoed; does not end in z
ahedz      <- echoed
ahedz

La negazione di Regex non è particolarmente utile da sola, ma quando hai anche un incrocio, le cose diventano interessanti, dato che hai un set completo di operazioni booleane: puoi esprimere "l'insieme che corrisponde a questo, tranne per le cose che corrispondono a quello".

La seguente funzione ti aiuterà a ottenere l'output desiderato

<?PHP
      function removePrepositions($text){

            $propositions=array('/\bfor\b/i','/\bthe\b/i'); 

            if( count($propositions) > 0 ) {
                foreach($propositions as $exceptionPhrase) {
                    $text = preg_replace($exceptionPhrase, '', trim($text));

                }
            $retval = trim($text);

            }
        return $retval;
    }


?>

^ ((?! hede).) * $ è una soluzione elegante, tranne perché consuma caratteri che non potrai combinare con altri criteri. Ad esempio, supponi di voler verificare la non presenza di "hede" e la presenza di "haha". Questa soluzione funzionerebbe perché non consumerebbe caratteri:

^ (?!. \ bhede \ b) (? =. \ bhaha \ b)

Come usare i verbi di controllo backtracking di PCRE per abbinare una riga che non contiene una parola

Ecco un metodo che non ho mai visto usato prima:

/.*hede(*COMMIT)^|/

Come funziona

In primo luogo, cerca di trovare "hede" da qualche parte nella linea. In caso di successo, a questo punto, (*COMMIT)indica al motore di non solo tornare indietro in caso di guasto, ma anche di non tentare ulteriori corrispondenze in quel caso. Quindi, proviamo ad abbinare qualcosa che non può corrispondere (in questo caso ^).

Se una riga non contiene "hede", la seconda alternativa, un sottotatro vuoto, corrisponde correttamente alla stringa dell'oggetto.

Questo metodo non è più efficiente di uno sguardo negativo, ma ho pensato di lanciarlo qui nel caso in cui qualcuno lo trovasse elegante e lo trovasse utile per altre applicazioni più interessanti.

Una soluzione più semplice è usare l'operatore not !

L' istruzione if dovrà corrispondere a "contiene" e non corrispondere a "esclude".

var contains = /abc/;
var excludes =/hede/;

if(string.match(contains) && !(string.match(excludes))){  //proceed...

Credo che i progettisti di RegEx abbiano anticipato l'uso di non operatori.

Forse lo troverai su Google mentre provi a scrivere una regex in grado di abbinare segmenti di una linea (al contrario di intere righe) che non contengono una sottostringa. Mi ci è voluto un po 'per capire, quindi condividerò:

Data una stringa: <span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>

Voglio abbinare i <span>tag che non contengono la sottostringa "cattiva".

/<span(?:(?!bad).)*?>corrisponderà <span class=\"good\">e <span class=\"ugly\">.

Si noti che esistono due serie (livelli) di parentesi:

• Quello più interno è per il lookahead negativo (non è un gruppo di acquisizione)
• Il più esterno è stato interpretato da Ruby come gruppo di acquisizione, ma non vogliamo che sia un gruppo di acquisizione, quindi ho aggiunto?: All'inizio e non viene più interpretato come un gruppo di acquisizione.

Demo in Ruby:

s = '<span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>'
s.scan(/<span(?:(?!bad).)*?>/)
# => ["<span class=\"good\">", "<span class=\"ugly\">"]

Con ConyEdit , è possibile utilizzare la riga di comando cc.gl !/hede/per ottenere righe che non contengono la corrispondenza regex oppure utilizzare la riga di comando cc.dl /hede/per eliminare le righe che contengono la corrispondenza regex. Hanno lo stesso risultato.

Volevo aggiungere un altro esempio per se si sta cercando di abbinare una intera linea che contiene la stringa X , ma non contengono anche stringa Y .

Ad esempio, supponiamo di voler verificare se il nostro URL / stringa contiene " gustosi dolcetti ", purché non contenga " cioccolato " da nessuna parte.

Questo modello regex funzionerebbe (funziona anche in JavaScript)

^(?=.*?tasty-treats)((?!chocolate).)*$

(esempio globale, bandiere multilinea)

Esempio interattivo: https://regexr.com/53gv4

fiammiferi

(Questi URL contengono "prelibatezze" e non contengono "cioccolato")

• example.com/tasty-treats/strawberry-ice-cream
• example.com/desserts/tasty-treats/banana-pudding
• example.com/tasty-treats-overview

Non corrisponde

(Questi URL contengono "cioccolato" da qualche parte - quindi non combaciano anche se contengono "prelibatezze")

• example.com/tasty-treats/chocolate-cake
• example.com/home-cooking/oven-roasted-chicken
• example.com/tasty-treats/banana-chocolate-fudge
• example.com/desserts/chocolate/tasty-treats
• example.com/chocolate/tasty-treats/desserts