Wiem, że można dopasować słowo, a następnie odwrócić dopasowania za pomocą innych narzędzi (np grep -v.). Czy można jednak dopasować wiersze, które nie zawierają określonego słowa, np. hedeUżywając wyrażenia regularnego?

Wejście:

hoho
hihi
haha
hede

Kod:

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

Pożądane wyjście:

hoho
hihi
haha

Pojęcie, że wyrażenie regularne nie obsługuje odwrotnego dopasowywania, nie jest do końca prawdziwe. Możesz naśladować to zachowanie, stosując negatywne zmiany:

^((?!hede).)*$

Wyrażenie regularne powyżej będzie pasować do dowolnego łańcucha lub linii bez podziału linii, nie zawierających (pod) łańcucha „hede”. Jak wspomniano, wyrażenie regularne nie jest „dobre” w (lub powinno być), ale nadal jest możliwe.

A jeśli chcesz również dopasować znaki podziału linii, użyj modyfikatora DOT-ALL ( snastępujący wzór:

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

lub użyj go w linii:

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

(gdzie /.../są ogranicznikami wyrażeń regularnych, tj. nie są częścią wzorca)

Jeśli modyfikator DOT-ALL nie jest dostępny, możesz naśladować to samo zachowanie za pomocą klasy znaków [\s\S]:

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

Wyjaśnienie

Łańcuch to tylko lista nznaków. Przed i po każdym znaku jest pusty ciąg. Zatem lista nznaków będzie miała n+1puste ciągi. Rozważ ciąg "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

gdzie esą puste ciągi. Wyrażenie regularne (?!hede).patrzy w przyszłość, aby zobaczyć, czy nie ma podłańcucha "hede", a jeśli tak jest (więc widać coś innego), wówczas .(kropka) będzie pasować do dowolnego znaku z wyjątkiem podziału linii. Rozejrzenia są również nazywane asercjami o zerowej szerokości, ponieważ nie zużywają żadnych znaków. Twierdzą tylko / potwierdzają coś.

Tak więc, w moim przykładzie, każdy pusty łańcuch jest najpierw sprawdzany, czy nie ma "hede"przed nim znaku, zanim znak zostanie zużyty przez .kropkę. Regex (?!hede).będzie zrobić tylko raz, więc jest owinięty w grupie, a powtórzony zero lub więcej razy: ((?!hede).)*. Wreszcie, początek i koniec wejścia są zakotwiczone, aby mieć pewność, że całe wejście zostanie wykorzystane:^((?!hede).)*$

Jak widać, wejście "ABhedeCD"nie powiedzie się, ponieważ on e3, regex (?!hede)zawiedzie ( jest "hede" przed nami!).

Zauważ, że rozwiązanie nie zaczyna się od „hede” :

^(?!hede).*$

jest ogólnie znacznie wydajniejszy niż rozwiązanie, które nie zawiera „hede” :

^((?!hede).)*$

Pierwszy sprawdza „hede” tylko na pierwszej pozycji ciągu wejściowego, a nie na każdej pozycji.

Jeśli używasz go tylko do grep, możesz użyć, grep -v hedeaby uzyskać wszystkie wiersze, które nie zawierają hede.

ETA. Ponowne przeczytanie pytania grep -vjest prawdopodobnie tym, co rozumiesz przez „opcje narzędzi”.

Odpowiedź:

^((?!hede).)*$

Wyjaśnienie:

^początek ciągu, (grupowanie i przechwytywanie do \ 1 (0 lub więcej razy (dopasowanie największej możliwej ilości)),
(?!spójrz w przyszłość, aby zobaczyć, czy nie ma,

hede twój sznurek,

)koniec patrzenia w przód, .dowolny znak oprócz \ n,
)*koniec \ 1 (Uwaga: ponieważ używasz kwantyfikatora w tym przechwytywaniu, tylko OSTATNIE powtórzenie przechwyconego wzoru zostanie zapisane w \ 1)
$przed opcjonalnym \ n, i koniec łańcucha

Podane odpowiedzi są w porządku, tylko akademicki punkt:

Wyrażenia regularne w znaczeniu teoretycznych informatyki NIE MOGĄ tego robić w ten sposób. Dla nich musiało to wyglądać mniej więcej tak:

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

To tylko pasuje PEŁNY. Robienie tego w meczach podrzędnych byłoby jeszcze bardziej niezręczne.

Jeśli chcesz, aby test wyrażenia regularnego zakończył się niepowodzeniem tylko wtedy, gdy cały ciąg znaków jest zgodny, następujące działania będą działać:

^(?!hede$).*

np. Jeśli chcesz zezwolić na wszystkie wartości oprócz „foo” (tzn. „foofoo”, „barfoo” i „foobar” przejdą, ale „foo” nie powiedzie się), użyj: ^(?!foo$).*

Oczywiście, jeśli sprawdzasz dokładność równości, lepszym ogólnym rozwiązaniem w tym przypadku jest sprawdzenie równości ciągów, tj

myStr !== 'foo'

Możesz nawet umieścić negację poza testem, jeśli potrzebujesz funkcji wyrażenia regularnego (w tym przypadku rozróżnianie wielkości liter i dopasowanie zakresu):

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

Rozwiązanie wyrażenia regularnego u góry tej odpowiedzi może być jednak pomocne w sytuacjach, w których wymagany jest pozytywny test wyrażenia regularnego (być może przez API).

FWIW, ponieważ języki regularne (zwane również językami wymiernymi) są zamknięte z dopełnianiem, zawsze można znaleźć wyrażenie regularne (zwane także wyrażeniem wymiernym), które neguje inne wyrażenie. Ale niewiele narzędzi to implementuje.

Vcsn obsługuje ten operator (co oznacza {c}postfiks).

Najpierw zdefiniować typ wyrażeń: Etykiety są list ( lal_char), aby wybrać z a, aby zna przykład (definiowanie alfabetu podczas pracy z uzupełnianie jest oczywiście bardzo ważne), a „wartość” obliczana dla każdego słowa jest po prostu logiczna : truesłowo jest akceptowane false, odrzucone.

W Pythonie:

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} → 𝔹

następnie wpisz wyrażenie:

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

przekonwertuj to wyrażenie na automat:

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

na koniec przekonwertuj ten automat z powrotem na proste wyrażenie.

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

gdzie +jest zwykle oznaczane |, \eoznacza puste słowo i [^]jest zwykle zapisywane .(dowolny znak). Więc przy odrobinie przepisywania ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*.

Możesz zobaczyć ten przykład tutaj i wypróbować Vcsn online tam .

Oto dobre wyjaśnienie, dlaczego nie jest łatwo zanegować arbitralne wyrażenie regularne. Muszę jednak zgodzić się z innymi odpowiedziami: jeśli jest to coś innego niż pytanie hipotetyczne, to wyrażenie regularne nie jest tutaj właściwym wyborem.

W przypadku negatywnego spojrzenia wyrażenie regularne może pasować do czegoś, co nie zawiera określonego wzorca. Odpowiada na to i wyjaśnia Bart Kiers. Świetne wyjaśnienie!

Jednak z odpowiedzią Barta Kiersa część lookahead przetestuje od 1 do 4 znaków z przodu, dopasowując dowolny pojedynczy znak. Możemy tego uniknąć i pozwolić, aby część z wyprzedzeniem sprawdziła cały tekst, upewniając się, że nie ma „hede”, a wtedy normalna część (. *) Może zjeść cały tekst jednocześnie.

Oto ulepszone wyrażenie regularne:

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

Zauważ, że (*?) Leniwy kwantyfikator w negatywnej części z wyprzedzeniem jest opcjonalny, możesz zamiast tego użyć (*) chciwego kwantyfikatora, w zależności od twoich danych: jeśli „hede” występuje i na początku połowy tekstu, leniwy kwantyfikator może bądź szybszy; w przeciwnym razie chciwy kwantyfikator będzie szybszy. Jeśli jednak „hede” się nie pojawi, oba będą równe powolne.

Oto kod demo .

Aby uzyskać więcej informacji o lookahead, zapoznaj się ze świetnym artykułem: Mastering Lookahead and Lookbehind .

Sprawdź także RegexGen.js , generator wyrażeń regularnych JavaScript, który pomaga konstruować złożone wyrażenia regularne. Za pomocą RegexGen.js możesz zbudować wyrażenie regularne w bardziej czytelny sposób:

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()
);

Benchmarki

Postanowiłem ocenić niektóre z przedstawionych Opcji i porównać ich wydajność, a także użyć nowych funkcji. Benchmarking w .NET Regex Engine: http://regexhero.net/tester/

Tekst testu:

Pierwsze 7 wierszy nie powinno się zgadzać, ponieważ zawierają wyszukiwane wyrażenie, a dolne 7 wierszy powinno pasować!

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.

Wyniki:

Wyniki to Iteracje na sekundę jako mediana 3 przebiegów - Większa liczba = lepsza

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

Ponieważ .NET nie obsługuje działań Czasowniki (* FAIL itp.), Nie mogłem przetestować rozwiązań P1 i P2.

Podsumowanie:

Próbowałem przetestować większość proponowanych rozwiązań, niektóre Optymalizacje są możliwe dla niektórych słów. Na przykład, jeśli dwie pierwsze litery szukanego ciągu nie są takie same, odpowiedź 03 można rozszerzyć, aby ^(?>[^R]+|R+(?!egex Hero))*$uzyskać niewielki wzrost wydajności.

Ale ogólnie najbardziej czytelnym i pod względem wydajności najszybszym rozwiązaniem wydaje się być 05 przy użyciu instrukcji warunkowej lub 04 z dodatnim kwantyfikatorem. Myślę, że rozwiązania Perla powinny być jeszcze szybsze i bardziej czytelne.

Nie regex, ale uznałem, że logiczne i użyteczne jest używanie seryjnych grepów z rurką w celu wyeliminowania hałasu.

na przykład. przeszukać plik konfiguracyjny Apache bez wszystkich komentarzy

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

i

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

Logika seryjnego grepa to (nie komentarz) i (pasuje do reż)

dzięki temu unikniesz testowania z wyprzedzeniem każdej pozycji:

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

odpowiednik (dla .net):

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

Stara odpowiedź:

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

Wyżej wspomniane (?:(?!hede).)*jest świetne, ponieważ można je zakotwiczyć.

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

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

W tym przypadku wystarczyłyby:

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

W tym uproszczeniu można dodać klauzule „ORAZ”:

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

Oto jak bym to zrobił:

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

Dokładne i bardziej wydajne niż inne odpowiedzi. Implementuje technikę efektywności „rozwijania pętli” Friedla i wymaga znacznie mniejszego cofania.

Jeśli chcesz dopasować znak, aby zanegować słowo podobne do negacji klasy znaków:

Na przykład ciąg:

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

Nie używaj:

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

Posługiwać się:

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

Uwaga "(?!bbb)."nie jest ani lookbehind ani lookahead, jest lookcurrent, na przykład:

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

Moim zdaniem, bardziej czytelny wariant najwyższej odpowiedzi:

^(?!.*hede)

Zasadniczo „dopasuj na początku wiersza, jeśli i tylko wtedy, gdy nie ma w nim„ hede ”- więc wymaganie przełożyło się prawie bezpośrednio na wyrażenie regularne.

Oczywiście istnieje wiele wymagań dotyczących awarii:

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

Szczegóły: Kotwica ^ zapewnia, że ​​silnik regex nie powtórzy dopasowania w każdym miejscu ciągu, co pasowałoby do każdego łańcucha.

Kotwica ^ na początku ma oznaczać początek linii. Narzędzie grep dopasowuje każdą linię pojedynczo, w kontekstach, w których pracujesz z ciągiem wielowierszowym, możesz użyć flagi „m”:

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

lub

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

OP nie określił ani nie Tagwskazał kontekstu (języka programowania, edytora, narzędzia), w którym będzie używany Regex.

Dla mnie czasami muszę to zrobić podczas edytowania pliku za pomocą Textpad.

Textpad obsługuje niektóre Regex, ale nie obsługuje lookahead ani lookbeind, więc zajmuje to kilka kroków.

Jeśli chcę zachować wszystkie wiersze, które NIE zawierają łańcucha hede, zrobiłbym to w ten sposób:

1. Wyszukaj / zamień cały plik, aby dodać niepowtarzalny „Tag” na początku każdego wiersza zawierającego dowolny tekst.

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

2. Usuń wszystkie wiersze zawierające ciąg hede(ciąg zastępujący jest pusty):

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

3. W tym momencie wszystkie pozostałe linie NIE zawierają łańcucha hede. Usuń unikalny „Tag” ze wszystkich wierszy (ciąg zastępujący jest pusty):

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

Teraz masz oryginalny tekst ze wszystkimi wierszami zawierającymi ciąg znaków hede.

Jeśli chcę zrobić coś innego tylko w wierszach, które NIE zawierają łańcucha hede, zrobiłbym to w ten sposób:

1. Wyszukaj / zamień cały plik, aby dodać niepowtarzalny „Tag” na początku każdego wiersza zawierającego dowolny tekst.

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

2. W przypadku wszystkich wierszy zawierających ciąg hedeusuń unikalny „Tag”:

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

3. W tym momencie wszystkie wiersze rozpoczynające się od unikalnego „Tagu” NIE zawierają łańcucha hede. Mogę teraz zrobić coś innego tylko dla tych linii.

4. Kiedy skończę, usuwam unikalny „Tag” ze wszystkich wierszy (ciąg zastępujący jest pusty):

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

Ponieważ nikt inny nie udzielił bezpośredniej odpowiedzi na zadane pytanie , zrobię to.

Odpowiedź jest taka, że ​​w POSIX grepniemożliwe jest dosłownie spełnienie tego żądania:

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

Powodem jest to, że POSIX grepjest wymagany tylko do pracy z podstawowymi wyrażeniami regularnymi , które po prostu nie są wystarczające do wykonania tego zadania (nie są w stanie analizować zwykłych języków z powodu braku naprzemienności i nawiasów).

Jednak GNU grepimplementuje rozszerzenia, które na to pozwalają. W szczególności \|jest operatorem naprzemiennym w implementacji BREU przez GNU \(i \)jest nawiasami. Jeśli silnik wyrażeń regularnych obsługuje naprzemiennie, wyrażenia z nawiasami ujemnymi, nawiasy i gwiazdę Kleene i jest w stanie zakotwiczyć na początku i na końcu łańcucha, to wszystko, czego potrzebujesz do tego podejścia. Zauważ jednak, że zestawy ujemne [^ ... ]są bardzo wygodne oprócz tych, ponieważ w przeciwnym razie musisz je zastąpić wyrażeniem formy, (a|b|c| ... )która zawiera listę wszystkich znaków, których nie ma w zestawie, co jest niezwykle żmudne i zbyt długie, tym bardziej, jeśli cały zestaw znaków to Unicode.

W przypadku GNU grepodpowiedzią byłoby:

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

(znaleziono z Graalem i kilkoma dalszymi optymalizacjami wykonanymi ręcznie).

Możesz także użyć narzędzia, które implementuje Rozszerzone wyrażenia regularne , na przykład egrep, aby pozbyć się odwrotnych ukośników:

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

Oto skrypt do jego przetestowania (pamiętaj, że generuje plik testinput.txtw bieżącym katalogu):

#!/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)

W moim systemie drukuje:

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

zgodnie z oczekiwaniami.

Dla zainteresowanych szczegółami zastosowana technika polega na konwersji wyrażenia regularnego pasującego do słowa na automat skończony, a następnie odwróceniu automatu poprzez zmianę każdego stanu akceptacji na brak akceptacji i odwrotnie, a następnie konwersję wynikowego FA z powrotem na wyrażenie regularne.

W końcu, jak wszyscy zauważyli, jeśli silnik wyrażeń regularnych obsługuje negatywne spojrzenie, to znacznie upraszcza to zadanie. Na przykład z GNU grep:

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

Aktualizacja: Niedawno znalazłem doskonałą bibliotekę FormalTheory Kendalla Hopkinsa , napisaną w PHP, która zapewnia funkcjonalność podobną do Graala. Używając go i napisanego przeze mnie prostownika, byłem w stanie napisać internetowy generator negatywnych wyrażeń regularnych, podając frazę wejściową (obecnie obsługiwane są tylko znaki alfanumeryczne i spacje): http://www.formauri.es/personal/ pgimeno / misc / non-match-regex /

Do hedewyjścia:

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

co jest równoważne z powyższym.

Od czasu wprowadzenia ruby-2.4.1 możemy używać nowego nieobecnego operatora w wyrażeniach regularnych Ruby

z oficjalnego dokumentu

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

Tak więc w twoim przypadku ^(?~hede)$robi to za Ciebie

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

Przez czasownik PCRE (*SKIP)(*F)

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

To całkowicie pomija linię, która zawiera dokładny ciąg hedei pasuje do wszystkich pozostałych linii.

PRÓBNY

Wykonanie części:

Rozważmy powyższe wyrażenie regularne, dzieląc je na dwie części.

1. Część przed |symbolem. Części nie należy dopasowywać .

   ^hede$(*SKIP)(*F)

2. Część po |symbolu. Część powinna być dopasowana .

   ^.*$

CZĘŚĆ 1

Silnik Regex rozpocznie wykonywanie od pierwszej części.

^hede$(*SKIP)(*F)

Wyjaśnienie:

• ^ Zapewnia, że ​​jesteśmy na początku.
• hede Dopasowuje ciąg hede
• $ Zapewnia, że ​​jesteśmy na końcu linii.

Tak więc linia zawierająca ciąg znaków hedebyłaby dopasowana. Gdy silnik wyrażenia regularnego zobaczy następujący czasownik (*SKIP)(*F)( uwaga: możesz napisać (*F)jako(*FAIL) ), przeskakuje i powoduje niepowodzenie dopasowania. |nazywany zmianą lub logicznym operatorem OR dodanym obok czasownika PCRE, którego inturn pasuje do wszystkich granic istniejących między każdym znakiem na wszystkich liniach, z wyjątkiem tego, że wiersz zawiera dokładny ciąg hede. Zobacz demo tutaj . Oznacza to, że próbuje dopasować znaki z pozostałego ciągu. Teraz wyrażenie regularne w drugiej części zostanie wykonane.

CZĘŚĆ 2

^.*$

Wyjaśnienie:

• ^ Zapewnia, że ​​jesteśmy na początku. tzn. pasuje do wszystkich początków linii oprócz tej w hedelinii. Zobacz demo tutaj .

• .*W trybie wielowierszowym pasowałby do .każdego znaku oprócz znaków nowego wiersza lub znaków powrotu karetki. I *powtórzyłby poprzedni znak zero lub więcej razy. Więc .*pasowałby do całej linii. Zobacz demo tutaj .

  Hej, dlaczego dodałeś. * Zamiast. +?

  Ponieważ .*pasowałby do pustej linii, ale .+nie pasuje do pustej. Chcemy dopasować wszystkie linie, z wyjątkiem tego hede, że na wejściu mogą występować puste linie. więc musisz użyć .*zamiast .+. .+powtórzy poprzedni znak jeden lub więcej razy. Zobacz .*pasuje do pustej linii tutaj .

• $ Zakotwiczenie końca linii nie jest tutaj konieczne.

Może być łatwiejsze do utrzymania do dwóch wyrażeń regularnych w kodzie, jednego do wykonania pierwszego dopasowania, a następnie, jeśli się zgadza, uruchom drugie wyrażenie regularne, aby sprawdzić przypadki odstające, które chcesz na przykład zablokować, ^.*(hede).*a następnie mieć odpowiednią logikę w kodzie.

OK, przyznaję, że tak naprawdę nie jest to odpowiedź na wysłane pytanie i może również wymagać nieco więcej przetwarzania niż jednego wyrażenia regularnego. Ale dla programistów, którzy przybyli tutaj, szukając szybkiej naprawy awaryjnej dla przypadku odstającego, to rozwiązanie nie powinno zostać przeoczone.

TXR Język obsługuje regex negację.

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

Bardziej skomplikowany przykład: dopasuj wszystkie linie, które zaczynają się ai kończą z, ale nie zawierają podłańcucha 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

Negacja Regex sama w sobie nie jest szczególnie przydatna, ale gdy masz również skrzyżowanie, sprawy stają się interesujące, ponieważ masz pełny zestaw operacji na zestawach boolowskich: możesz wyrazić „zestaw, który pasuje do tego, z wyjątkiem rzeczy, które pasują do tego”.

Inną opcją jest dodanie pozytywnego spojrzenia w przyszłość i sprawdzenie, czy hehejest gdzieś w wierszu wprowadzania, wtedy negujemy to, używając wyrażenia podobnego do:

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

z granicami słów.

Wyrażenie to wyjaśniono w prawym górnym panelu strony regex101.com , jeśli chcesz je zbadać / uprościć / zmodyfikować, a pod tym linkiem możesz zobaczyć, jak będzie pasował do niektórych przykładowych danych wejściowych, jeśli chcesz.

RegEx Circuit

jex.im wizualizuje wyrażenia regularne:

Poniższa funkcja pomoże ci uzyskać pożądaną wydajność

<?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).) * $ jest eleganckim rozwiązaniem, z wyjątkiem tego, że zużywa znaki, nie będziesz w stanie połączyć go z innymi kryteriami. Powiedzmy na przykład, że chcesz sprawdzić, czy nie ma „hede” i „haha”. To rozwiązanie działałoby, ponieważ nie zużywa znaków:

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

Jak używać czasowników kontrolnych cofania PCRE, aby dopasować wiersz nie zawierający słowa

Oto metoda, której wcześniej nie widziałem:

/.*hede(*COMMIT)^|/

Jak to działa

Najpierw próbuje znaleźć „hede” gdzieś w linii. Jeśli się powiedzie, w tym momencie (*COMMIT)mówi silnikowi, aby nie tylko nie cofał się w przypadku awarii, ale także nie próbował w tym przypadku dokonywać dalszych dopasowań. Następnie próbujemy dopasować coś, co nie może być zgodne (w tym przypadku, ^).

Jeśli wiersz nie zawiera „hede”, wówczas druga alternatywa, pusty wzorzec, z powodzeniem dopasowuje ciąg tematu.

Ta metoda nie jest bardziej wydajna niż negatywne spojrzenie w przyszłość, ale pomyślałem, że po prostu ją tu wrzucę, na wypadek, gdyby ktoś uznał ją za sprytną i znalazł zastosowanie w innych, bardziej interesujących aplikacjach.

Prostszym rozwiązaniem jest użycie operatora non !

Twoja instrukcja if będzie musiała pasować do „zawiera”, a nie do „wyklucza”.

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

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

Wierzę, że projektanci RegEx przewidzieli użycie nie operatorów.

Być może znajdziesz to w Google podczas próby napisania wyrażenia regularnego, które jest w stanie dopasować segmenty linii (w przeciwieństwie do całych linii), które nie zawierają podłańcucha. Zajęło mi to trochę czasu, aby dowiedzieć się, więc podzielę się:

Podany ciąg: <span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>

Chcę dopasować <span>tagi, które nie zawierają podłańcucha „zły”.

/<span(?:(?!bad).)*?>będzie pasować <span class=\"good\">i <span class=\"ugly\">.

Zauważ, że istnieją dwa zestawy (warstwy) nawiasów:

• Najbardziej wewnętrzny dotyczy negatywnego spojrzenia w przyszłość (nie jest to grupa przechwytująca)
• Najbardziej zewnętrzna została zinterpretowana przez Ruby jako grupa przechwytywania, ale nie chcemy, aby była to grupa przechwytywania, więc dodałem?: Na początku i nie jest już interpretowana jako grupa przechwytywania.

Demo w 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\">"]

Za pomocą ConyEdit można użyć wiersza polecenia, cc.gl !/hede/aby uzyskać wiersze, które nie zawierają dopasowania wyrażenia regularnego, lub użyć wiersza polecenia, cc.dl /hede/aby usunąć wiersze zawierające dopasowanie wyrażenia regularnego. Mają ten sam wynik.

Chciałem dodać kolejny przykład, jeśli próbujesz dopasować całą linię, która zawiera ciąg X , ale nie zawiera również ciągu Y. .

Na przykład, powiedzmy, że chcemy sprawdzić, czy nasz adres URL / ciąg znaków zawiera „ smaczne smakołyki ”, o ile nie zawiera nigdzie „ czekolady ”.

Ten wzorzec wyrażenia regularnego działałby (działa również w JavaScript)

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

(na przykład globalne flagi wieloliniowe)

Interaktywny przykład: https://regexr.com/53gv4

mecze

(Te adresy URL zawierają „smaczne smakołyki”, a także nie zawierają „czekolady”)

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

Nie pasuje

(Te adresy URL zawierają gdzieś „czekoladę” - więc nie będą pasować, nawet jeśli zawierają „smaczne smakołyki”)

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