Come posso abbinare qualsiasi personaggio su più righe in un'espressione regolare?

Ad esempio, questa regex

(.*)<FooBar>

corrisponderà:

abcde<FooBar>

Ma come faccio ad abbinarlo su più righe?

abcde
fghij<FooBar>

Dipende dalla lingua, ma dovrebbe esserci un modificatore che puoi aggiungere al modello regex. In PHP è:

/(.*)<FooBar>/s

La s alla fine fa sì che il punto corrisponda a tutti i caratteri, comprese le nuove linee.

Prova questo:

((.|\n)*)<FooBar>

In pratica dice "qualsiasi personaggio o una nuova riga" ripetuto zero o più volte.

La domanda è: può un .modello adattarsi a qualsiasi personaggio? La risposta varia da motore a motore. La differenza principale è se il pattern viene utilizzato da una libreria regex POSIX o non POSIX.

Nota speciale su lua-patterns: non sono considerati espressioni regolari, ma .corrispondono a qualsiasi carattere lì, come i motori basati su POSIX.

Un'altra nota su mATLAB e ottava: .corrisponde a qualsiasi carattere predefinito ( demo ): str = "abcde\n fghij<Foobar>"; expression = '(.*)<Foobar>*'; [tokens,matches] = regexp(str,expression,'tokens','match');( tokenscontiene un abcde\n fghijoggetto).

Inoltre, in tutto IncrementoLe grammatiche regex del punto corrispondono alle interruzioni di riga per impostazione predefinita. La grammatica ECMAScript di Boost ti consente di disattivarlo con regex_constants::no_mod_m( sorgente ).

Quanto a oracolo(è basato su POSIX), utilizzare l' nopzione ( demo ):select regexp_substr('abcde' || chr(10) ||' fghij<Foobar>', '(.*)<Foobar>', 1, 1, 'n', 1) as results from dual

Motori basati su POSIX :

Un semplice .abbina già le interruzioni di riga, non è necessario utilizzare alcun modificatore, vedibash( demo ).

Il TCL( demo ),PostgreSQL( demo ),r(TRE, motore predefinito di base R con no perl=TRUE, per base R con perl=TRUEo per schemi stringr / stringi , utilizzare il (?s)modificatore inline) ( demo ) anche trattare .allo stesso modo.

Tuttavia , la maggior parte degli strumenti basati su POSIX elabora l'input riga per riga. Quindi, .non corrisponde alle interruzioni di riga solo perché non rientrano nell'ambito. Ecco alcuni esempi su come sovrascrivere questo:

• sed- Esistono diverse soluzioni alternative, la più precisa ma non molto sicura è sed 'H;1h;$!d;x; s/\(.*\)><Foobar>/\1/'( H;1h;$!d;x;assorbe il file in memoria). Se devono essere incluse intere righe, sed '/start_pattern/,/end_pattern/d' file(la rimozione dall'inizio termina con le righe corrispondenti incluse) o sed '/start_pattern/,/end_pattern/{{//!d;};}' file(con le righe corrispondenti escluse) può essere preso in considerazione.
• perl- perl -0pe 's/(.*)<FooBar>/$1/gs' <<< "$str"( -0assorbe l'intero file in memoria, -pstampa il file dopo aver applicato lo script fornito da -e). Si noti che l'utilizzo -000peridurrà il file e attiverà la "modalità paragrafo" in cui Perl utilizza newline consecutive ( \n\n) come separatore dei record.
• GNU-grep- grep -Poz '(?si)abc\K.*?(?=<Foobar>)' file. Qui, zabilita (?s)lo slurping dei file, abilita la modalità DOTALL per il .modello, (?i)abilita la modalità senza distinzione tra maiuscole e minuscole, \Komette il testo corrispondente finora, *?è un quantificatore pigro, (?=<Foobar>)corrisponde alla posizione precedente <Foobar>.
• pcregrep- pcregrep -Mi "(?si)abc\K.*?(?=<Foobar>)" file( Mabilita lo slurping dei file qui). Nota pcregrepè una buona soluzione per gli greputenti di Mac OS .

Guarda le demo .

Motori non basati su POSIX :

• php- Usa il smodificatore modificatore PCRE_DOTALL : preg_match('~(.*)<Foobar>~s', $s, $m)( demo )
• c #- Usa RegexOptions.Singlelineflag ( demo ):
  - var result = Regex.Match(s, @"(.*)<Foobar>", RegexOptions.Singleline).Groups[1].Value;
  -var result = Regex.Match(s, @"(?s)(.*)<Foobar>").Groups[1].Value;
• powershell- Usa (?s)l'opzione in linea:$s = "abcde`nfghij<FooBar>"; $s -match "(?s)(.*)<Foobar>"; $matches[1]
• perl- Usa il smodificatore (o la (?s)versione incorporata all'inizio) ( demo ):/(.*)<FooBar>/s
• pitone- Usa re.DOTALL(o re.S) flag o (?s)modificatore inline ( demo ): m = re.search(r"(.*)<FooBar>", s, flags=re.S)(e poi if m:, print(m.group(1)))
• Giava- Usa Pattern.DOTALLmodificatore (o (?s)flag incorporato ) ( demo ):Pattern.compile("(.*)<FooBar>", Pattern.DOTALL)
• Groovy- Usa il (?s)modificatore in-pattern ( demo ):regex = /(?s)(.*)<FooBar>/
• Scala- Usa (?s)modificatore ( demo ):"(?s)(.*)<Foobar>".r.findAllIn("abcde\n fghij<Foobar>").matchData foreach { m => println(m.group(1)) }
• javascript- Utilizzo [^]o soluzioni alternative [\d\D]/ [\w\W]/ [\s\S]( demo ):s.match(/([\s\S]*)<FooBar>/)[1]
• C ++( std::regex) Utilizzare [\s\S]o le soluzioni alternative JS ( demo ):regex rex(R"(([\s\S]*)<FooBar>)");

• VBA vbscript- Utilizzare lo stesso approccio in JavaScript, ([\s\S]*)<Foobar>. ( NOTA : a volte si ritiene erroneamente che la MultiLineproprietà RegExpdell'oggetto sia l'opzione per consentire la .corrispondenza tra le interruzioni di riga, mentre, in realtà, cambia solo il comportamento ^e $per far coincidere l'inizio / la fine delle righe anziché le stringhe , come in JS regex ) comportamento.)

• rubino- Usa il modificatore /m MULTILINE ( demo ):s[/(.*)<Foobar>/m, 1]

• rtrebase-r- Base R PCRE regexps - uso (?s): regmatches(x, regexec("(?s)(.*)<FooBar>",x, perl=TRUE))[[1]][2]( demo )
• ricustringrstringi- le funzioni in stringr/ stringiregex che sono alimentate con il motore regex ICU, usano anche (?s): stringr::str_match(x, "(?s)(.*)<FooBar>")[,2]( demo )
• partire- Usa il modificatore inline (?s)all'avvio ( demo ):re: = regexp.MustCompile(`(?s)(.*)<FooBar>`)
• veloce- Utilizzare dotMatchesLineSeparatorso (più semplice) passare il (?s)modificatore in linea al modello:let rx = "(?s)(.*)<Foobar>"
• Obiettivo-c- Come Swift, (?s)funziona nel modo più semplice, ma ecco come può essere utilizzata l' opzione :NSRegularExpression* regex = [NSRegularExpression regularExpressionWithPattern:pattern options:NSRegularExpressionDotMatchesLineSeparators error:&regexError];
• RE2, google-apps-script- Usa (?s)modificatore ( demo ): "(?s)(.*)<Foobar>"(in Google Spreadsheets, =REGEXEXTRACT(A2,"(?s)(.*)<Foobar>"))

NOTE SU(?s) :

Nella maggior parte dei motori non POSIX, è (?s)possibile utilizzare il modificatore inline (o l'opzione flag incorporata) per applicare le .interruzioni di riga.

Se posizionato all'inizio del modello, (?s)cambia il comportamento di tutti .nel modello. Se (?s)viene posizionato da qualche parte dopo l'inizio, .saranno interessati solo quelli che si trovano alla sua destra a meno che questo non sia uno schema passato a Python re. In Python re, indipendentemente dalla (?s)posizione, l'intero modello .è interessato. L' (?s)effetto viene interrotto usando (?-s). Un gruppo modificato può essere utilizzato per influenzare solo un intervallo specificato di un modello regex (ad es. Delim1(?s:.*?)\nDelim2.*Farà la prima .*?corrispondenza tra le nuove linee e la seconda .*corrisponderà solo al resto della linea).

Nota POSIX :

Nei motori regex non POSIX, per abbinare qualsiasi carattere, [\s\S]/ [\d\D]/ [\w\W]costrutti possono essere utilizzati.

In POSIX, [\s\S]non corrisponde alcun carattere (come in JavaScript o qualsiasi motore non POSIX) perché le sequenze di escape regex non sono supportate all'interno delle espressioni parentesi. [\s\S]viene analizzato come espressioni di parentesi che corrispondono a un singolo carattere \o soppure S.

Se stai usando la ricerca Eclipse, puoi abilitare l'opzione "DOTALL" per creare '.' corrisponde a qualsiasi carattere inclusi i delimitatori di riga: aggiungi "(? s)" all'inizio della stringa di ricerca. Esempio:

(?s).*<FooBar>

In molti dialetti regex, /[\S\s]*<Foobar>/farà esattamente quello che vuoi. fonte

([\s\S]*)<FooBar>

Il punto corrisponde a tutti tranne alle nuove righe (\ r \ n). Quindi usa \ s \ S, che corrisponderà a TUTTI i caratteri.

In rubino rubinopuoi usare l' mopzione ' ' (multilinea):

/YOUR_REGEXP/m

Vedere la documentazione di Regexp su ruby-doc.org per ulteriori informazioni.

possiamo anche usare

(.*?\n)*?

per abbinare tutto compreso newline senza avidità

Ciò renderà la nuova linea opzionale

(.*?|\n)*?

"."normalmente non corrisponde alle interruzioni di riga. La maggior parte dei motori regex ti consente di aggiungere il S-flag (chiamato anche DOTALLe SINGLELINE) per far "."corrispondere anche i newline. Se fallisce, potresti fare qualcosa del genere [\S\s].

Per Eclipse ha funzionato la seguente espressione:

foo

jadajada Bar "

Espressione regolare:

Foo[\S\s]{1,10}.*Bar*

/(.*)<FooBar>/s

la s fa sì che Dot (.) corrisponda ai ritorni a capo

Nell'espressione regolare basata su Java puoi usare [\s\S]

Nota che (.|\n)*può essere meno efficiente di (ad esempio) [\s\S]*(se le regex della tua lingua supportano tali escape) e di trovare come specificare il modificatore che rende. abbinare anche le nuove righe. Oppure puoi scegliere POSIX come alternative [[:space:][:^space:]]*.

Usa RegexOptions.Singleline, cambia il significato di. per includere newline

Regex.Replace (contenuto, searchText, replaceText, RegexOptions.Singleline);

Soluzione:

Usa modificatore di pattern sU otterrà la corrispondenza desiderata in PHP.

esempio:

preg_match('/(.*)/sU',$content,$match);

Fonte:

http://dreamluverz.com/developers-tools/regex-match-all-including-new-line http://php.net/manual/en/reference.pcre.pattern.modifiers.php

Nel contesto dell'uso all'interno delle lingue, le espressioni regolari agiscono sulle stringhe, non sulle linee. Quindi dovresti essere in grado di usare normalmente il regex, supponendo che la stringa di input abbia più righe.

In questo caso, la regex fornita corrisponderà all'intera stringa, poiché è presente "<FooBar>". A seconda delle specifiche dell'implementazione di regex, il valore $ 1 (ottenuto da "(. *)") Sarà "fghij" o "abcde \ nfghij". Come altri hanno già detto, alcune implementazioni consentono di controllare se il "." corrisponderà alla nuova riga, dandoti la scelta.

L'uso di espressioni regolari basate su linea è in genere per cose da riga di comando come egrep.

Ho avuto lo stesso problema e risolto probabilmente non nel modo migliore ma funziona. Ho sostituito tutte le interruzioni di riga prima di fare la mia vera partita:

mystring= Regex.Replace(mystring, "\r\n", "")

Sto manipolando HTML, quindi in questo caso le interruzioni di riga non contano davvero per me.

Ho provato tutti i suggerimenti di cui sopra senza fortuna, sto usando .Net 3.5 FYI

In Javascript puoi usare [^] * per cercare da zero a infiniti caratteri, comprese le interruzioni di riga.

$("#find_and_replace").click(function() {
  var text = $("#textarea").val();
  search_term = new RegExp("[^]*<Foobar>", "gi");;
  replace_term = "Replacement term";
  var new_text = text.replace(search_term, replace_term);
  $("#textarea").val(new_text);
});

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<button id="find_and_replace">Find and replace</button>
<br>
<textarea ID="textarea">abcde
fghij&lt;Foobar&gt;</textarea>

generalmente . non corrisponde a newline, quindi prova((.|\n)*)<foobar>

Volevo abbinare un blocco if particolare in Java

   ...
   ...
   if(isTrue){
       doAction();

   }
...
...
}

Se uso regExp

if \(isTrue(.|\n)*}

includeva la parentesi graffa di chiusura per il blocco del metodo, quindi l'ho usato

if \(!isTrue([^}.]|\n)*}

per escludere la parentesi graffa di chiusura dalla corrispondenza dei caratteri jolly.

Spesso dobbiamo modificare una sottostringa con alcune parole chiave sparse tra le righe che precedono la sottostringa. Considera un elemento xml:

<TASK>
  <UID>21</UID>
  <Name>Architectural design</Name>
  <PercentComplete>81</PercentComplete>
</TASK>

Supponiamo di voler modificare 81, ad un altro valore, diciamo 40. Prima identifica .UID.21..UID., quindi salta tutti i caratteri incluso \ntill .PercentCompleted.. Il modello di espressione regolare e la specifica di sostituzione sono:

String hw = new String("<TASK>\n  <UID>21</UID>\n  <Name>Architectural design</Name>\n  <PercentComplete>81</PercentComplete>\n</TASK>");
String pattern = new String ("(<UID>21</UID>)((.|\n)*?)(<PercentComplete>)(\\d+)(</PercentComplete>)");
String replaceSpec = new String ("$1$2$440$6");
//note that the group (<PercentComplete>) is $4 and the group ((.|\n)*?) is $2.

String  iw = hw.replaceFirst(pattern, replaceSpec);
System.out.println(iw);

<TASK>
  <UID>21</UID>
  <Name>Architectural design</Name>
  <PercentComplete>40</PercentComplete>
</TASK>

Il sottogruppo (.|\n)è probabilmente il gruppo mancante $3. Se lo rendiamo non-cattura (?:.|\n)allora $3è (<PercentComplete>). Quindi il modello e replaceSpecpuò anche essere:

pattern = new String("(<UID>21</UID>)((?:.|\n)*?)(<PercentComplete>)(\\d+)(</PercentComplete>)");
replaceSpec = new String("$1$2$340$5")

e la sostituzione funziona correttamente come prima.

In genere la ricerca di tre righe consecutive in Powershell sarebbe simile a:

$file = get-content file.txt -raw

$pattern = 'lineone\r\nlinetwo\r\nlinethree\r\n'     # "windows" text
$pattern = 'lineone\nlinetwo\nlinethree\n'           # "unix" text
$pattern = 'lineone\r?\nlinetwo\r?\nlinethree\r?\n'  # both

$file -match $pattern

# output
True

Stranamente, questo sarebbe unix text al prompt, ma il testo di Windows in un file:

$pattern = 'lineone
linetwo
linethree
'

Ecco un modo per stampare le terminazioni di riga:

'lineone
linetwo
linethree
' -replace "`r",'\r' -replace "`n",'\n'

# output
lineone\nlinetwo\nlinethree\n

opzione 1

Un modo sarebbe usare la sbandiera (proprio come la risposta accettata):

/(.*)<FooBar>/s

Demo 1

opzione 2

Un secondo modo sarebbe quello di usare la mbandiera (multilinea) e uno dei seguenti modelli:

/([\s\S]*)<FooBar>/m

o

/([\d\D]*)<FooBar>/m

o

/([\w\W]*)<FooBar>/m

Demo 2

Circuito RegEx

jex.im visualizza le espressioni regolari: