Je sais qu'il est possible de faire correspondre un mot, puis d'inverser les correspondances à l'aide d'autres outils (par exemple grep -v). Cependant, est-il possible de faire correspondre des lignes qui ne contiennent pas de mot spécifique, par exemple hedeen utilisant une expression régulière?

Contribution:

hoho
hihi
haha
hede

Code:

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

Sortie désirée:

hoho
hihi
haha

L'idée que l'expression régulière ne prend pas en charge la correspondance inverse n'est pas entièrement vraie. Vous pouvez imiter ce comportement à l'aide de contournements négatifs:

^((?!hede).)*$

L'expression régulière ci-dessus correspondra à n'importe quelle chaîne ou ligne sans saut de ligne, ne contenant pas la (sous) chaîne 'hede'. Comme mentionné précédemment, ce n'est pas quelque chose regex est « bon » à (ou devrait faire), mais encore, il est possible.

Et si vous devez également faire correspondre les caractères de saut de ligne, utilisez le modificateur DOT-ALL (la fin sdans le modèle suivant):

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

ou utilisez-le en ligne:

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

(où /.../sont les délimiteurs d'expressions régulières, c'est-à-dire ne faisant pas partie du modèle)

Si le modificateur DOT-ALL n'est pas disponible, vous pouvez imiter le même comportement avec la classe de caractères [\s\S]:

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

Explication

Une chaîne n'est qu'une liste de ncaractères. Avant et après chaque caractère, il y a une chaîne vide. Ainsi, une liste de ncaractères aura n+1des chaînes vides. Considérez la chaîne "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

où les esont les chaînes vides. Le regex (?!hede).regarde en avant pour voir s'il n'y a pas de sous-chaîne "hede"à voir, et si c'est le cas (donc quelque chose d'autre est vu), alors le .(point) correspondra à n'importe quel caractère sauf un saut de ligne. Les ressemblances sont également appelées assertions de largeur nulle car elles ne consomment aucun caractère. Ils ne font qu'affirmer / valider quelque chose.

Ainsi, dans mon exemple, chaque chaîne vide est d'abord validée pour voir s'il n'y en a pas "hede", avant qu'un caractère ne soit consommé par le .(point). Le regex (?!hede).fera qu'une seule fois, il est enveloppé dans un groupe, et répété zéro ou plus: ((?!hede).)*. Enfin, le début et la fin de l'entrée sont ancrés pour s'assurer que l'entrée entière est consommée:^((?!hede).)*$

Comme vous pouvez le voir, l'entrée "ABhedeCD"échouera car e3, le regex (?!hede)échoue (il y a "hede" de l'avance!).

Notez que la solution de ne commence pas par «hede» :

^(?!hede).*$

est généralement beaucoup plus efficace que la solution ne contient pas de "hede" :

^((?!hede).)*$

Le premier vérifie «hede» uniquement à la première position de la chaîne d'entrée, plutôt qu'à chaque position.

Si vous ne l'utilisez que pour grep, vous pouvez utiliser grep -v hedepour obtenir toutes les lignes qui ne contiennent pas de hede.

ETA Oh, en relisant la question, grep -vc'est probablement ce que vous vouliez dire par "options d'outils".

Réponse:

^((?!hede).)*$

Explication:

^le début de la chaîne, le (groupe et la capture à \ 1 (0 fois ou plus (correspondant au plus grand nombre possible)),
(?!regardez en avant pour voir s'il n'y en a pas,

hede votre chaîne,

)fin d'anticipation, .tout caractère sauf \ n,
)*fin de \ 1 (Remarque: comme vous utilisez un quantificateur sur cette capture, seule la DERNIÈRE répétition du motif capturé sera stockée dans \ 1)
$avant un \ n facultatif, et la fin de la chaîne

Les réponses données sont parfaitement bien, juste un point académique:

Les expressions régulières au sens de l'informatique théorique NE SONT PAS CAPABLES de le faire comme ça. Pour eux, cela devait ressembler à ceci:

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

Cela ne fait qu'une correspondance COMPLÈTE. Le faire pour les sous-matchs serait encore plus gênant.

Si vous souhaitez que le test d'expression rationnelle échoue uniquement si la chaîne entière correspond, les éléments suivants fonctionneront:

^(?!hede$).*

par exemple - Si vous souhaitez autoriser toutes les valeurs sauf "foo" (c'est-à-dire "foofoo", "barfoo" et "foobar" passeront, mais "foo" échouera), utilisez: ^(?!foo$).*

Bien sûr, si vous vérifiez l' égalité exacte , une meilleure solution générale dans ce cas est de vérifier l'égalité des chaînes, c'est-à-dire

myStr !== 'foo'

Vous pouvez même mettre la négation en dehors du test si vous avez besoin de fonctionnalités d'expression régulière (ici, insensibilité à la casse et correspondance de plage):

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

La solution de regex en haut de cette réponse peut être utile, cependant, dans les situations où un test de regex positif est requis (peut-être par une API).

FWIW, puisque les langages réguliers (aka langages rationnels) sont fermés par complémentation, il est toujours possible de trouver une expression régulière (aka expression rationnelle) qui nie une autre expression. Mais peu d'outils implémentent cela.

Vcsn prend en charge cet opérateur (qu'il désigne par le {c}suffixe).

Vous définissez d' abord le type de vos expressions: les étiquettes sont lettre ( lal_char) à choisir aà zpar exemple (définir l'alphabet lorsque vous travaillez avec complémentation est, bien sûr, très important), et la « valeur » calculée pour chaque mot est juste un booléen : truele mot est accepté false, rejeté.

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

puis vous entrez votre expression:

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

convertissez cette expression en automate:

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

enfin, reconvertissez cet automate en une expression simple.

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

où +est généralement indiqué |, \edésigne le mot vide et [^]est généralement écrit .(n'importe quel caractère). Donc, avec un peu de réécriture ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*.

Vous pouvez voir cet exemple ici et essayer Vcsn en ligne là-bas .

Voici une bonne explication de la raison pour laquelle il n'est pas facile de nier une expression rationnelle arbitraire. Je dois cependant être d'accord avec les autres réponses: s'il ne s'agit pas d'une question hypothétique, alors l'expression rationnelle n'est pas le bon choix ici.

Avec l'anticipation négative, l'expression régulière peut correspondre à quelque chose qui ne contient pas de motif spécifique. Ceci est répondu et expliqué par Bart Kiers. Grande explication!

Cependant, avec la réponse de Bart Kiers, la partie d'anticipation testera 1 à 4 caractères à l'avance tout en faisant correspondre n'importe quel caractère. Nous pouvons éviter cela et laisser la partie d'anticipation vérifier tout le texte, s'assurer qu'il n'y a pas de «haie», puis la partie normale (. *) Peut manger tout le texte en une seule fois.

Voici l'expression rationnelle améliorée:

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

Notez que le quantificateur paresseux (*?) Dans la partie d'anticipation négative est facultatif, vous pouvez utiliser le quantificateur gourmand (*) à la place, en fonction de vos données: si 'hede' est présent et dans la moitié du début du texte, le quantificateur paresseux peut Être plus rapide; sinon, le quantificateur gourmand sera plus rapide. Cependant, si «hede» n'est pas présent, les deux seraient également lents.

Voici le code de démonstration .

Pour plus d'informations sur Lookahead, veuillez consulter le grand article: Maîtriser Lookahead et Lookbehind .

Consultez également RegexGen.js , un générateur d'expressions régulières JavaScript qui aide à construire des expressions régulières complexes. Avec RegexGen.js, vous pouvez construire le regex d'une manière plus lisible:

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

Repères

J'ai décidé d'évaluer certaines des options présentées et de comparer leurs performances, ainsi que d'utiliser de nouvelles fonctionnalités. Analyse comparative sur .NET Regex Engine: http://regexhero.net/tester/

Texte de référence:

Les 7 premières lignes ne doivent pas correspondre, car elles contiennent l'expression recherchée, tandis que les 7 lignes inférieures doivent correspondre!

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.

Résultats:

Les résultats sont des itérations par seconde comme la médiane de 3 courses - Plus grand nombre = meilleur

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

Étant donné que .NET ne prend pas en charge les verbes d'action (* FAIL, etc.), je n'ai pas pu tester les solutions P1 et P2.

Sommaire:

J'ai essayé de tester la plupart des solutions proposées, certaines optimisations sont possibles pour certains mots. Par exemple, si les deux premières lettres de la chaîne de recherche ne sont pas identiques, la réponse 03 peut être développée pour ^(?>[^R]+|R+(?!egex Hero))*$entraîner un petit gain de performances.

Mais la solution globale la plus lisible et la plus rapide en termes de performances semble être 05 en utilisant une instruction conditionnelle ou 04 avec le quantificateur possessif. Je pense que les solutions Perl devraient être encore plus rapides et plus lisibles.

Pas regex, mais je l'ai trouvé logique et utile d'utiliser des greps série avec un tuyau pour éliminer le bruit.

par exemple. rechercher un fichier de configuration apache sans tous les commentaires-

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

et

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

La logique du grep série est (pas un commentaire) et (correspond à dir)

avec cela, vous évitez de tester une anticipation sur chaque position:

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

équivalent à (pour .net):

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

Ancienne réponse:

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

Ce qui précède (?:(?!hede).)*est génial car il peut être ancré.

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

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

Mais ce qui suit suffirait dans ce cas:

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

Cette simplification est prête à ajouter des clauses "ET":

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

Voici comment je le ferais:

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

Précis et plus efficace que les autres réponses. Il met en œuvre la technique d'efficacité "déroulant la boucle" de Friedl et nécessite beaucoup moins de retour en arrière.

Si vous voulez faire correspondre un caractère pour nier un mot similaire à nier la classe de caractères:

Par exemple, une chaîne:

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

Ne pas utiliser:

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

Utilisation:

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

L'avis "(?!bbb)."n'est ni lookbehind ni lookahead, c'est lookcurrent, par exemple:

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

Une variante, à mon avis, plus lisible de la réponse du haut:

^(?!.*hede)

Fondamentalement, "correspond au début de la ligne si et seulement si elle ne contient pas" hede "" - donc l'exigence s'est traduite presque directement en expression régulière.

Bien sûr, il est possible d'avoir plusieurs exigences de défaillance:

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

Détails: l' ancre ^ garantit que le moteur d'expression régulière ne réessaye pas la correspondance à chaque emplacement de la chaîne, ce qui correspondrait à chaque chaîne.

L'ancre ^ au début est censée représenter le début de la ligne. L'outil grep correspond à chaque ligne une par une, dans les contextes où vous travaillez avec une chaîne multiligne, vous pouvez utiliser l'indicateur "m":

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

ou

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

L'OP n'a pas précisé ni Tagle post pour indiquer le contexte (langage de programmation, éditeur, outil) dans lequel Regex sera utilisé.

Pour moi, je dois parfois le faire lors de l'édition d'un fichier à l'aide de Textpad.

Textpad prend en charge certains Regex, mais ne prend pas en charge lookahead ou lookbehind, donc cela prend quelques étapes.

Si je cherche à conserver toutes les lignes qui NE contiennent PAS la chaîne hede, je le ferais comme ceci:

1. Recherchez / remplacez le fichier entier pour ajouter un "Tag" unique au début de chaque ligne contenant n'importe quel texte.

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

2. Supprimez toutes les lignes contenant la chaîne hede( la chaîne de remplacement est vide):

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

3. À ce stade, toutes les lignes restantes NE contiennent PAS la chaîne hede. Supprimez le "Tag" unique de toutes les lignes (la chaîne de remplacement est vide):

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

Vous avez maintenant le texte d'origine avec toutes les lignes contenant la chaîne hedesupprimées.

Si je cherche à faire quelque chose d'autre uniquement aux lignes qui ne contiennent pas la chaîne hede, je le ferais comme ceci:

1. Recherchez / remplacez le fichier entier pour ajouter un "Tag" unique au début de chaque ligne contenant n'importe quel texte.

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

2. Pour toutes les lignes contenant la chaîne hede, supprimez le "Tag" unique:

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

3. À ce stade, toutes les lignes qui commencent par l'unique "Tag", NE contiennent PAS la chaîne hede. Je peux maintenant faire mon autre chose uniquement pour ces lignes.

4. Lorsque j'ai terminé, je supprime le "Tag" unique de toutes les lignes (la chaîne de remplacement est vide):

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

Puisque personne d'autre n'a donné de réponse directe à la question qui a été posée , je vais le faire.

La réponse est qu'avec POSIX grep, il est impossible de satisfaire littéralement cette demande:

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

La raison en est que POSIX grepn'est requis que pour travailler avec les expressions régulières de base , qui ne sont tout simplement pas assez puissantes pour accomplir cette tâche (elles ne sont pas capables d'analyser les langues normales, en raison du manque d'alternance et de parenthèses).

Cependant, GNU grepimplémente des extensions qui le permettent. En particulier, \|est l'opérateur d'alternance dans la mise en œuvre de BRE par GNU, et \(et \)sont les parenthèses. Si votre moteur d'expression régulière prend en charge l'alternance, les expressions de parenthèses négatives, les parenthèses et l'étoile Kleene, et est capable d'ancrer au début et à la fin de la chaîne, c'est tout ce dont vous avez besoin pour cette approche. Notez cependant que les jeux négatifs [^ ... ]sont très pratiques en plus de ceux-ci, car sinon, vous devez les remplacer par une expression de la forme (a|b|c| ... )qui répertorie tous les caractères qui ne sont pas dans le jeu, ce qui est extrêmement fastidieux et trop long, d'autant plus si l'ensemble des caractères est Unicode.

Avec GNU grep, la réponse serait quelque chose comme:

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

(trouvé avec Graal et quelques optimisations supplémentaires faites à la main).

Vous pouvez également utiliser un outil qui implémente les expressions régulières étendues , comme egreppour supprimer les barres obliques inverses:

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

Voici un script pour le tester (notez qu'il génère un fichier testinput.txtdans le répertoire courant):

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

Dans mon système, il imprime:

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

comme prévu.

Pour ceux qui s'intéressent aux détails, la technique utilisée consiste à convertir l'expression régulière correspondant au mot en un automate fini, puis à inverser l'automate en changeant chaque état d'acceptation en non-acceptation et vice versa, puis en reconvertissant l'AF résultante en une expression régulière.

Enfin, comme tout le monde l'a noté, si votre moteur d'expression régulière prend en charge l'anticipation négative, cela simplifie beaucoup la tâche. Par exemple, avec GNU grep:

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

Mise à jour: J'ai récemment trouvé l'excellente bibliothèque FormalTheory de Kendall Hopkins , écrite en PHP, qui fournit une fonctionnalité similaire à Grail. En l'utilisant, et un simplificateur écrit par moi-même, j'ai pu écrire un générateur en ligne d'expressions régulières négatives avec une phrase d'entrée (seuls les caractères alphanumériques et spatiaux sont actuellement pris en charge): http://www.formauri.es/personal/ pgimeno / misc / non-match-regex /

Car hedeil délivre:

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

qui est équivalent à ce qui précède.

Depuis l'introduction de ruby-2.4.1, nous pouvons utiliser le nouvel opérateur absent dans les expressions régulières de Ruby

du doc officiel

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

Ainsi, dans votre cas, ^(?~hede)$fait le travail pour vous

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

Par le verbe PCRE (*SKIP)(*F)

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

Cela ignorerait complètement la ligne qui contient la chaîne exacte hedeet correspond à toutes les lignes restantes.

DEMO

Exécution des pièces:

Considérons le regex ci-dessus en le divisant en deux parties.

1. Partie devant le |symbole. La pièce ne doit pas correspondre .

   ^hede$(*SKIP)(*F)

2. Partie après le |symbole. La pièce doit être appariée .

   ^.*$

PARTIE 1

Le moteur Regex commencera son exécution à partir de la première partie.

^hede$(*SKIP)(*F)

Explication:

• ^ Affirme que nous sommes au début.
• hede Correspond à la chaîne hede
• $ Affirme que nous sommes à la fin de la ligne.

Ainsi, la ligne qui contient la chaîne hedeserait mise en correspondance. Une fois que le moteur d'expression régulière voit le verbe suivant (*SKIP)(*F)( Remarque: vous pourriez écrire (*F)comme(*FAIL) ), il saute et fait échouer la correspondance. |appelé altération ou opérateur OU logique ajouté à côté du verbe PCRE qui correspond à son tour toutes les frontières existent entre chaque caractère sur toutes les lignes sauf que la ligne contient la chaîne exacte hede. Voir la démo ici . Autrement dit, il essaie de faire correspondre les caractères de la chaîne restante. Maintenant, l'expression régulière dans la deuxième partie serait exécutée.

PARTIE 2

^.*$

Explication:

• ^ Affirme que nous sommes au début. c'est-à-dire qu'il correspond à tous les départs de ligne, sauf celui de la hedeligne. Voir la démo ici .

• .*En mode multiligne, .correspondrait à n'importe quel caractère à l'exception des caractères de retour à la ligne ou de retour chariot. Et *répéterait le caractère précédent zéro ou plusieurs fois. Il en .*serait de même pour toute la ligne. Voir la démo ici .

  Hey pourquoi vous avez ajouté. * Au lieu de. +?

  Parce .*que correspondrait à une ligne vide mais .+ne correspondra pas à un blanc. Nous voulons faire correspondre toutes les lignes sauf hede, il peut y avoir une possibilité de lignes vides également dans l'entrée. vous devez donc utiliser .*au lieu de .+. .+répéterait le caractère précédent une ou plusieurs fois. Voir .*correspond à une ligne vide ici .

• $ L'ancrage de fin de ligne n'est pas nécessaire ici.

Il peut être plus facile à gérer pour deux expressions régulières dans votre code, une pour effectuer la première correspondance, puis si elle correspond, exécutez la deuxième expression régulière pour vérifier les cas aberrants que vous souhaitez bloquer par exemple, ^.*(hede).*puis disposez d'une logique appropriée dans votre code.

OK, j'admets que ce n'est pas vraiment une réponse à la question publiée et qu'il peut également utiliser un peu plus de traitement qu'une seule expression régulière. Mais pour les développeurs qui sont venus ici à la recherche d'une solution d'urgence rapide pour un cas aberrant, cette solution ne doit pas être négligée.

Une autre option est que pour ajouter une anticipation positive et vérifier si se hehetrouve n'importe où dans la ligne d'entrée, nous annulerions cela, avec une expression similaire à:

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

avec des limites de mots.

L'expression est expliquée dans le panneau supérieur droit de regex101.com , si vous souhaitez l'explorer / la simplifier / la modifier, et dans ce lien , vous pouvez voir comment elle correspondrait à certains exemples d'entrées, si vous le souhaitez.

Circuit RegEx

jex.im visualise les expressions régulières:

Le langage TXR prend en charge la négation des expressions rationnelles.

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

Un exemple plus compliqué: faites correspondre toutes les lignes commençant par aet finissant par z, mais ne contenant pas la sous-chaîne 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 négation d'expression régulière n'est pas particulièrement utile en soi, mais lorsque vous avez également une intersection, les choses deviennent intéressantes, car vous avez un ensemble complet d'opérations d'ensemble booléennes: vous pouvez exprimer "l'ensemble qui correspond à ceci, sauf pour les choses qui correspondent à cela".

La fonction ci-dessous vous aidera à obtenir la sortie souhaitée

<?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).) * $ est une solution élégante, sauf qu'il consomme des caractères que vous ne pourrez pas combiner avec d'autres critères. Par exemple, supposons que vous vouliez vérifier la non-présence de "hede" et la présence de "haha". Cette solution fonctionnerait car elle ne consommera pas de caractères:

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

Comment utiliser les verbes de contrôle de retour arrière de PCRE pour faire correspondre une ligne ne contenant pas de mot

Voici une méthode que je n'ai jamais vue utilisée auparavant:

/.*hede(*COMMIT)^|/

Comment ça fonctionne

Tout d'abord, il essaie de trouver "hede" quelque part dans la ligne. En cas de succès, à ce stade, (*COMMIT)indique au moteur non seulement de ne pas revenir en arrière en cas d'échec, mais également de ne pas tenter de correspondance supplémentaire dans ce cas. Ensuite, nous essayons de faire correspondre quelque chose qui ne peut pas correspondre (dans ce cas, ^).

Si une ligne ne contient pas "hede", la deuxième alternative, un sous-modèle vide, correspond avec succès à la chaîne du sujet.

Cette méthode n'est pas plus efficace qu'un lookahead négatif, mais j'ai pensé que je la mettrais ici au cas où quelqu'un la trouverait astucieuse et trouverait une utilisation pour d'autres applications plus intéressantes.

Une solution plus simple consiste à utiliser l'opérateur not !

Votre instruction if devra correspondre à "contient" et non à "exclut".

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

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

Je pense que les concepteurs de RegEx ont prévu de ne pas utiliser d'opérateurs.

Peut-être le trouverez-vous sur Google en essayant d'écrire une expression régulière capable de faire correspondre des segments d'une ligne (par opposition à des lignes entières) qui ne contiennent pas de sous-chaîne. M'a pris un certain temps pour comprendre, alors je vais partager:

Étant donné une chaîne: <span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>

Je veux faire correspondre les <span>balises qui ne contiennent pas la sous-chaîne "bad".

/<span(?:(?!bad).)*?>correspondra <span class=\"good\">et <span class=\"ugly\">.

Notez qu'il existe deux ensembles (couches) de parenthèses:

• L'intérieur est pour l'anticipation négative (ce n'est pas un groupe de capture)
• L'extérieur a été interprété par Ruby comme un groupe de capture, mais nous ne voulons pas que ce soit un groupe de capture, alors j'ai ajouté?: À ses débuts et il n'est plus interprété comme un groupe de capture.

Démo en 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\">"]

Avec ConyEdit , vous pouvez utiliser la ligne de commande cc.gl !/hede/pour obtenir des lignes qui ne contiennent pas la correspondance regex, ou utiliser la ligne de commande cc.dl /hede/pour supprimer les lignes qui contiennent la correspondance regex. Ils ont le même résultat.

Je voulais ajouter un autre exemple si vous essayez de faire correspondre une ligne entière qui contient la chaîne X , mais ne contient pas aussi chaîne Y .

Par exemple, disons que nous voulons vérifier si notre URL / chaîne contient des " gâteries savoureuses ", tant qu'elle ne contient pas de " chocolat " nulle part.

Ce modèle d'expression régulière fonctionnerait (fonctionne également en JavaScript)

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

(drapeaux globaux, multilignes dans l'exemple)

Exemple interactif: https://regexr.com/53gv4

Allumettes

(Ces URL contiennent des "gâteries savoureuses" et ne contiennent pas non plus de "chocolat")

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

Ne correspond pas

(Ces URL contiennent du "chocolat" quelque part - donc elles ne correspondent pas même si elles contiennent des "gâteries savoureuses")

• 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