Come si scrive una espressione regolare per far corrispondere qualsiasi stringa che non soddisfa un particolare schema? Sono di fronte a una situazione in cui devo abbinare un modello (A e ~ B).Regex - come abbinare tutto tranne un particolare motivo
Si potrebbe utilizzare un'asserzione look-ahead:
(?!999)\d{3}
Questo esempio corrisponde a tre cifre diverse da 999.
Ma se vi capita di non avere un'implementazione espressione regolare con questa funzione (vedere Comparison of Regular Expression Flavors), probabilmente necessario costruire un'espressione regolare con le caratteristiche di base per conto proprio.
Un'espressione regolare compatibile con sintassi di base solo sarebbe:
[0-8]\d\d|\d[0-8]\d|\d\d[0-8]
questo non corrisponde con nessun anche tre sequenza di cifre che non è 999.
Combinare lo schema e utilizzare la lingua host per invertire il risultato booleano della partita. Questo sarà molto più leggibile e mantenibile.
Quindi mi ritrovo con (~ A o B) anziché (A e ~ B) Non risolve il mio problema – notnot
Pseudo-codice: String toTest; if (toTest.matches (A) AND! ToTest.matches (B)) {...} –
Avrei dovuto essere più chiaro - i pezzi non sono completamente indipendenti: se A corrisponde a una parte della stringa, ci interessa se ~ B corrisponde al resto di esso (ma non necessariamente tutto). Questo era per la funzione findstr della riga di comando di Windows, che ho trovato è limitato a regex reali, quindi punto controverso. – notnot
Il complemento di una lingua normale è anche un linguaggio normale, ma per costruirlo è necessario creare il DFA per la lingua normale e apportare eventuali modifiche di stato valide in un errore. Vedere this per un esempio. Quello che la pagina non dice è che ha convertito /(ac|bd)/ in /(a[^c]?|b[^d]?|[^ab])/. La conversione da un DFA a un'espressione regolare non è banale. È più facile se puoi usare l'espressione regolare immutata e cambiare la semantica nel codice, come suggerito in precedenza.
Se avessi a che fare con le regex effettive, tutto ciò sarebbe discutibile. Regex ora sembra riferirsi al nebuloso spazio CSG-ish (?) Del pattern matching che supporta la maggior parte delle lingue. Dato che ho bisogno di corrispondere (A e ~ B), non c'è modo di rimuovere la negazione e continuare a fare tutto in un solo passaggio. – notnot
Lookahead, come descritto sopra, lo avrebbe fatto se findstr avesse fatto qualcosa oltre le regex di DFA. Il tutto è un po 'strano e non so perché devo fare questo stile da riga di comando (batch ora). È solo un altro esempio delle mie mani legate. – notnot
@notnot: stai usando findstr da Windows? Allora hai solo bisogno di/v. Come: findstr Un file di input | findstr/v B> outputfile.txt Il primo corrisponde a tutte le linee con A, il secondo corrisponde a tutte le linee che non hanno B. – Juliano
Probabilmente vorrai dire che devi unirti di nuovo. – tomdemuyt
Un approccio simile sta usando 'replace' ' str.replace (/ re/g, '') ', quindi non è necessario ricongiungerli. anche se si butta in un file \ s? come 'str.replace (/ \ re \ s?/g, '')' poi ti sbarazzi degli spazi duplicati che avresti da qualcosa che viene sostituito nel mezzo di una stringa – jakecraige
(B)|(A)
quindi utilizzare quale gruppo 2 cattura ...
Ha bisogno di * catturare * non B, il suo scopo non è quello di ignorare tutti i modelli B. – hexicle
Forse è sbagliato, ma era esattamente quello che stavo cercando – user3473534
Se si desidera far corrispondere una parola A in una stringa e di non abbinare una parola B. Per esempio: Se hai un testo:
1. I have a two pets - dog and a cat
2. I have a pet - dog
Se si desidera effettuare la ricerca per le linee di testo che avere un cane per un animale domestico e NON HA gatto è possibile utilizzare questa espressione regolare:
^(?=.*?\bdog\b)((?!cat).)*$
troverà solo la seconda linea:
2. I have a pet - dog
Non l'ha menzionato nella domanda, ma l'OP sta effettivamente usando il comando DOS 'findstr'. Offre solo un piccolo sottoinsieme delle funzionalità che ci si aspetta di trovare in uno strumento regex; lookahead non è tra questi. (Ho appena aggiunto il tag [tag: findstr].) –
hm, sì, l'ho trovato in uno dei suoi commenti sui post. Ho visto Regex nel titolo. Ad ogni modo, se qualcuno trova questo post quando cerca lo stesso per l'espressione regolare, come ho fatto io, forse potrebbe essere utile a qualcuno :) grazie per i commenti – Aleks
Grazie Aleks. Proprio come hai immaginato, mi sono imbattuto in questa domanda a causa del titolo e hai risposto molto bene per me. – Hagelt18
notnot, resuscitare questa antica domanda perché aveva una soluzione semplice che wasn' ho menzionato (Trova la tua domanda mentre fai qualche ricerca per un regex bounty quest.)
Sono di fronte a una situazione in cui devo corrispondere a uno schema (A e ~ B) .
l'espressione regolare di base per questo è spaventosamente semplice: B|(A)
Basta ignorare le partite complessive e di esaminare le catture del gruppo 1, che conterrà A.
Un esempio (con tutte le rinunce su parsing html regex): a è cifre, B è all'interno cifre <a tag
La regex: <a.*?<\/a>|(\d+)
Demo (vedi gruppo 1 nel riquadro in basso a destra)
Riferimento
La mia risposta qui potrebbe risolvere il problema così:
https://stackoverflow.com/a/27967674/543814
$1, leggere il gruppo $2.$2 è stato reso non-catturante lì, che si eviterebbe.Esempio:
Regex.Match("50% of 50% is 25%", "(\d+\%)|(.+?)");
Il primo gruppo di cattura specifica il modello che si vuole evitare. L'ultimo gruppo catturante cattura tutto il resto. Basta leggere quel gruppo, $2.
Look-ahead non è una sintassi di espressione regolare standard, è un'estensione Perl, funzionerà solo in Perl, PCRE (RegEx compatibile con Perl) o altre implementazioni non standard – Juliano
Potrebbe non essere standard, ma non la maggior parte delle lingue moderne lo supporta? In che lingua * non * viene supportato lo sguardo avanti di questi tempi? –
È vero. Ma la maggior parte degli aromi regex supporta questa funzione (vedi). –
Gumbo