tester - regular expression javascript example




Un regex per abbinare una sottostringa che non è seguita da una certa altra sottostringa (4)

Provare:

/(?!.*bar)(?=.*foo)^(\w+)$/

test:

blahfooblah            # pass
blahfooblahbarfail     # fail
somethingfoo           # pass
shouldbarfooshouldfail # fail
barfoofail             # fail

Spiegazione dell'espressione regolare

NODE                     EXPLANATION
--------------------------------------------------------------------------------
  (?!                      look ahead to see if there is not:
--------------------------------------------------------------------------------
    .*                       any character except \n (0 or more times
                             (matching the most amount possible))
--------------------------------------------------------------------------------
    bar                      'bar'
--------------------------------------------------------------------------------
  )                        end of look-ahead
--------------------------------------------------------------------------------
  (?=                      look ahead to see if there is:
--------------------------------------------------------------------------------
    .*                       any character except \n (0 or more times
                             (matching the most amount possible))
--------------------------------------------------------------------------------
    foo                      'foo'
--------------------------------------------------------------------------------
  )                        end of look-ahead
--------------------------------------------------------------------------------
  ^                        the beginning of the string
--------------------------------------------------------------------------------
  (                        group and capture to \1:
--------------------------------------------------------------------------------
    \w+                      word characters (a-z, A-Z, 0-9, _) (1 or
                             more times (matching the most amount
                             possible))
--------------------------------------------------------------------------------
  )                        end of \1
--------------------------------------------------------------------------------
  $                        before an optional \n, and the end of the
                           string

Altre espressioni regolari

Se vuoi solo escludere la bar quando è direttamente dopo foo , puoi usare

/(?!.*foobar)(?=.*foo)^(\w+)$/

modificare

Hai apportato un aggiornamento alla tua domanda per renderla specifica.

/(?=.*foo(?!bar))^(\w+)$/

Nuovi test

fooshouldbarpass               # pass
butnotfoobarfail               # fail
fooshouldpassevenwithfoobar    # pass
nofuuhere                      # fail

Nuova spiegazione

(?=.*foo(?!bar)) assicura che venga trovato un foo ma non viene seguito direttamente dalla bar

Ho bisogno di una regex che corrisponda a blahfooblah ma non blahfoobarblah

Voglio che corrisponda solo a foo e tutto ciò che sta intorno a foo, a patto che non sia seguito da bar.

Ho provato ad usare questo: foo.*(?<!bar) che è abbastanza vicino, ma corrisponde a blahfoobarblah . L'aspetto negativo dietro deve corrispondere a qualsiasi cosa e non solo alla barra.

Il linguaggio specifico che sto usando è Clojure che utilizza regex Java sotto il cofano.

EDIT: Più specificamente, ho anche bisogno che passi blahfooblahfoobarblah ma non blahfoobarblahblah .


Hai scritto un commento suggerendo che ti piace lavorare in modo che corrisponda a tutte le parole in una stringa piuttosto che all'intera stringa stessa.

Piuttosto che schiacciare tutto questo in un commento, lo sto postando come una nuova risposta.

Nuovo Regex

/(?=\w*foo(?!bar))(\w+)/

Testo di esempio

foowithbar fooevenwithfoobar notfoobar foohere notfoobarhere butfooisokherebar notfoobarhere andnofuu needsfoo

fiammiferi

foowithbar fooevenwithfoobar foohere butfooisokherebar needsfoo


Per abbinare un foo seguito da qualcosa che non inizia con la bar , prova

foo(?!bar)

La tua versione con lookbehind negativo è effettivamente "match a foo seguito da qualcosa che non termina in bar ". Il .* barblah tutti i barblah e il (?<!bar) guarda indietro a lah e controlla che non corrisponda alla bar , cosa che non fa, quindi l'intero schema corrisponde.


Utilizza invece un look negativo per il futuro:

\s*(?!\w*(bar)\w*)\w*(foo)\w*\s*

Questo ha funzionato per me, spero che aiuti. In bocca al lupo!





clojure