Expresiones regulares en JavaScript. Objeto RegExp

La clase RegExp en JavaScript es una expresión regular, un objeto que describe un patrón de carácter. Los objetos RegExp generalmente se crean usando la sintaxis literal especial que se muestra a continuación, pero también se pueden crear usando el constructor RegExp ().

Sintaxis

Valores paramétricos:

Banderas de expresiones regulares

Conjuntos de caracteres

Metacaracteres

Restricciones

Cuantificadores

Agrupación y backlinks

Este artículo ha cubierto los conceptos básicos del uso de expresiones regulares en Javascript.

Introducción

¿Qué es una expresión regular?

Una expresión regular de JS es una secuencia de caracteres que forman una regla de búsqueda. Esta regla se puede utilizar para buscar el texto y reemplazarlo. En la práctica, una expresión regular puede incluso constar de un solo carácter, pero los patrones de búsqueda más complejos son más comunes.

En Javascript, las expresiones regulares también son objetos. Estos son patrones que se utilizan para hacer coincidir secuencias de caracteres en cadenas. Se utilizan en los métodos exec () y test () del objeto RegExp, así como en los métodos match (), replace (), search y split () del objeto String.

Ejemplo

var patrón = / ejemplo / i

/ ejemplo / i es una expresión regular. ejemplo es una plantilla ( que se utilizará en la búsqueda). i es un modificador que indica la distinción entre mayúsculas y minúsculas.

Preparando una expresión regular

Las expresiones regulares de JS constan de un patrón y un modificador. La sintaxis será algo como esto:

/ patrón / modificadores;

La plantilla define la regla de búsqueda. Consiste en caracteres simples como / abc / o una combinación de caracteres simples y caracteres especiales: / abc / o / Capítulo (d +). d /.

Tabla de plantillas

Los modificadores permiten que las consultas sean sensibles a mayúsculas y minúsculas, globales, etc. Se utilizan para realizar búsquedas que distinguen entre mayúsculas y minúsculas, así como búsquedas globales.

Tabla de modificadores

Ahora estamos listos para aplicar expresiones regulares JS. Hay dos formas principales de hacer esto: usando un objeto regex o un regex para cadena.

Usando un objeto regex

Crea un objeto de expresión regular

Este objeto describe un patrón de carácter. Se utiliza para combinar patrones. Hay dos formas de construir un objeto de expresión regular.

Método 1: usar un literal de expresión regular que consta de un patrón encerrado en barras, por ejemplo:

var reg = / ab + c /;

Los literales de expresión regular activan la compilación previa de la expresión regular cuando se analiza el script. Si la expresión regular es persistente, úsela para mejorar el rendimiento.

Método 2: llamando a la función constructora del objeto RegExp, por ejemplo:

var reg = new RegExp ("ab + c");

El constructor le permite compilar la expresión regular JS en tiempo de ejecución. Utilice este método si la expresión regular cambiará o si no conoce el patrón de antemano. Por ejemplo, si recibe información de un usuario que ingresa un término de búsqueda.

Métodos de objetos de expresión regular

Echemos un vistazo a algunos métodos comunes del objeto de expresión regular:

• compilar () ( obsoleto en la versión 1.5) - compila la expresión regular;
• exec (): realiza la coincidencia en una cadena. Devuelve la primera coincidencia;
• test (): realiza la coincidencia en una cadena. Devuelve verdadero o falso;
• toString (): devuelve el valor de cadena de la expresión regular.

Ejemplos de

Usando test ()

El método test () es una expresión regular de un objeto RegExp. Busca una cadena de plantilla y, según el resultado que devuelve, devuelve verdadero o falso. El siguiente ejemplo de expresión regular JS muestra cómo buscar en una cadena el carácter " mi”:

var patt = / e /; patt.test ("¡Las mejores cosas del mundo son gratis!");

Dado que aquí la línea contiene " mi”, El resultado de este código será verdadero.

No es necesario que coloques expresiones regulares en una variable. La misma consulta se puede realizar en una línea:

/e/.test("¡Las mejores cosas del mundo son gratis! ");

Usando exec ()

Busca en la cadena la regla de búsqueda especificada y devuelve el texto encontrado. Si no se encontró ninguna coincidencia, el resultado es nulo.

Veamos el método en acción, usando el ejemplo del mismo símbolo " mi”:

/e/.exec("¡Las mejores cosas del mundo son gratis! ");

Dado que la línea contiene " mi”, El resultado de este código será .e.

Aplicar una expresión regular a una cadena

En Javascript, estas expresiones también se pueden usar con dos métodos del objeto String: buscar () y reemplazar (). Son necesarios para realizar búsquedas y reemplazar en el texto.

• El método search (): utiliza una expresión para encontrar una coincidencia y devuelve información sobre la ubicación de la coincidencia;
• Método Replace (): devuelve una cadena modificada con una plantilla reemplazada.

Ejemplos de

Aplicación de la expresión regular de JS para realizar una búsqueda que distingue entre mayúsculas y minúsculas de la frase " w3schools" en línea:

var str = "Visitar W3Schools"; var n = str.search (/ w3schools / i);

El resultado en n es 6.

El método de búsqueda también acepta una cadena como argumento. El argumento de cadena se convertirá en una expresión regular:

Usando una cadena para encontrar la frase " W3schools" en línea.

Expresiones regulares

Expresión regular es un objeto que describe un patrón de carácter. La clase RegExp en JavaScript representa expresiones regulares, y los objetos de clase String y RegExp definen métodos que usan expresiones regulares para realizar operaciones de búsqueda y coincidencia de patrones en texto con reemplazo. La gramática de expresiones regulares en JavaScript contiene un subconjunto bastante completo de la sintaxis de expresiones regulares utilizada en Perl 5, por lo que si tiene experiencia con el lenguaje Perl, puede describir patrones fácilmente en programas JavaScript.

Las características de las expresiones regulares de Perl que no son compatibles con ECMAScript incluyen los indicadores s (modo de una sola línea) y x (sintaxis extendida); secuencias de escape \ a, \ e, \ l, \ u, \ L, \ U, \ E, \ Q, \ A, \ Z, \ z y \ G y otras construcciones extendidas que comienzan con (?.

Definición de expresiones regulares

En JavaScript, las expresiones regulares están representadas por objetos RegExp... Los objetos RegExp se pueden crear usando el constructor RegExp (), pero más a menudo se crean usando una sintaxis literal especial. Así como los literales de cadena se especifican como caracteres entre comillas, los literales de expresión regular se especifican como caracteres encerrados en un par de barras inclinadas (/). Por lo tanto, el código JavaScript puede contener cadenas como esta:

Var patrón = / s $ /;

Esta línea crea un nuevo objeto RegExp y lo asigna a la variable de patrón. Este objeto RegExp busca cualquier cadena que termine con el carácter "s". La misma expresión regular se puede definir usando el constructor RegExp ():

Var patrón = new RegExp ("s $");

Una especificación de patrón de expresiones regulares consta de una secuencia de caracteres. La mayoría de los caracteres, incluidos todos los caracteres alfanuméricos, describen literalmente los caracteres que deben estar presentes. Es decir, la expresión regular / java / coincide con todas las cadenas que contienen la subcadena "java".

Los otros caracteres de las expresiones regulares no están destinados a ser utilizados para encontrar sus equivalentes exactos, sino que tienen significados especiales. Por ejemplo, la expresión regular / s $ / contiene dos caracteres. La primera s indica una búsqueda de un carácter literal. En segundo lugar, $ es un metacarácter especial que denota el final de una línea. Entonces, esta expresión regular coincidirá con cualquier cadena que termine con s.

Las siguientes secciones describen los diversos caracteres y metacaracteres utilizados en expresiones regulares en JavaScript.

Caracteres literales

Como se señaló anteriormente, todos los caracteres alfabéticos y números en expresiones regulares coinciden. La sintaxis de expresiones regulares en JavaScript también admite la capacidad de especificar algunos caracteres no alfabéticos mediante secuencias de escape que comienzan con un carácter de barra invertida (\). Por ejemplo, \ n coincide con un carácter de salto de línea. Estos símbolos se enumeran en la siguiente tabla:

Algunos signos de puntuación tienen significados especiales en expresiones regulares:

^ $ . * + ? = ! : | \ / () { } -

El significado de estos símbolos se explica en las siguientes secciones. Algunos de ellos tienen un significado especial solo en ciertos contextos de expresiones regulares, mientras que en otros contextos se toman literalmente. Normalmente, sin embargo, para incluir cualquiera de estos caracteres literalmente en una expresión regular, debe anteponerlo con una barra invertida. Otros caracteres, como las comillas y @, no tienen un significado especial y simplemente coinciden en expresiones regulares.

Si no puede recordar exactamente qué carácter debe ir precedido por una \, puede poner una barra diagonal inversa delante de cualquiera de los caracteres. Sin embargo, tenga en cuenta que muchas letras y números tienen un significado especial cuando se combinan con una barra, por lo que las letras y números que busca literalmente no deben ir precedidos de \. Para incluir el carácter de barra invertida en la expresión regular, obviamente necesita poner otro carácter de barra invertida delante de él. Por ejemplo, la siguiente expresión regular coincide con cualquier cadena que contenga un carácter de barra invertida: / \\ /.

Clases de personajes

Los caracteres literales individuales se pueden combinar en clases de caracteres encerrándolos entre corchetes. Una clase de carácter coincide con cualquier carácter contenido en esta clase. Por lo tanto, la expresión regular // coincide con uno de los caracteres a, b o c.

Las clases de caracteres negadas también se pueden definir para que coincidan con cualquier carácter que no sean los indicados entre paréntesis. Una clase de carácter negado se especifica mediante el carácter ^ como el primer carácter que sigue al paréntesis izquierdo. La expresión regular / [^ abc] / coincide con cualquier carácter que no sea a, b o c. En las clases de caracteres, se puede especificar un rango de caracteres mediante un guión. Busque todos los caracteres del alfabeto latino en minúscula se realiza usando la expresión //, y cualquier letra o número del juego de caracteres latinos se puede encontrar usando la expresión //.

Ciertas clases de caracteres se utilizan con especial frecuencia, por lo que la sintaxis de expresiones regulares en JavaScript incluye caracteres especiales y secuencias de escape para denotarlos. Por ejemplo, \ s coincide con espacios en blanco, tabulaciones y cualquier carácter de espacio en blanco Unicode, y \ S coincide con cualquier carácter de espacio en blanco que no sea Unicode.

La siguiente tabla enumera estos caracteres especiales y la sintaxis de las clases de caracteres. (Tenga en cuenta que algunas de las secuencias de escape de clases de caracteres solo coinciden con caracteres ASCII y no están extendidas para trabajar con caracteres Unicode. Puede definir explícitamente propias clases Caracteres Unicode, por ejemplo / [\ u0400- \ u04FF] / coincide con cualquier carácter cirílico).

Tenga en cuenta que las secuencias de escape para caracteres especiales de clase se pueden encerrar entre corchetes. \ s coincide con cualquier carácter de espacio en blanco y \ d coincide con cualquier dígito, por lo tanto / [\ s \ d] / coincide con cualquier carácter o dígito de espacio en blanco.

Repetición

Con el conocimiento de la sintaxis de las expresiones regulares obtenidas hasta ahora, podemos describir un número de dos dígitos como / \ d \ d / o números de cuatro dígitos como / \ d \ d \ d \ d /, pero no podemos, por Por ejemplo, describa un número, cualquier número de dígitos o una cadena de tres letras seguidas de un dígito opcional. Estos patrones más complejos utilizan la sintaxis de expresión regular para indicar cuántas veces se puede repetir un elemento de expresión regular determinado.

Los símbolos de repetición siempre siguen el patrón al que se aplican. Algunos tipos de repetición se utilizan con bastante frecuencia y existen símbolos especiales para indicar estos casos. Por ejemplo, + coincide con una o más instancias del patrón anterior. La siguiente tabla proporciona un resumen de la sintaxis de repetición:

Las siguientes líneas muestran algunos ejemplos:

Var patrón = / \ d (2,4) /; // Coincide con un patrón numérico de dos a cuatro dígitos = / \ w (3) \ d? /; // Coincide exactamente con tres caracteres de palabra y un patrón de dígito opcional = / \ s + java \ s + /; // Coincide con la palabra "java" con uno o más espacios // antes y después de ella pattern = / [^ (] * /; // Coincide con cero o más caracteres que no sean el paréntesis de apertura

Tenga cuidado al utilizar los caracteres de repetición * y?. Pueden corresponder a la ausencia del patrón especificado delante de ellos y, por tanto, a la ausencia de símbolos. Por ejemplo, la expresión regular / a * / coincide con la cadena "bbbb" porque no contiene el carácter a.

Los caracteres de repetición enumerados en la tabla corresponden al número máximo de repeticiones que se pueden usar para buscar partes posteriores de la expresión regular. Decimos que esto es una repetición "codiciosa". También es posible implementar la repetición de una manera no codiciosa. Basta con indicar después del símbolo (o símbolos) de la repetición un signo de interrogación: ??, +?, *? o incluso (1,5)?.

Por ejemplo, la expresión regular / a + / coincide con una o más instancias de la letra a. Aplicado a la cadena "aaa", coincide con las tres letras. Por otro lado, la expresión / a +? / Coincide con una o más instancias de la letra ay selecciona el menor número posible de caracteres. Aplicado a la misma línea, este patrón coincide solo con la primera letra a.

Una repetición "insegura" no siempre da el resultado esperado. Considere el patrón / a + b /, que coincide con uno o más a seguidos de a b. Cuando se aplica a la cadena "aaab", coincide con toda la cadena.

Ahora revisemos la versión "no codiciosa" de / a +? B /. Uno pensaría que debería coincidir con el carácter b, precedido por un solo carácter a. Si se aplica a la misma cadena, se esperaría que "aaab" coincidiera con la única a y la última b. Sin embargo, en realidad, toda la cadena coincide con este patrón, como en el caso de la versión "codiciosa". El punto es que una búsqueda de patrón de expresión regular se realiza encontrando la primera posición en la cadena desde la cual se hace posible una coincidencia. Dado que una coincidencia es posible desde el primer carácter de la cadena, las coincidencias más cortas que comienzan con los caracteres siguientes ni siquiera se consideran.

Alternativas, agrupaciones y enlaces

La gramática de las expresiones regulares incluye caracteres especiales para definir alternativas, agrupando subexpresiones y referencias a subexpresiones anteriores. Símbolo de tubería | sirve para separar alternativas. Por ejemplo, / ab | cd | ef / coincide con la cadena "ab", o la cadena "cd", o la cadena "ef", y el patrón / \ d (3) | (4) / coincide con tres dígitos o cuatro letras minúsculas ...

Tenga en cuenta que las alternativas se procesan de izquierda a derecha hasta que se encuentra una coincidencia. Si se encuentra una coincidencia con la alternativa de la izquierda, se ignora la de la derecha, aunque se puede lograr una coincidencia "mejor". Por lo tanto, cuando se aplica el patrón / a | ab / a la cadena "ab", solo coincidirá con el primer carácter.

Los paréntesis tienen varios significados en expresiones regulares. Uno de ellos está agrupando elementos individuales en una subexpresión, de modo que los elementos cuando se utilizan los caracteres especiales |, *, + ,? y otros son tratados como un todo. Por ejemplo, / java (script)? / Coincide con la palabra "java" seguida de la palabra opcional "script", y / (ab | cd) + | ef) / coincide con la cadena "ef" o una o más repeticiones de lo mismo de las cadenas "ab" o "cd".

Otro uso de paréntesis en expresiones regulares es definir subpatrones dentro de un patrón. Cuando se encuentra una coincidencia de expresión regular en la cadena de destino, puede extraer la parte de la cadena de destino que coincide con cualquier subpatrón específico entre paréntesis.

Suponga que desea buscar una o más letras minúsculas seguidas de uno o más números. Para hacer esto, puede usar el patrón / + \ d + /. Pero supongamos también que solo queremos los números al final de cada partido. Si pone esta parte del patrón entre paréntesis (/ + (\ d +) /), entonces puede extraer números de cualquier coincidencia que encontremos. Cómo se hace esto se describirá a continuación.

Relacionado con esto hay otro uso de subexpresiones entre paréntesis, lo que le permite hacer referencia a subexpresiones de la parte anterior de la misma expresión regular. Esto se logra especificando uno o más dígitos después del carácter \. Los números se refieren a la posición de la subexpresión entre paréntesis dentro de la expresión regular. Por ejemplo, \ 1 se refiere a la primera subexpresión y \ 3 se refiere a la tercera. Tenga en cuenta que las subexpresiones se pueden anidar entre sí, por lo que la posición del paréntesis izquierdo se usa en el recuento. Por ejemplo, en la siguiente expresión regular, una referencia de subexpresión anidada (cript) se vería como \ 2:

/ (ava (cript)?) \ sis \ s (divertido \ w *) /

Una referencia a una subexpresión anterior no apunta al patrón de esa subexpresión, sino al texto encontrado que coincide con ese patrón. Por lo tanto, los enlaces se pueden utilizar para imponer una restricción que seleccione partes de una cadena que contengan exactamente los mismos caracteres. Por ejemplo, la siguiente expresión regular coincide con cero o más caracteres dentro de una sola o doble comillas... Sin embargo, no requiere que las comillas de apertura y cierre coincidan entre sí (es decir, que ambas comillas sean simples o dobles):

/[""][^""]*[""]/

Podemos requerir que las comillas coincidan mediante dicho enlace:

Aquí, \ 1 coincide con la primera subexpresión. En este ejemplo, el vínculo impone la restricción de que las comillas de cierre coincidan con las comillas de apertura. Esta expresión regular no permite comillas simples dentro de comillas dobles y viceversa.

También es posible agrupar elementos en una expresión regular sin crear una referencia numerada a esos elementos. En lugar de simplemente agrupar elementos entre (y), comience el grupo con (?: Y termínelo con). Considere, por ejemplo, el siguiente patrón:

/ (ava (?: cript)?) \ sis \ s (divertido \ w *) /

Aquí la subexpresión (?: Cript) solo es necesaria para agrupar de modo que el carácter de repetición? Se pueda aplicar al grupo. Estos paréntesis modificados no crean un enlace, por lo que en esta expresión regular, \ 2 se refiere al texto que coincide con el patrón (fun \ w *).

La siguiente tabla enumera las alternativas, agrupaciones y operadores de referencia en expresiones regulares:

Especificando la posición del partido

Como se describió anteriormente, muchos elementos regexp coinciden con un carácter por cadena. Por ejemplo, \ s coincide con un carácter de espacio en blanco. Otros elementos de expresión regular coinciden con las posiciones entre los caracteres, no con los caracteres en sí. Por ejemplo, \ b coincide con el límite de una palabra: el límite entre \ w (carácter de texto ASCII) y \ W (carácter que no es de texto), o el límite entre un carácter de texto ASCII y el principio o el final de una línea.

Elementos como \ b no definen ningún carácter que deba estar presente en la cadena encontrada, pero definen posiciones válidas para la coincidencia. Estos elementos a veces se denominan elementos de anclaje de expresiones regulares porque anclan el patrón a una posición específica en la cadena. Los elementos de anclaje más comunes que se utilizan son ^ y $, que anclan patrones al principio y al final de una línea, respectivamente.

Por ejemplo, la palabra "JavaScript" en su propia línea se puede encontrar usando la expresión regular / ^ JavaScript $ /. Para encontrar una sola palabra "Java" (y no un prefijo, por ejemplo, en la palabra "JavaScript"), puede intentar usar el patrón / \ sJava \ s /, que requiere un espacio antes y después de la palabra.

Pero esta solución plantea dos problemas. Primero, solo encontrará la palabra "Java" si está rodeada de espacios en ambos lados y no puede encontrarla al principio o al final de la línea. En segundo lugar, cuando este patrón coincide, la cadena que devuelve contendrá espacios iniciales y finales, que no es exactamente lo que queremos. Entonces, en lugar de un patrón que coincida con los espacios en blanco \ s, usaremos un patrón (o ancla) que coincida con los límites de la palabra \ b. Resultará la siguiente expresión: / \ bJava \ b /.

El elemento de anclaje \ B coincide con una posición que no es un límite de palabra. Es decir, el patrón / \ Bcript / coincidirá con las palabras "JavaScript" y "postscript" y no con las palabras "script" o "Scripting".

Las expresiones regulares arbitrarias también se pueden utilizar como condiciones de anclaje. Poner una expresión entre los caracteres (? = Y) la convierte en una coincidencia anticipada contra los caracteres siguientes, lo que requiere que esos caracteres coincidan con el patrón especificado, pero que no se incluyan en la cadena de coincidencia.

Por ejemplo, para hacer coincidir el nombre de un lenguaje de programación común seguido de dos puntos, puede usar la expresión / ava (cript)? (? = \ :) /. Este patrón coincide con la palabra "JavaScript" en la cadena "JavaScript: The Definitive Guide", pero no coincidirá con la palabra "Java" en la cadena "Java in a Nutshell" porque no va seguida de dos puntos.

Si ingresa la condición (?!, Entonces será una búsqueda anticipada negativa para los caracteres subsiguientes, requiriendo que los siguientes caracteres no coincidan con el patrón especificado. Por ejemplo, el patrón / Java (?! Script) (\ w *) / coincide con la subcadena "Java", seguida de letra mayúscula y cualquier número de caracteres de texto ASCII, siempre que la subcadena "Java" no vaya seguida de la subcadena "Script". Coincidirá con la cadena "JavaBeans" pero no con la cadena "Javanese", coincidirá con la cadena "JavaScrip" pero no con las cadenas "JavaScript" o "JavaScripter".

La siguiente tabla enumera los caracteres de anclaje de las expresiones regulares:

Banderas

Y un elemento final más de la gramática de las expresiones regulares. Los indicadores de expresión regular especifican reglas de coincidencia de patrones de alto nivel. A diferencia del resto de la gramática de expresiones regulares, los indicadores no se especifican entre caracteres de barra, sino después del segundo. Hay tres banderas compatibles con JavaScript.

Marcar i especifica que la coincidencia de patrones no debe distinguir entre mayúsculas y minúsculas, y bandera g- que la búsqueda debe ser global, es decir se deben encontrar todas las coincidencias en la cadena. Bandera m busca un patrón en modo multilínea. Si la expresión de cadena que se busca contiene caracteres de avance de línea, entonces, en este modo, los caracteres de anclaje ^ y $, además de coincidir con el principio y el final de toda la expresión de cadena, también coinciden con el principio y el final de cada cadena de texto. Por ejemplo, / java $ / im coincide con "java" y "Java \ nis fun".

Estas banderas se pueden combinar en cualquier combinación. Por ejemplo, para buscar la primera aparición de la palabra "java" (o "Java", "JAVA", etc.) sin distinción entre mayúsculas y minúsculas, puede utilizar la expresión regular / \ bjava \ b / i que no distingue entre mayúsculas y minúsculas. Y para encontrar todas las apariciones de esta palabra en una cadena, puede agregar la bandera g: / \ bjava \ b / gi.

Métodos de clases de cadenas para la coincidencia de patrones

Hasta este punto, hemos discutido la gramática de la expresión regular generada, pero no hemos analizado cómo la expresión regular se puede usar realmente en JavaScript. En esta sección, discutiremos los métodos del objeto String que usan expresiones regulares para la coincidencia de patrones y la búsqueda y reemplazo. Luego continuaremos nuestra discusión sobre la coincidencia de patrones con expresiones regulares observando el objeto RegExp y sus métodos y propiedades.

Las cadenas admiten cuatro métodos que utilizan expresiones regulares. El más simple de estos es el método buscar ()... Toma una expresión regular como argumento y devuelve la posición del primer carácter de la subcadena encontrada o -1 si no se encontró ninguna coincidencia. Por ejemplo, la siguiente llamada devolverá 4:

Var result = "JavaScript" .search (/ script / i); // 4

Si el argumento del método search () no es una expresión regular, primero se convierte pasándolo al constructor RegExp. El método search () no admite búsquedas globales e ignora la bandera g en su argumento.

Método reemplazar () realiza una operación de búsqueda y reemplazo. Toma una expresión regular como primer argumento y una cadena de reemplazo como segundo. El método busca la línea para la que se llama para que coincida con el patrón especificado.

Si la expresión regular contiene la bandera g, el método replace () reemplaza cualquier coincidencia que encuentre con la cadena de reemplazo. De lo contrario, solo reemplaza la primera coincidencia que encuentre. Si el primer argumento del método replace () es una cadena y no una expresión regular, entonces el método realiza una búsqueda literal de la cadena, en lugar de convertirla en una expresión regular usando el constructor RegExp (), como la búsqueda () el método lo hace.

Como ejemplo, podemos usar el método replace () para escribir en mayúscula consistentemente la palabra "JavaScript" en toda una línea de texto:

// Independientemente del caso de los caracteres, reemplácelo con una palabra en el caso requerido var result = "javascript" .replace (/ JavaScript / ig, "JavaScript");

El método replace () es más poderoso de lo que podría sugerir este ejemplo. Permítame recordarle que las subexpresiones entre paréntesis dentro de una expresión regular se numeran de izquierda a derecha y que la expresión regular recuerda el texto que coincide con cada una de las subexpresiones. Si la cadena de reemplazo contiene un $ seguido de un dígito, el método replace () reemplaza esos dos caracteres con el texto que coincide con la subexpresión especificada. Esta es una caracteristica muy útil. Podemos usarlo, por ejemplo, para reemplazar comillas rectas en una cadena con comillas tipográficas, que son simuladas por caracteres ASCII:

// Una cita es una cita seguida de cualquier número de caracteres no comillas (los recordamos), // estos caracteres van seguidos de otra cita var quote = / "([^"] *) "/ g; // Reemplazar las comillas rectas con tipográficas y dejar "$ 1" sin cambios // el contenido de la cita almacenado en $ 1 var text = "" JavaScript "es un lenguaje de programación interpretado."; Var result = text.replace (quote, "" $ 1 ""); // "JavaScript" es un lenguaje de programación interpretado.

Un punto importante a tener en cuenta es que el segundo argumento para reemplazar () puede ser una función que calcula dinámicamente la cadena de reemplazo.

Método fósforo () es el más común de los métodos de expresión regular de la clase String. Toma una expresión regular como único argumento (o convierte su argumento en una expresión regular pasándola al constructor RegExp ()) y devuelve una matriz que contiene los resultados de la búsqueda. Si la bandera g se establece en la expresión regular, el método devuelve una matriz de todas las coincidencias en la cadena. Por ejemplo:

// devolverá ["1", "2", "3"] var result = "1 más 2 es igual a 3" .match (/ \ d + / g);

Si la expresión regular no contiene la bandera g, el método match () no realiza una búsqueda global; solo busca la primera coincidencia. Sin embargo, match () devuelve una matriz incluso cuando el método no realiza una búsqueda global. En este caso, el primer elemento de la matriz es la subcadena encontrada y todos los elementos restantes son subexpresiones de la expresión regular. Por lo tanto, si match () devuelve una matriz arr, entonces arr contendrá la cadena completa encontrada, arr contendrá la subcadena que coincida con la primera subexpresión, y así sucesivamente. Paralelamente al método replace (), podemos decir que arr [n] se llena con el contenido de $ n.

Por ejemplo, eche un vistazo al siguiente código para analizar una URL:

Var url = /(\w+):\/\/((\w.tory+)\/(\S*)/; var text = "Visite nuestro sitio http: //www..php"; var result = text.match (url); if (result! = null) (var fullurl = result; // Contiene "http: //www..php" var protocol = result; // Contiene "http" var host = result; // Contiene "www..php ")

Cabe señalar que para una expresión regular que no tiene el indicador de búsqueda global g establecido, el método match () devuelve el mismo valor que el método exec () de la expresión regular: la matriz devuelta tiene propiedades de índice y de entrada, como descrito en la discusión del exec () a continuación.

El último de los métodos del objeto String que usa expresiones regulares es separar ()... Este método divide la cadena para la que se llama en una matriz de subcadenas utilizando el argumento como delimitador. Por ejemplo:

"123,456,789" .split (","); // Devuelve ["123", "456", "789"]

El método split () también puede tomar una expresión regular como argumento. Esto hace que el método sea más poderoso. Por ejemplo, puede especificar un delimitador que permita un número arbitrario de caracteres de espacio en blanco en ambos lados:

"1, 2, 3, 4, 5". Dividir (/ \ s *, \ s * /); // Devuelve ["1", "2", "3", "4", "5"]

Objeto RegExp

Como se mencionó, las expresiones regulares se representan como objetos RegExp. Además del constructor RegExp (), los objetos RegExp admiten tres métodos y varias propiedades.

El constructor RegExp () toma uno o dos argumentos de cadena y crea un nuevo objeto RegExp. El primer argumento del constructor es una cadena que contiene el cuerpo de la expresión regular, es decir, el texto que debe aparecer entre los caracteres de barra en el literal de expresiones regulares. Tenga en cuenta que los literales de cadena y las expresiones regulares usan el carácter \ para denotar secuencias de escape, por lo que al pasar la expresión regular al constructor RegExp () como un literal de cadena, debe reemplazar cada \ con un par \\.

Es posible que falte el segundo argumento de RegExp (). Si se especifica, define las banderas de la expresión regular. Debe ser uno de los caracteres g, i, m o una combinación de estos caracteres. Por ejemplo:

// Encuentra todos los números de 5 dígitos en una cadena. Nota // el uso de \\ var zipcode = new RegExp ("\\ d (5)", "g");

El constructor RegExp () es útil cuando la expresión regular se genera dinámicamente y, por lo tanto, no se puede representar mediante la sintaxis literal de expresión regular. Por ejemplo, para encontrar una cadena ingresada por el usuario, crea una expresión regular en tiempo de ejecución usando RegExp ().

Propiedades de expresiones regulares

Cada objeto RegExp tiene cinco propiedades. Propiedad fuente: una cadena de solo lectura que contiene el texto de la expresión regular. Propiedad global - booleano Un indicador de solo lectura que especifica el indicador g en la expresión regular. Propiedad ignorar caso es un valor booleano de solo lectura que determina si la bandera i está presente en la expresión regular. Propiedad multilínea es un valor booleano de solo lectura que especifica la presencia del indicador m en la expresión regular. Y la ultima propiedad lastIndex es un entero de lectura / escritura. Para patrones con la bandera g, esta propiedad contiene el número de posición en la cadena en la que debe comenzar la siguiente búsqueda. Como se describe a continuación, es utilizado por los métodos exec () y test ().

Métodos RegExp

Los objetos RegExp definen dos métodos que realizan la coincidencia de patrones; se comportan de manera similar a los métodos de la clase String descritos anteriormente. El método principal de la clase RegExp utilizado para la coincidencia de patrones es ejecutivo ()... Es similar al método match () mencionado anteriormente de la clase String, excepto que es un método de la clase RegExp que toma una cadena como argumento, y no un método de la clase String que toma un argumento RegExp.

El método exec () ejecuta una expresión regular en la cadena especificada, es decir busca una coincidencia en una cadena. Si no se encuentra ninguna coincidencia, el método devuelve nulo. Sin embargo, si se encuentra una coincidencia, devuelve la misma matriz que la matriz devuelta por el método match () para buscar sin la bandera g. El elemento cero de la matriz contiene la cadena que coincide con la expresión regular y todos los elementos posteriores son subcadenas que coinciden con todas las subexpresiones. Además, la propiedad índice contiene el número de posición del carácter con el que comienza el fragmento correspondiente, y la propiedad aporte se refiere a la cadena que se buscó.

A diferencia de match (), el método exec () devuelve una matriz cuya estructura no depende de la presencia de la bandera g en la expresión regular. Permítame recordarle que al pasar una expresión regular global, el método match () devuelve una matriz de coincidencias encontradas. Y exec () siempre devuelve una coincidencia, pero proporciona al respecto información completa... Cuando se llama a exec () en una expresión regular que contiene el indicador g, el método establece la propiedad lastIndex del objeto de expresión regular en el número de posición del carácter que sigue inmediatamente a la subcadena encontrada.

Cuando se llama al método exec () por segunda vez para la misma expresión regular, comienza a buscar en el carácter cuya posición se especifica en la propiedad lastIndex. Si exec () no encuentra una coincidencia, la propiedad lastIndex se establece en 0. (También puede establecer lastIndex en cero en cualquier momento, lo que debe hacerse en todos los casos en los que la búsqueda se completa antes de que se complete la última coincidencia en la misma línea. encontrado y comienza a buscar en otra cadena con el mismo objeto RegExp.) Este comportamiento especial permite que se llame a exec () repetidamente para iterar sobre todas las coincidencias de expresiones regulares en la cadena. Por ejemplo:

Var patrón = / Java / g; var text = "¡JavaScript es más divertido que Java!"; var result; while ((resultado = patrón.exec (texto))! = nulo) (console.log ("Encontrado" "+ resultado +" "" + "en la posición" + resultado.index + "; la próxima búsqueda comenzará con" + patrón .lastIndex);)

Otro método de objeto RegExp - prueba () que es mucho más simple que el método exec (). Toma una cadena y devuelve verdadero si la cadena coincide con una expresión regular:

Var patrón = / java / i; pattern.test ("JavaScript"); // Devuelve verdadero

Llamar a test () es equivalente a llamar a exec (), devolviendo verdadero si exec () devuelve un valor no nulo. Por esta razón, el método test () se comporta igual que el método exec () cuando se llama para una expresión regular global: comienza a buscar la cadena especificada en la posición dada por la propiedad lastIndex, y si encuentra una coincidencia, establece la propiedad lastIndex al número de posición del carácter, directamente al lado de la coincidencia encontrada. Por lo tanto, usando el método test (), también puede formar un bucle para atravesar una línea como con el método exec ().

regex ANTES

Se sabe que sintaxis literal preferida(/ prueba / i).

Si la expresión regular no se conoce de antemano, entonces es preferible crear la expresión regular (en una cadena de caracteres) usando el constructor (new RegExp).

Pero preste atención, dado que la "barra" \ juega el papel de cambiar el código, entonces en el literal de cadena (nueva RegExp) debe escribirse dos veces: \\

Banderas

Ignoro el caso al hacer coincidir

g coincidencia global, a diferencia de local (de forma predeterminada, coincide solo con la primera instancia del patrón) permite coincidencias con todas las instancias del patrón

Operadores

Clases de caracteres predefinidas

Agrupación ()

Si desea aplicar un operador, por ejemplo, + (/ (abcd) + /) a un grupo de miembros, puede usar paréntesis ().

Fijación

La parte de la expresión regular entre paréntesis () se llama fijación.

Considere el siguiente ejemplo:

/ ^ () k \ 1 /

\ 1 no es ningún carácter de a, b, c.
\ 1 es cualquier personaje que inicie coincidir con el primer carácter... Es decir, el carácter que coincide con \ 1 se desconoce hasta que se resuelve la expresión regular.

Grupos no fijos

Los corchetes () se utilizan en 2 casos: para agrupar y para confirmar. Pero hay situaciones en las que necesitamos usar () solo para agrupar, ya que no se requiere ningún compromiso, además, al eliminar los compromisos innecesarios, lo hacemos más fácil para el motor de procesamiento de expresiones regulares.

Así que para prevenir el compromiso antes del paréntesis de apertura, debes poner:?:

Str = "

" ]

Función de prueba

Regexp.test ()

La función de prueba comprueba si la expresión regular coincide con la cadena (str). Devuelve verdadero o falso.

Ejemplo de uso:

Javascript

función codeF (str) (return /^\d(5)-\d(2)/.test(str);) //console.log(codeF("12345-12ss ")); // verdadero //console.log(codeF("1245-12ss ")); // falso

Función de coincidencia

str.match (regexp)

La función de coincidencia devuelve una matriz de valores, o nulo si no se encontraron coincidencias. Echale un vistazo: si la bandera g está ausente en la expresión regular (para realizar una búsqueda global), entonces el método de coincidencia devolverá la primera coincidencia en la cadena, mientras que, como puede ver en el ejemplo, en una matriz de coincidencias arreglarse(la parte de la expresión regular entre paréntesis).

Javascript

str = "Para obtener información, consulte: Capítulo 3.4.5.1"; re = / head (\ d + (\. \ d) *) / i // con confirmaciones (sin casilla de verificación global) encontrado = str.match (re) console.log (encontrado); // ["Capítulo 3.4.5.1", "3.4.5.1", ".1"]

Si proporciona el método match () con una expresión regular global (con el indicador g), también se devolverá una matriz, pero con coincidencias GLOBALES... Es decir, no se devuelven resultados confirmados.

Javascript

str = "Para obtener más información, consulte: Capítulo 3.4.5.1, Capítulo 7.5"; re = / head (\ d + (\. \ d) *) / ig // sin confirmaciones - globalmente encontrado = str.match (re) console.log (encontrado); // ["Capítulo 3.4.5.1", "Capítulo 7.5"]

Función ejecutiva

regexp.exec (str)

La función exec comprueba si la expresión regular coincide con la cadena (str). Devuelve una matriz de resultados (con confirmaciones) o nulos. Cada llamada posterior al método exec (por ejemplo, cuando se usa while) ocurre (debido a Actualización automática al ejecutar exec del índice del final de la última búsqueda lastIndex) ir a la siguiente coincidencia global (si la bandera g está marcada).

Javascript

var html = "

¡BAM! ¡CULO!

"; var reg = /<(\/?)(\w+)([^>] *?)> / g; //console.log(reg.exec(html)); // ["

"," "," div "," class = "test" "] while ((match = reg.exec (html))! == null) (console.log (reg.exec (html));) / * [" "," "," B "," "] [" "," "," em "," "] ["

"," / "," div "," "] * /

Sin una bandera global, los métodos de coincidencia y ejecución funcionan de manera idéntica. Es decir, devuelven una matriz con la primera coincidencia global y se compromete.

Javascript

// coincide con var html = "

¡BAM! ¡CULO!

"; var reg = /<(\/?)(\w+)([^>] *?)> /; // no global console.log (html.match (reg)); // ["

"," "," div "," class = "test" "] // exec var html ="

¡BAM! ¡CULO!

"; var reg = /<(\/?)(\w+)([^>] *?)> /; // sin consola global.log (reg.exec (html)); // ["

"," "," div "," class = "test" "]

Reemplazar función

str.replace (regexp, newSubStr | función)

• regexp - reg. expresión;
• newSubStr: la línea a la que se cambia la expresión encontrada en el texto;
• función - llamada para cada coincidencia encontrada con una lista de parámetros variables (recuerde que una búsqueda global en una cadena encuentra todas las instancias de una coincidencia de patrón).

El valor de retorno de esta función sirve como reemplazo.

Parámetros de función:

• 1 - Subcadena completa emparejada.
• 2 - El significado de los grupos de soportes (fijaciones).
• 3 - Índice (posición) de la coincidencia en la cadena original.
• 4 - La cadena original.

El método no cambia la cadena de llamada, pero devuelve una nueva después de reemplazar las coincidencias. Para realizar una búsqueda global y reemplazar, use regexp con la bandera g.

"GHGHGHGTTTT" .replace (// g, "K"); // "KKKKKKKKKKK"

Javascript

function upLetter (allStr, letter) (return letter.toUpperCase ();) var res = "border-top-width" .replace (/ - (\ w) / g, upLetter); console.log (res); // borderTopWidth

Última modificación: 1.11.2015

Expresiones regulares representan un patrón que se utiliza para buscar o modificar una cadena. Para trabajar con expresiones regulares en JavaScript, se define un objeto RegExp.

Hay dos formas de definir una expresión regular:

Var myExp = / hola /; var myExp = new RegExp ("hola");

La expresión regular utilizada aquí es bastante simple: consta de una sola palabra "hola". En el primer caso, la expresión se coloca entre dos barras diagonales, y en el segundo caso, se usa el constructor RegExp, en el que la expresión se pasa como una cadena.

Métodos RegExp

Para determinar si una expresión regular coincide con una cadena, el método test () se define en el objeto RegExp. Este método devuelve verdadero si la cadena coincide con la expresión regular y falso si no lo hace.

Var initialText = "¡hola mundo!"; var exp = / hola /; var result = exp.test (initialText); document.write (resultado + "
"); // true initialText =" beautifull weather "; result = exp.test (initialText); document.write (result); // false - no hay" hola "en la línea initialText

El método exec funciona de manera similar: también verifica si la cadena coincide con una expresión regular, solo que ahora este método devuelve la parte de la cadena que coincide con la expresión. Si no hay ninguna coincidencia, se devuelve un valor nulo.

Var initialText = "¡hola mundo!"; var exp = / hola /; var result = exp.exec (initialText); document.write (resultado + "
"); // hola initialText =" beautifull weather "; result = exp.exec (initialText); document.write (result); // null

Grupos de personajes

Una expresión regular no tiene que ser cadenas regulares, pero también puede incluir elementos de sintaxis de expresión regular especiales. Uno de estos elementos representa grupos de caracteres entre corchetes. Por ejemplo:

Var initialText = "defensas"; var exp = / [abc] /; var result = exp.test (initialText); document.write (resultado + "
"); // true initialText =" city "; result = exp.test (initialText); document.write (result); // false

La expresión [abc] indica que la cadena debe tener una de tres letras.

Si necesitamos determinar la presencia de caracteres alfabéticos de un cierto rango en una cadena, entonces podemos establecer este rango una vez:

Var initialText = "defensas"; var exp = / [a-z] /; var result = exp.test (initialText); document.write (resultado + "
"); // true initialText =" 3di0789 "; result = exp.test (initialText); document.write (result); // false

En este caso, la cadena debe contener al menos un carácter de rango a-z.

Si, por el contrario, no es necesario que la cadena tenga solo ciertos caracteres, entonces es necesario poner el signo ^ entre corchetes antes de la enumeración de caracteres:

Var initialText = "defensas"; var exp = / [^ a-z] /; var result = exp.test (initialText); document.write (resultado + "
"); // falso initialText =" 3di0789 "; exp = / [^ 0-9] /; result = exp.test (initialText); document.write (result); // true

En el primer caso, la cadena no debe tener solo caracteres del rango az, pero dado que la cadena "defensas" consta solo de caracteres de este rango, el método test () devuelve falso, es decir, la expresión regular no coincide con el existencias.

En el segundo caso ("3di0789"), la cadena no debe contener solo caracteres numéricos. Pero dado que la cadena también contiene letras, la cadena coincide con la expresión regular, por lo que el método de prueba devuelve verdadero.

Si es necesario, podemos recopilar combinaciones de expresiones:

Var initialText = "inicio"; var exp = / [dt] o [nm] /; var result = exp.test (initialText); document.write (resultado); // cierto

La expresión [dt] o [nm] indica aquellas cadenas que pueden contener subcadenas "casa", "volumen", "don", "tono".

Propiedades de expresión

La propiedad global le permite encontrar todas las subcadenas que coinciden con la expresión regular. De forma predeterminada, al buscar subcadenas, la expresión regular selecciona la primera subcadena encontrada de la cadena que coincide con la expresión. Aunque puede haber muchas subcadenas en una cadena que también coincidan con la expresión. Para esto, esta propiedad se usa en forma del símbolo g en expresiones

La propiedad ignoreCase le permite encontrar subcadenas que coincidan con la expresión regular, independientemente del caso de los caracteres de la cadena. Para hacer esto, el carácter i se usa en expresiones regulares

La propiedad multilínea le permite encontrar subcadenas que coincidan con una expresión regular en texto multilínea. Para hacer esto, el símbolo m se usa en expresiones regulares.

Por ejemplo:

Var initialText = "hola mundo"; var exp = / mundo /; var result = exp.test (initialText); // falso

No hay coincidencia entre la cadena y la expresión, ya que "World" difiere de "world" en el caso. En este caso, debe cambiar la expresión regular agregando la propiedad ignoreCase:

Var exp = / mundo / i;

Bueno, también podemos usar varias propiedades a la vez.

Pruebas: cómo llamar gratis desde una computadora a un teléfono móvil

¿Cómo restauro la barra de idioma?

Cómo restablecer una computadora portátil Packard Bell a la configuración de fábrica Instrucciones para restablecer una computadora portátil a la configuración de fábrica

Descripción general de Ontrack EasyRecovery Professional Recupere archivos eliminados con easyrecovery professional