Regex para cadena entre comillas con comillas de escape

Question

¿Cómo obtengo la subcadena " It's big \"problem " usando una expresión regular?

s = ' function(){ return " It\'s big \"problem "; }';  

Answer 1

/(["\']).*?(?<!\\)(\\\\)*\1/is 

debería funcionar con cualquier cadena entre comillas

Answer 2

Hay que recordar que las expresiones regulares no son una panacea para todo, cuerdas-y. Algunas cosas son más simples de hacer con un cursor y lineal, manual, buscando. Un CFL haría el truco bastante trivial, pero no hay muchas implementaciones de CFL (afaik).

Answer 3

/"(?:[^"\\]|\\.)*"/ 

Trabaja en The Regex Coach and PCRE Workbench.

Ejemplo de prueba en JavaScript:

var s = ' function(){ return " Is big \\"problem\\", \\no? "; }'; 
 
    var m = s.match(/"(?:[^"\\]|\\.)*"/); 
 
    if (m != null) 
 
     alert(m);

Answer 4

Éste viene de nanorc.sample disponible en muchas distribuciones de Linux. Se utiliza para resaltar la sintaxis de cadenas estilo C

\"(\\.|[^\"])*\" 

Answer 5

"(?:\\"|.)*?" 

alternando la \" y la . pasa por encima de las cotizaciones escapó mientras que el cuantificador perezoso *? se asegura de que usted no va más allá del final de la cadena entre comillas. Funciona con clases de .NET Framework RE

Answer 6

Como proporcionada por ePharaoh, la respuesta es

/"([^"\\]*(\\.[^"\\]*)*)"/ 

Para que lo anterior se aplica a cualquiera de las cadenas entre comillas simples o dobles citados, utilice

/"([^"\\]*(\\.[^"\\]*)*)"|\'([^\'\\]*(\\.[^\'\\]*)*)\'/ 

Answer 7

Si se busca desde el principio, tal vez esto puede funcionar?

\"((\\\")|[^\\])*\" 

Answer 8

Una versión más extensa de https://stackoverflow.com/a/10786066/1794894

/"([^"\\]{50,}(\\.[^"\\]*)*)"|\'[^\'\\]{50,}(\\.[^\'\\]*)*\'|“[^”\\]{50,}(\\.[^“\\]*)*”/ 

Esta versión también contiene

1. longitud cotización mínimo de 50
2. tipo adicional de comillas (abierta “ y cerca ”)

Answer 9

en mal estado en torno al regexpal y terminó con esta expresión regular: (No me pregunte cómo funciona, yo apenas entiendo incluso aunque lo escribí lol)

"(([^"\\]?(\\\\)?)|(\\")+)+" 

Answer 10

La mayoría de las soluciones proporcionadas aquí usar la repetición alternativa caminos ie (A | B) *.

Puede encontrar desbordamientos de pila en entradas grandes, ya que algunos compiladores de patrones implementan esto mediante la recursión.

Java por ejemplo: http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6337993

Algo como esto: "(?:[^"\\]*(?:\\.)?)*", o el proporcionado por Guy Bedford reducirá la cantidad de pasos de análisis evitando la mayoría de los desbordamientos de pila.

Answer 11

/"(?:[^"\\]++|\\.)*+"/ 

llevaron directamente a partir man perlre en un sistema Linux con Perl 5.22.0 instalado. Como optimización, esta expresión regular usa la forma 'posessive' de + y * para evitar el retroceso, ya que se sabe de antemano que una cadena sin una cita de cierre no coincidiría en ningún caso.

Answer 12

Este funciona perfectamente en PCRE y no cae con StackOverflow.

"(.*?[^\\])??((\\\\)+)?+" 

Explicación:

1. Cada cadena entre comillas se inicia con Char: ";
2. Puede contener cualquier número de caracteres: .*? {Lazy match}; terminando con el carácter de no escape [^\\];
3. La instrucción (2) es Lazy (!) Opcional porque la cadena puede estar vacía (""). Entonces: (.*?[^\\])??
4. Finalmente, cada cadena citada termina con Char ("), pero puede ir precedida por un número par de parejas de signos de escape (\\\\)+; y es codicioso (!) opcional: ((\\\\)+)?+ {Greedy matching}, ¡porque la cadena puede estar vacía o sin pares de finalización!

Answer 13

aquí es uno que trabaja tanto con "y" y se agrega fácilmente a otros en la salida.

("|')(?:\\\1|[^\1])*?\1

se utiliza la referencia inversa (\ 1) partido exactley lo que está en el primer grupo (" o ').

http://www.regular-expressions.info/backref.html

Answer 14

Una opción que no ha sido tocado antes es:

1. reversa de la cadena.
2. Realice la coincidencia en la cadena invertida.
3. Vuelva a invertir las cadenas coincidentes.

Esto tiene la ventaja añadida de ser capaz de igualar correctamente las etiquetas abiertas escapado.

Supongamos que tiene la siguiente cadena; String \"this "should" NOT match\" and "this \"should\" match" Aquí, \"this "should" NOT match\" no debe coincidir y "should" debería ser. Además de eso, this \"should\" match debe coincidir y \"should\" no.

Primero un ejemplo.

// The input string. 
const myString = 'String \\"this "should" NOT match\\" and "this \\"should\\" match"'; 

// The RegExp. 
const regExp = new RegExp(
    // Match close 
    '([\'"])(?!(?:[\\\\]{2})*[\\\\](?![\\\\]))' + 
    '((?:' + 
     // Match escaped close quote 
     '(?:\\1(?=(?:[\\\\]{2})*[\\\\](?![\\\\])))|' + 
     // Match everything thats not the close quote 
     '(?:(?!\\1).)' + 
    '){0,})' + 
    // Match open 
    '(\\1)(?!(?:[\\\\]{2})*[\\\\](?![\\\\]))', 
    'g' 
); 

// Reverse the matched strings. 
matches = myString 
    // Reverse the string. 
    .split('').reverse().join('') 
    // '"hctam "\dluohs"\ siht" dna "\hctam TON "dluohs" siht"\ gnirtS' 

    // Match the quoted 
    .match(regExp) 
    // ['"hctam "\dluohs"\ siht"', '"dluohs"'] 

    // Reverse the matches 
    .map(x => x.split('').reverse().join('')) 
    // ['"this \"should\" match"', '"should"'] 

    // Re order the matches 
    .reverse(); 
    // ['"should"', '"this \"should\" match"'] 

Bien, ahora para explicar la expresión regular. Esta es la expresión regular se puede dividir fácilmente en tres partes. En la siguiente manera:

# Part 1 
(['"])   # Match a closing quotation mark " or ' 
(?!   # As long as it's not followed by 
    (?:[\\]{2})* # A pair of escape characters 
    [\\]   # and a single escape 
    (?![\\])  # As long as that's not followed by an escape 
) 
# Part 2 
((?:   # Match inside the quotes 
(?:   # Match option 1: 
    \1   # Match the closing quote 
    (?=   # As long as it's followed by 
    (?:\\\\)* # A pair of escape characters 
    \\  # 
    (?![\\]) # As long as that's not followed by an escape 
)   # and a single escape 
)|   # OR 
(?:   # Match option 2: 
    (?!\1).  # Any character that isn't the closing quote 
) 
)*)   # Match the group 0 or more times 
# Part 3 
(\1)   # Match an open quotation mark that is the same as the closing one 
(?!   # As long as it's not followed by 
    (?:[\\]{2})* # A pair of escape characters 
    [\\]   # and a single escape 
    (?![\\])  # As long as that's not followed by an escape 
) 

Esta es probablemente mucho más clara en forma de imagen: generada usando Jex's Regulex

Image on github (JavaScript Regular Expression Visualizer.) Lo sentimos, no tengo una reputación lo suficientemente alto como para incluir las imágenes, por lo que, es sólo una enlace por ahora.

Aquí está una esencia de una función de ejemplo utilizando este concepto de que es un poco más avanzado: https://gist.github.com/scagood/bd99371c072d49a4fee29d193252f5fc#file-matchquotes-js