Come abbinare "qualsiasi cosa fino a questa sequenza di caratteri" in un'espressione regolare?

Prendete questa espressione regolare: /^[^abc]/. Questo corrisponderà a ogni singolo carattere all'inizio di una stringa, tranne a, b o c.

Se lo aggiungi *dopo - /^[^abc]*/- l'espressione regolare continuerà ad aggiungere ogni carattere successivo al risultato, fino a quando non incontra uno a, o b , o c .

Ad esempio, con la stringa di origine "qwerty qwerty whatever abc hello", l'espressione corrisponderà a "qwerty qwerty wh".

E se volessi che la stringa corrispondente fosse "qwerty qwerty whatever "

... In altre parole, come posso abbinare tutto fino a (ma non includere) la sequenza esatta "abc" ?

Non hai specificato quale tipo di regex stai usando, ma questo funzionerà in uno dei più popolari che possono essere considerati "completi".

/.+?(?=abc)/

Come funziona

La .+? parte è la versione non avida di .+ (uno o più di qualsiasi cosa). Quando usiamo .+, il motore praticamente corrisponderà a tutto. Quindi, se c'è qualcos'altro nella regex, tornerà indietro nei passaggi cercando di abbinare la parte seguente. Questo è il comportamento avido , che significa quanto più possibile soddisfare .

Durante l'utilizzo .+?, invece di abbinare tutto in una volta e tornare indietro per altre condizioni (se presenti), il motore abbinerà i caratteri successivi per passo fino a quando la parte successiva della regex viene abbinata (di nuovo se presente). Questo è il non avido , il che significa abbinare il minor numero possibile da soddisfare .

/.+X/  ~ "abcXabcXabcX"        /.+/  ~ "abcXabcXabcX"
          ^^^^^^^^^^^^                  ^^^^^^^^^^^^

/.+?X/ ~ "abcXabcXabcX"        /.+?/ ~ "abcXabcXabcX"
          ^^^^                          ^

Dopo che abbiamo , un'asserzione di larghezza pari a zero , uno sguardo intorno . Questa costruzione raggruppata corrisponde al suo contenuto, ma non conta come caratteri corrispondenti ( larghezza zero ). Restituisce solo se è una corrispondenza o meno ( asserzione ).(?={contents})

Quindi, in altri termini, regex /.+?(?=abc)/significa:

Abbina tutti i caratteri il meno possibile fino a quando non viene trovato un "abc", senza contare "abc".

Se stai cercando di catturare tutto fino a "abc":

/^(.*?)abc/

Spiegazione:

( )catturare l'espressione contenuta tra parentesi per accesso utilizzando $1, $2ecc

^ corrisponde all'inizio della riga

.*abbina qualsiasi cosa, ?non avidamente (abbina il numero minimo di caratteri richiesti) - [1]

[1] Il motivo per cui questo è necessario è che altrimenti, nella seguente stringa:

whatever whatever something abc something abc

per impostazione predefinita, le regex sono avide , il che significa che corrisponderà il più possibile. Pertanto /^.*abc/corrisponderebbe "qualunque cosa qualunque cosa abc qualcosa". L'aggiunta del quantificatore non avido ?fa corrispondere la regex solo "qualunque cosa sia".

Come sottolineato da @Jared Ng e @Issun, la chiave per risolvere questo tipo di RegEx come "abbinare tutto fino a una determinata parola o sottostringa" o "abbinare tutto dopo una determinata parola o sottostringa" è chiamata "lookaround" affermazioni a lunghezza zero . Leggi di più su di loro qui.

Nel tuo caso particolare, può essere risolto con uno sguardo positivo in avanti: .+?(?=abc)

Un'immagine vale più di mille parole. Vedi la spiegazione dei dettagli nello screenshot.

Ciò di cui hai bisogno è guardarti attorno come un'affermazione .+? (?=abc).

Vedi: Lookahead e Lookbehind Zero-Length Assertions

Sii consapevole che [abc]non è lo stesso di abc. Tra parentesi non è una stringa: ogni personaggio è solo una delle possibilità. Fuori dalle parentesi diventa la stringa.

Per regex in Java, e credo anche nella maggior parte dei motori regex, se si desidera includere l'ultima parte funzionerà:

.+?(abc)

Ad esempio, in questa riga:

I have this very nice senabctence

seleziona tutti i caratteri fino a "abc" e includi anche abc

usando il nostro regex, il risultato sarà: I have this very nice senabc

Prova questo: https://regex101.com/r/mX51ru/1

Ho finito con questa domanda StackOverflow dopo aver cercato aiuto per risolvere il mio problema ma non ho trovato alcuna soluzione :(

Quindi ho dovuto improvvisare ... dopo qualche tempo sono riuscito a raggiungere la regex di cui avevo bisogno:

Come puoi vedere, avevo bisogno di una cartella prima della cartella "grp-bps", senza includere l'ultimo trattino. Ed era necessario disporre di almeno una cartella dopo la cartella "grp-bps".

modificare

Versione testo per copia-incolla (cambia 'grp-bps' per il tuo testo):

.*\/grp-bps\/[^\/]+

Questo avrà senso su regex.

1. La parola esatta può essere ottenuta dal seguente comando regex:

( "(. *?)") / G

Qui, possiamo ottenere la parola esatta a livello globale che appartiene all'interno delle doppie virgolette. Ad esempio, se il nostro testo di ricerca è,

Questo è l'esempio per le parole "tra virgolette doppie"

allora otterremo "doppie citazioni" da quella frase.

Su Python:

.+?(?=abc) funziona per il caso a riga singola.

[^]+?(?=abc)non funziona, poiché python non riconosce [^] come regex valido. Per far funzionare la corrispondenza su più righe, è necessario utilizzare l'opzione re.DOTALL, ad esempio:

re.findall('.+?(?=abc)', data, re.DOTALL)

Credo che tu abbia bisogno di sottoespressioni. Se ricordo bene, puoi usare le ()parentesi normali per le sottoespressioni.

Questa parte è dal manuale grep:

 Back References and Subexpressions
       The back-reference \n, where n is a single digit, matches the substring
       previously matched  by  the  nth  parenthesized  subexpression  of  the
       regular expression.

Fare qualcosa come ^[^(abc)]dovrebbe fare il trucco.

Il $ segna la fine di una stringa, in modo da qualcosa come questo dovrebbe funzionare: [[^abc]*]$dove si sta cercando qualcosa che non terminano in qualsiasi iterazione abc, ma avrebbe dovuto essere alla fine

Inoltre, se stai usando un linguaggio di scripting con regex (come php o js), hanno una funzione di ricerca che si interrompe quando incontra per la prima volta un pattern (e puoi specificare start da sinistra o start da destra, o con php, puoi fare un'implosione per rispecchiare la stringa).

prova questo

.+?efg

Query:

select REGEXP_REPLACE ('abcdefghijklmn','.+?efg', '') FROM dual;

produzione :

hijklmn