regulares - javascript regex example

¿Cómo hago coincidir cualquier carácter en varias líneas en una expresión regular?

Question

Por ejemplo, esta expresión regular.

(.*)<FooBar>

coincidirá:

abcde<FooBar>

Pero, ¿cómo puedo hacer que coincida en varias líneas?

abcde
fghij<FooBar>

Answer 1

Solución:

Use el modificador de patrón sU obtendrá la coincidencia deseada en PHP.

ejemplo:

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

Fuente:

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

Answer 2

A menudo tenemos que modificar una subcadena con algunas palabras clave repartidas en líneas que preceden a la subcadena. Considere un elemento xml:

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

Supongamos que queremos modificar el 81, a algún otro valor, digamos 40. Primero identifique .UID.21..UID. , luego omita todos los caracteres incluyendo /n hasta .PercentCompleted. . El patrón de expresión regular y la especificación de reemplazo son:

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>

El subgrupo (.|/n) es probablemente el grupo que falta $3 . Si lo hacemos sin captura por (?:.|/n) entonces $3 es (<PercentComplete>) . Así que el patrón y replaceSpec también pueden ser:

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

y el reemplazo funciona correctamente como antes.

Answer 3

Depende del idioma, pero debería haber un modificador que pueda agregar al patrón de expresiones regulares. En PHP es:

/(.*)<FooBar>/s

La s al final hace que el punto coincida con todos los caracteres, incluidas las nuevas líneas.

Answer 4

En Ruby ruby puedes usar la opción '' m '' (multilínea):

/YOUR_REGEXP/m

Consulte la documentación de Regexp en ruby-doc.org para obtener más información.

Answer 5

En JavaScript, use /[/S/s]*<Foobar>/ . source

Answer 6

En el contexto del uso dentro de los idiomas, las expresiones regulares actúan sobre cadenas, no líneas. Por lo tanto, debería poder usar la expresión regular normalmente, suponiendo que la cadena de entrada tiene varias líneas.

En este caso, la expresión regular dada coincidirá con toda la cadena, ya que "<FooBar>" está presente. Dependiendo de los detalles de la implementación de expresiones regulares, el valor de $ 1 (obtenido de "(. *)") Será "fghij" o "abcde / nfghij". Como han dicho otros, algunas implementaciones le permiten controlar si el "." coincidirá con la nueva línea, dándole la opción.

El uso de expresiones regulares basado en líneas es generalmente para cosas de línea de comandos como egrep.

Answer 7

En la expresión regular basada en java puedes usar [/s/S]

Answer 8

La pregunta es, puede . patrón coincide con cualquier personaje? La respuesta varía de un motor a otro. La principal diferencia es si el patrón es usado por una biblioteca de expresiones regulares POSIX o no POSIX.

Nota especial sobre lua-patterns : no se consideran expresiones regulares, pero . coincide con cualquier char allí, igual que los motores basados ​​en POSIX.

Otra nota sobre matlab y octave : la . coincide con cualquier char por defecto ( demo ): str = "abcde/n fghij<Foobar>"; expression = ''(.*)<Foobar>*''; [tokens,matches] = regexp(str,expression,''tokens'',''match''); str = "abcde/n fghij<Foobar>"; expression = ''(.*)<Foobar>*''; [tokens,matches] = regexp(str,expression,''tokens'',''match''); (Los tokens contienen un elemento abcde/n fghij ).

Además, en todas las gramáticas regex de boost , el punto coincide con los saltos de línea por defecto. La gramática ECMAScript de Boost le permite desactivar esto con regex_constants::no_mod_m ( source ).

En cuanto a oracle (se basa en POSIX), use la opción n ( demo ): select regexp_substr(''abcde'' || chr(10) ||'' fghij<Foobar>'', ''(.*)<Foobar>'', 1, 1, ''n'', 1) as results from dual

Motores basados ​​en POSIX :

tcl ( demo ), postgresql ( demo ), r (TRE, motor por defecto de base R sin perl=TRUE , para la base R con perl=TRUE o para los patrones stringr / stringi , use el modificador en línea (?s) ) ( demo ) . Un mero ya coincide con los saltos de línea, no es necesario utilizar modificadores.

Motores no basados ​​en POSIX :

• php - Use s modificador s PCRE_DOTALL modifier : preg_match(''~(.*)<Foobar>~s'', $s, $m) ( demo )
• c# - Use el indicador RegexOptions.Singleline ( demo ):
  - var result = Regex.Match(s, @"(.*)<Foobar>", RegexOptions.Singleline).Groups[1].Value;
  - var result = Regex.Match(s, @"(?s)(.*)<Foobar>").Groups[1].Value;
• powershell : use (?s) opción en línea: $s = "abcde`nfghij<FooBar>"; $s -match "(?s)(.*)<Foobar>"; $matches[1] $s = "abcde`nfghij<FooBar>"; $s -match "(?s)(.*)<Foobar>"; $matches[1]
• perl - Use s modificador s (o (?s) versión en línea al inicio) ( demo ): /(.*)<FooBar>/s
• python : utilice re.DOTALL (o re.S ) o (?s) modificador en línea ( demo ): m = re.search(r"(.*)<FooBar>", s, flags=re.S) ( y luego if m: print(m.group(1)) )
• java - Use el modificador Pattern.DOTALL (o el Pattern.DOTALL línea (?s) ) ( demo ): Pattern.compile("(.*)<FooBar>", Pattern.DOTALL)
• groovy - Use (?s) modificador en el patrón ( demo ): regex = /(?s)(.*)<FooBar>/
• scala - Usar (?s) modificador ( demo ): "(?s)(.*)<Foobar>".r.findAllIn("abcde/n fghij<Foobar>").matchData foreach { m => println(m.group(1)) }
• javascript : use [^] o soluciones [/d/D] / [/w/W] / [/s/S] ( demo ): s.match(/([/s/S]*)<FooBar>/)[1]
• c ++ ( std::regex ) Use [/s/S] o las soluciones de JS ( demo ): regex rex(R"(([/s/S]*)<FooBar>)");
• vba : use el mismo enfoque que en JavaScript, ([/s/S]*)<Foobar> .
• ruby - Usa /m MULTILINE modifier ( demo ): s[/(.*)<Foobar>/m, 1]
• go go : use el modificador en línea (?s) al inicio ( demo ): re: = regexp.MustCompile(`(?s)(.*)<FooBar>`)
• swift - Use dotMatchesLineSeparators o (más fácil) pase el modificador en línea (?s) al patrón: let rx = "(?s)(.*)<Foobar>"
• objective-c - Igual que Swift, (?s) funciona de la manera más fácil, pero aquí es cómo se puede usar la opción : NSRegularExpression* regex = [NSRegularExpression regularExpressionWithPattern:pattern options:NSRegularExpressionDotMatchesLineSeparators error:&regexError];
• re2 google-apps-script google-apps-script - Use (?s) modificador ( demo ): "(?s)(.*)<Foobar>" (en Google Spreadsheets, =REGEXEXTRACT(A2,"(?s)(.*)<Foobar>") )

NOTAS SOBRE (?s) :

En la mayoría de los motores que no son POSIX, se puede usar el modificador en línea (?s) (o la opción de marca incrustada) para hacer cumplir . para que coincida con los saltos de línea.

Si se coloca al inicio del patrón, (?s) cambia el comportamiento de todos . en el patron Si el (?s) se coloca en algún lugar después del comienzo, solo esos . se verán afectados los que se encuentren a la derecha, a menos que este sea un patrón que se pase a Python re . En Python re , independientemente de la ubicación (?s) , todo el patrón . Son afectados. El efecto (?s) se detiene utilizando (?-s) . Se puede usar un grupo modificado para afectar solo un rango específico de un patrón de Delim1(?s:.*?)/nDelim2.* regulares (por ejemplo, Delim1(?s:.*?)/nDelim2.* Hará que la primera .*? Coincida con las nuevas líneas y la segunda .* Solo coincidirá con la resto de la línea).

Nota POSIX :

En motores no regex, para coincidir con cualquier char, se pueden usar construcciones [/s/S] / [/d/D] / [/w/W] .

En POSIX, [/s/S] no coincide con ningún char (como en JavaScript o cualquier motor que no sea POSIX) porque las secuencias de escape de expresiones regulares no son compatibles dentro de las expresiones de corchete. [/s/S] se analiza como expresiones de corchete que coinciden con un solo carácter, / o s o S

Answer 9

Para Eclipse trabajó la siguiente expresión:

Foo

jadajada bar "

Expresión regular:

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

Answer 10

Prueba esto:

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

Básicamente dice que "cualquier carácter o una nueva línea" se repite cero o más veces.

Answer 11

Quería hacer coincidir un particular si bloque en java

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

   }
...
...
}

Si uso el regExp

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

Incluía la llave de cierre para el bloque de método, así que utilicé

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

para excluir la llave de cierre de la coincidencia de comodín.

Answer 12

Si está utilizando la búsqueda de Eclipse, puede habilitar la opción "DOTALL" para hacer ''''. haga coincidir cualquier carácter, incluidos los delimitadores de línea: simplemente agregue "(? s)" al comienzo de la cadena de búsqueda. Ejemplo:

(?s).*<FooBar>

Answer 13

Tenga en cuenta que (.|/n)* puede ser menos eficiente que (por ejemplo) [/s/S]* (si las expresiones regulares de su idioma admiten dichos escapes) y que encontrar la forma de especificar el modificador que hace. también emparejar nuevas líneas. O puede ir con POSIXy alternativas como [[:space:][:^space:]]* .

Answer 14

Tuve el mismo problema y lo resolví, probablemente no de la mejor manera, pero funciona. Reemplacé todos los saltos de línea antes de hacer mi partido real:

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

Estoy manipulando HTML para que los saltos de línea realmente no me importen en este caso.

Intenté todas las sugerencias anteriores sin suerte, estoy usando .Net 3.5 FYI

Answer 15

Utilice RegexOptions.Singleline, cambia el significado de. para incluir nuevas líneas

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

Answer 16

generalmente . no coincide con las nuevas líneas, así que intente ((.|/n)*)<foobar>

Answer 17

también podemos usar

(.*?/n)*?

para que coincida con todo, incluyendo la nueva línea sin codicia

Esto hará que la nueva línea sea opcional.

(.*?|/n)*?

Answer 18

"." Normalmente no coincide con los saltos de línea. La mayoría de los motores de DOTALL SINGLELINE le permiten agregar la marca S (también llamada DOTALL y SINGLELINE ) para hacer "." también emparejar nuevas líneas. Si eso falla, podrías hacer algo como [/S/s] .

Answer 19

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

El punto coincide con todos excepto las líneas nuevas (/ r / n). Entonces usa / s / S, que coincidirá con TODOS los caracteres.

Answer 20

/(.*)<FooBar>/s

la s hace que el punto (.) coincida con los retornos de carro