JavaScript
Expresiones regulares

Sintaxis

• dejar regex = / patrón / [ banderas ]
• let regex = new RegExp (' patrón ', [ marcas ])
• deja ismatch = regex.test (' texto ')
• dejar resultados = regex.exec (' texto ')

Parámetros

Observaciones

Creando un objeto RegExp

Creación estándar

Se recomienda utilizar este formulario solo cuando se crean expresiones regulares a partir de variables dinámicas.

Se usa cuando la expresión puede cambiar o la expresión es generada por el usuario.

var re = new RegExp(".*");

Con banderas:

var re = new RegExp(".*", "gmi");

Con una barra invertida: (esto debe ser evitado porque la expresión regular está especificada con una cadena)

var re = new RegExp("\\w*");

Inicializacion estatica

Utilícelo cuando sepa que la expresión regular no cambiará y sabrá cuál es la expresión antes del tiempo de ejecución.

var re = /.*/;

Con banderas:

var re = /.*/gmi;

Con una barra invertida: (esto no debe escaparse porque la expresión regular se especifica en un literal)

var re = /\w*/;

Banderas RegExp

Hay varios indicadores que puede especificar para alterar el comportamiento de RegEx. Los indicadores pueden agregarse al final de un literal de expresión regular, como especificar gi en /test/gi , o pueden especificarse como el segundo argumento para el constructor RegExp , como en el new RegExp('test', 'gi') .

g - Global. Encuentra todas las coincidencias en lugar de detenerse después de la primera.

i - Ignorar el caso. /[az]/i es equivalente a /[a-zA-Z]/ .

m - Multilínea. ^ y $ coinciden con el principio y el final de cada línea, respectivamente, tratando a \n \r como delimitadores en lugar de simplemente al principio y al final de toda la cadena.

Coincidencia con .exec ()

Coincidencia con .exec()

RegExp.prototype.exec(string) devuelve una matriz de capturas, o null si no hubo coincidencia.

var re = /([0-9]+)[a-z]+/;
var match = re.exec("foo123bar");

match.index es 3, la ubicación (basada en cero) de la coincidencia.

match[0] es la cadena de coincidencia completa.

match[1] es el texto correspondiente al primer grupo capturado. match[n] sería el valor del n º grupo capturado.

Bucle a través de coincidencias utilizando .exec()

var re = /a/g;
var result;
while ((result = re.exec('barbatbaz')) !== null) {
    console.log("found '" + result[0] + "', next exec starts at index '" + re.lastIndex + "'");
}

Rendimiento esperado

encontrado 'a', el próximo exec comienza en el índice '2'
encontrado 'a', el próximo exec comienza en el índice '5'
encontrado 'a', el próximo exec comienza en el índice '8'

Compruebe si la cadena contiene patrón usando .test ()

var re = /[a-z]+/;
if (re.test("foo")) {
    console.log("Match exists.");
}

El método de test realiza una búsqueda para ver si una expresión regular coincide con una cadena. La expresión regular [az]+ buscará una o más letras minúsculas. Dado que el patrón coincide con la cadena, "la coincidencia existe" se registrará en la consola.

Usando RegExp con cadenas

El objeto String tiene los siguientes métodos que aceptan expresiones regulares como argumentos.

• "string".match(...
• "string".replace(...
• "string".split(...
• "string".search(...

Coincidir con RegExp

console.log("string".match(/[i-n]+/));
console.log("string".match(/(r)[i-n]+/));

Rendimiento esperado

Array ["in"]
Array ["rin", "r"]

Reemplazar con RegExp

console.log("string".replace(/[i-n]+/, "foo"));

Rendimiento esperado

strfoog

Dividir con RegExp

console.log("stringstring".split(/[i-n]+/));

Rendimiento esperado

Array ["str", "gstr", "g"]

Buscar con RegExp

.search() devuelve el índice en el que se encuentra una coincidencia o -1.

console.log("string".search(/[i-n]+/));
console.log("string".search(/[o-q]+/));

Rendimiento esperado

3
-1

Reemplazo de cadena coincidente con una función de devolución de llamada

String#replace puede tener una función como segundo argumento, por lo que puede proporcionar un reemplazo basado en alguna lógica.

"Some string Some".replace(/Some/g, (match, startIndex, wholeString) => {
  if(startIndex == 0){
    return 'Start';
  } else {
    return 'End';
  }
});
// will return Start string End

Biblioteca de plantillas de una línea

let data = {name: 'John', surname: 'Doe'}
"My name is {surname}, {name} {surname}".replace(/(?:{(.+?)})/g, x => data[x.slice(1,-1)]);

// "My name is Doe, John Doe"

Grupos RegExp

JavaScript es compatible con varios tipos de grupos en sus expresiones regulares, grupos de captura , grupos que no son de captura y perspectivas . Actualmente, no hay soporte de búsqueda .

Capturar

A veces, la coincidencia deseada se basa en su contexto. Esto significa que un simple RegExp sobre-buscará la parte de la cadena que es de interés, por lo que la solución es escribir un grupo de captura (pattern) . Los datos capturados pueden ser referenciados como ...

• Reemplazo de cadena "$n" donde n es el n ° grupo de captura (comenzando desde 1 )
• El n º argumento en una función de devolución de llamada
• Si el RegExp no está marcado como g , el elemento n + 1 en una matriz str.match devuelta
• Si el RegExp está marcado como g , str.match descarta capturas, use re.exec en re.exec lugar

Supongamos que hay una cadena en la que todos los signos + deben reemplazarse con un espacio, pero solo si siguen un carácter de letra. Esto significa que una coincidencia simple incluiría ese carácter de letra y también se eliminaría. Capturarla es la solución, ya que significa que la letra coincidente se puede conservar.

let str = "aa+b+cc+1+2",
    re = /([a-z])\+/g;

// String replacement
str.replace(re, '$1 '); // "aa b cc 1+2"
// Function replacement
str.replace(re, (m, $1) => $1 + ' '); // "aa b cc 1+2"

No captura

Usando el formulario (?:pattern) , estos funcionan de manera similar para capturar grupos, excepto que no almacenan el contenido del grupo después de la coincidencia.

Pueden ser particularmente útiles si se capturan otros datos de los que no desea mover los índices, pero necesita hacer una comparación de patrones avanzada, como un OR

let str = "aa+b+cc+1+2",
    re = /(?:\b|c)([a-z])\+/g;

str.replace(re, '$1 '); // "aa+b c 1+2"

Mirar hacia el futuro

Si la coincidencia deseada se basa en algo que la sigue, en lugar de combinarla y capturarla, es posible usar un anticipo para probarla pero no incluirla en la partida. Un look-ahead positivo tiene la forma (?=pattern) , un look-ahead negativo (donde la expresión de coincidencia solo ocurre si el patrón de look-ahead no coincide) tiene la forma (?!pattern)

let str = "aa+b+cc+1+2",
    re = /\+(?=[a-z])/g;

str.replace(re, ' '); // "aa b cc+1+2"

Usando Regex.exec () con paréntesis regex para extraer coincidencias de una cadena

A veces no quieres simplemente reemplazar o eliminar la cadena. A veces quieres extraer y procesar coincidencias. Aquí un ejemplo de cómo manipulas los partidos.

¿Qué es un partido? Cuando se encuentra una subcadena compatible para toda la expresión regular en la cadena, el comando exec produce una coincidencia. Una coincidencia es una matriz compuesta por, en primer lugar, toda la subcadena que coincide y todo el paréntesis en la coincidencia.

Imagina una cadena html:

<html>
<head></head>
<body>
  <h1>Example</h1>
  <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>
  Copyright <a href="https://stackoverflow.com">Stackoverflow</a>
</body>

Desea extraer y obtener todos los enlaces dentro de a etiqueta. Al principio, aquí la expresión regular usted escribe:

var re = /<a[^>]*href="https?:\/\/.*"[^>]*>[^<]*<\/a>/g;

Pero ahora, imagina que quieres el href y el anchor de cada enlace. Y lo quieren juntos. Simplemente puede agregar un nuevo regex para cada coincidencia O puede usar paréntesis:

var re = /<a[^>]*href="(https?:\/\/.*)"[^>]*>([^<]*)<\/a>/g; 
var str = '<html>\n    <head></head>\n    <body>\n        <h1>Example</h1>\n        <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>\n\n        Copyright <a href="https://stackoverflow.com">Stackoverflow</a>\n    </body>\';\n';
var m;
var links = [];

while ((m = re.exec(str)) !== null) {
    if (m.index === re.lastIndex) {
        re.lastIndex++;
    }
    console.log(m[0]); // The all substring
    console.log(m[1]); // The href subpart
    console.log(m[2]); // The anchor subpart

    links.push({
      match : m[0],   // the entire match
      href : m[1],    // the first parenthesis => (https?:\/\/.*)
      anchor : m[2],  // the second one => ([^<]*)
    });
}

Al final del bucle, tienes una matriz de enlaces con anchor y href y puedes usarlo para escribir markdown, por ejemplo:

links.forEach(function(link) {
  console.log('[%s](%s)', link.anchor, link.href);
});

Para llegar más lejos :

• Paréntesis anidado