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

Prueba esto:

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

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

Si estás usando Eclipse search, puedes habilitar la opción "DOTALL" para hacer '.'coincide con cualquier carácter, incluidos los delimitadores de línea: simplemente agregue "(?s)" al principio de la cadena de búsqueda. Ejemplo:

(?s).*<FooBar>

La pregunta es, ¿puede . el patrón coincidir con cualquier carácter? La respuesta varía de un motor a otro. La principal diferencia es si el patrón es utilizado por una biblioteca de expresiones regulares POSIX o no POSIX.

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

Otra a matlab y octava: el . coincide con cualquier carácter por defecto (demo): str = "abcde\n fghij<Foobar>"; expression = '(.*)<Foobar>*'; [tokens,matches] = regexp(str,expression,'tokens','match'); (tokens contendrá 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 te permite desactivar esto con regex_constants::no_mod_m (source ).

En cuanto a oracle (está basado en POSIX), use n opció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, base R motor por defecto con no perl=TRUE, para base R con perl=TRUE o para strintr/stringi patrones, utilice el modificador inline (?s)) (demo ). Un mero . ya coincide con los saltos de línea, sin necesidad de usar ningún modificador.

Motores no basados en POSIX :

• php - Use s modificador Modificador PCRE_DOTALL: preg_match('~(.*)<Foobar>~s', $s, $m) (demo)
• c # - Uso RegexOptions.Singleline flag ( demo):
  - var result = Regex.Match(s, @"(.*)<Foobar>", RegexOptions.Singleline).Groups[1].Value;
  - var result = Regex.Match(s, @"(?s)(.*)<Foobar>").Groups[1].Value;
• powershell - Usar (?s) opción en línea: $s = "abcde`nfghij<FooBar>"; $s -match "(?s)(.*)<Foobar>"; $matches[1]
• perl - Use s modificador (o (?s) versión en línea al inicio) ( demo): /(.*)<FooBar>/s
• python - Use re.DOTALL (o re.S) banderas 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 Pattern.DOTALL modificador (o flag inline (?s) ) (demo): Pattern.compile("(.*)<FooBar>", Pattern.DOTALL)
• groovy - Use (?s) modificador de patrón (demo): regex = /(?s)(.*)<FooBar>/
• scala - Use (?s) modificador ( demo): "(?s)(.*)<Foobar>".r.findAllIn("abcde\n fghij<Foobar>").matchData foreach { m => println(m.group(1)) }
• javascript - Use [^] o soluciones alternativas [\d\D] / [\w\W] / [\s\S] (demo): s.match(/([\s\S]*)<FooBar>/)[1]
• c++ (std::regex) Utilice [\s\S] o las soluciones JS (demo): regex rex(R"(([\s\S]*)<FooBar>)");
• vba - Use el mismo enfoque que en JavaScript, ([\s\S]*)<Foobar>.
• ruby - Use /m Modificador MULTILÍNEA ( demo): s[/(.*)<Foobar>/m, 1]
• go - Usa el modificador inline (?s) al inicio (demo): re: = regexp.MustCompile(`(?s)(.*)<FooBar>`)
• swift - Uso dotMatchesLineSeparators o (más fácil) pasar el modificador inline (?s) al patrón: let rx = "(?s)(.*)<Foobar>"
• objective-c - Igual que Swift, (?s) funciona de la manera más fácil, pero así es como la opción se puede utilizar: NSRegularExpression* regex = [NSRegularExpression regularExpressionWithPattern:pattern options:NSRegularExpressionDotMatchesLineSeparators error:&regexError];
• re2, google-apps-script - Use (?s) modificador (demo): "(?s)(.*)<Foobar>" (en Hojas de cálculo de Google, =REGEXEXTRACT(A2,"(?s)(.*)<Foobar>"))

NOTAS SOBRE (?s):

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

Si se coloca al comienzo del patrón, (?s) cambia el bahavior de todos . en el patrón. Si el (?s) se coloca en algún lugar después del principio, solo se verán afectados aquellos . que se encuentren a la derecha de él a menos que este sea un patrón pasado a Python re. En Python re, independientemente de la ubicación (?s), todo el patrón . se ve afectado. El efecto (?s) se deja de usar (?-s). Un grupo modificado se puede usar para afectar solo un rango especificado de un patrón de expresiones regulares (por ejemplo, Delim1(?s:.*?)\nDelim2.* hará que el primer .*? coincida a través de nuevas líneas y el segundo .* solo coincidirá con el resto de la línea).

Nota POSIX :

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

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.

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

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

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

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

/YOUR_REGEXP/m

Ver la documentación de expresiones regulares en ruby-doc.org para más información.

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

Para Eclipse funcionó la siguiente expresión:

Foo

Jadajada Bar "

Expresión regular:

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

/(.*)<FooBar>/s

La s causa el Punto (.) para que coincidan los retornos de carro

También podemos usar

(.*?\n)*?

Para que coincida con todo, incluyendo nueva línea sin codicioso

Esto hará que la nueva línea opcional

(.*?|\n)*?

Tenga en cuenta que (.|\n)* puede ser menos eficiente que (por ejemplo) [\s\S]* (si las expresiones regulares de su lenguaje admiten tales escapes) y que encontrar cómo especificar el modificador que hace . también coinciden con las nuevas líneas. O puedes ir con alternativas POSIXy como [[:space:][:^space:]]*.

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

Regex.Reemplazar (contenido, SearchText, replaceText, RegexOptions.Singleline);

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

En expresiones regulares basadas en java se puede usar [\s\S]

En el contexto del uso dentro de los lenguajes, las expresiones regulares actúan sobre cadenas, no sobre líneas. Así que debería ser capaz de utilizar 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 "" está presente. Dependiendo de los detalles de la implementación regex, el valor $1 (obtenido de la "(.*)") será "fghij" o "abcde\nfghij". Como otros han dicho, algunas implementaciones le permiten controlar si el "."coincidirá con la nueva línea, dándote la opción.

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

Tuve el mismo problema y lo resolví probablemente no de la mejor manera, pero funciona. He reemplazado 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.

Probé todas las sugerencias anteriores sin suerte, estoy usando. Net 3.5 Para su información

En general . no coincide con las nuevas líneas, así que intenta ((.|\n)*)<foobar>

Quería hacer coincidir un bloque if en particular en java

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

   }
...
...
}

Si uso la expresión regular

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

Incluía la abrazadera de cierre para el bloque de método, así que usé

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

Para excluir la llave de cierre de la coincidencia de comodines.

A menudo tenemos que modificar una subcadena con algunas palabras clave repartidas entre 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 replace 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 no captura por (?:.|\n) entonces el $3 es (<PercentComplete>). Así que el patrón y replaceSpec también puede 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.