Una breve discusión sobre el uso de objetos y soportes regexp para expresiones regulares JS

Autor：Eve Cole Fecha de actualización：2025-08-30 06:32:02

Creación del objeto regexp:

La creación de expresiones regulares regulares se puede hacer directamente, es decir, caracteres encerrados por Slash "/". Sin embargo, en un entorno donde se requieren cambios de parámetros, el constructor regexp () es una mejor opción:

var reg1 =/'/w+'/g;

var reg2 = new Regexp ('/' // w+/'', 'g');

Comparando los dos métodos de creación, el primer parámetro en Regexp es la cadena regular que se creará. Por un lado, no es una representación directa de la cantidad, por lo que no está encerrada con un corte "/"; En cambio, la marca de cita "'" y el símbolo de escape "/" deben ser cuadráticos escapados en la cadena.

Además, ya sea la cantidad directa o el constructor REGEXP (), se genera un nuevo objeto REGEXP y se asigna a una variable.

Similitudes y diferencias entre Match () y Exec ():

Match y Exec son formas comunes de combinar las cadenas para expresiones regulares. Las funciones implementadas por los dos son similares, con algunas diferencias sutiles:

1. Cómo usar

Match es un método para envolver objetos con cadenas, uso: string.match (regexp);

EXEC es un método de un objeto de expresión regular, uso: regexp.exec (string);

2. Resultados devueltos

Cuando Regexp no establece la bandera global "G":

Los resultados de retorno de ambos son los mismos. Es decir, cuando no hay un valor coincidente, devuelve nulo, y cuando hay un valor coincidente, devuelve una matriz (vamos a la matriz). La matriz [0] es una cadena coincidente, matriz [1], matriz [2] ... corresponde a sustros paréntesis coincidentes en expresiones regulares. Al mismo tiempo, la matriz tiene dos propiedades. Array.Index representa la posición inicial de la cadena coincidente, y Array.input representa la cadena que se está recuperando.

Cuando Regexp tiene la bandera global "G" establecido:

Match devuelve una matriz de matriz cuando hay un valor. Cada elemento en la matriz representa todas las cadenas que coinciden, por lo que no hay más subcadenas que coincidan con paréntesis. En este momento, la matriz no tiene atributo de índice y atributo de entrada.

Exec no es diferente del rendimiento sin la etiqueta global "G". La matriz de matriz devuelta, la matriz [0] es la cadena de coincidencia actual, matriz [1], matriz [2] ... es la cadena de coincidencia actual. En este momento, preste atención a la propiedad de LastIdex del objeto Regexp, que representa la última posición al final de la cadena coincidente en la cadena original. Cuando no hay más resultados coincidentes, la propiedad LastIdex se establece en 0. Por lo tanto, puede usar el bucle LastIdex para encontrar todas las cadenas coincidentes.

Admite múltiples métodos de coincidencia:

código JS

 var teststr = "ahora test001 test002"; var re =/test (/d+)/ig; var r = ""; while (r = re.exec (teststr)) {alert (r [0] + "" + r [1]); }

Además, también puede usar TestStr.Match (RE), pero de esta manera, no hay opción para G, y solo puede obtener la primera coincidencia.

1. Reglas de expresión regulares

1.1 caracteres normales

Las letras, números, caracteres chinos, subrayos y signos de puntuación que no están específicamente definidos en los siguientes capítulos son todos "caracteres ordinarios". Cuando un carácter normal en una expresión coincide con una cadena, coincide con el mismo carácter que él.

Ejemplo 1: Cuando la expresión "C", al coincidir la cadena "ABCDE", el resultado coincidente es: Success; El contenido coincidente es: "C"; La posición de coincidencia es: comenzar a las 2 y finalizar a las 3. (Nota: el subíndice comienza desde 0 o 1, que puede variar según el lenguaje de programación actual)

Ejemplo 2: Cuando la expresión "BCD", al coincidir la cadena "ABCDE", el resultado coincidente es: exitoso; El contenido coincidente es: "BCD"; La posición coincidente es: Comience en 1 y finalice a las 4.

1.2 personajes de escape simples

Para algunos personajes que son inconvenientes de escribir, use el método de agregar "/" al frente. Ya estamos familiarizados con estos personajes.

expresión	Combinable
/r, /n	Representa el retorno del carro y la ruptura de la línea
/t	Símbolos de pestaña
//	Representa "/" en sí mismo

Hay otros signos de puntuación que son especiales para su uso en los siguientes capítulos. Después de agregar "/" al frente, representan el símbolo en sí. Por ejemplo: ^ y $ tienen significados especiales. Si desea igualar los caracteres "^" y "$" en una cadena, la expresión debe escribirse como "/^" y "/$".

expresión	Combinable
/^	Coincidir ^ símbolo mismo
/$	Coincide con el símbolo $ en sí
/.	Coincidir con el punto decimal () mismo

El método de coincidencia de estos personajes escapados es similar a los "caracteres normales". También coincide con el mismo personaje.

Ejemplo 1: Cuando la expresión "/$ D", al coincidir la cadena "ABC $ DE", el resultado correspondiente es: Success; El contenido coincidente es: "$ D"; La posición coincidente es: Comience a las 3 y termine a las 5.

1.3 Expresiones que pueden igualar 'múltiples caracteres'

Algunos métodos de representación en expresiones regulares pueden coincidir con cualquiera de los 'múltiples caracteres'. Por ejemplo, la expresión "/D" puede coincidir con cualquier número. Aunque puede coincidir con cualquier personaje en él, solo puede ser uno, no múltiple. Esto es como cuando se juega cartas de póker, los reyes grandes y pequeños pueden reemplazar cualquier carta, pero solo pueden reemplazar una tarjeta.

expresión	Combinable
/d	Cualquier número, cualquiera de 0 ~ 9
/W	Cualquier carta, número o subrayado, es decir, cualquiera de A ~ Z, A ~ Z, 0 ~ 9, _
/s	Cualquiera de los caracteres en blanco, incluidos espacios, pestañas, saltos de página, etc.
.	El punto decimal puede coincidir con cualquier carácter, excepto el carácter de Newline (/N).

Ejemplo 1: Cuando la expresión "/D/D", al coincidir "ABC123", el resultado de la coincidencia es: éxito; El contenido coincidente es: "12"; La posición emparejada es: comenzar a 3 y finalizar a las 5.

Ejemplo 2: Cuando la expresión "A./D", al coincidir "AAA100", el resultado del partido es: éxito; El contenido coincidente es: "AA1"; La posición coincidente es: Comience en 1 y finalice a las 4.

1.4 Personalizar expresiones que pueden coincidir con 'múltiples caracteres'

Use soportes cuadrados [] para contener una serie de caracteres que pueden igualar cualquiera de ellos. Si usa [^] para contener una serie de caracteres, puede coincidir con cualquier personaje que no sea los personajes. Del mismo modo, aunque puede igualar cualquiera de ellos, solo puede ser uno, no múltiple.

expresión	Combinable
[AB5@]	Coincidir con "a" o "b" o "5" o "@"
[^ABC]	Haga coincidir con cualquier personaje que no sea "A", "B", "C"
[FK]	Haga coincidir cualquier carta entre "f" ~ "k"
[^A-F0-3]	Coincidir con cualquier personaje que no sea "a" ~ "f", "0" ~ "3"

Ejemplo 1: Cuando la expresión "[BCD] [BCD]" coincide "ABC123", el resultado de la coincidencia es: éxito; El contenido coincidente es: "BC"; La posición coincidente es: Comience en 1 y finalice a las 3.

Ejemplo 2: Cuando la expresión "[^ABC]" coincide "ABC123", el resultado de la coincidencia es: éxito; El contenido coincidente es: "1"; La posición coincidente es: Comience a las 3 y finalice a las 4.

1.5 símbolos especiales que modifican el número de coincidencias

Las expresiones mencionadas en el capítulo anterior solo pueden coincidir con un personaje o cualquiera de los múltiples personajes. Si usa una expresión más un símbolo especial que modifica el número de coincidencias, puede repetir la coincidencia sin escribir repetidamente la expresión.

El método de usarlo es: "Número de modificación" se coloca después de la "expresión modificada". Por ejemplo: "[BCD] [BCD]" se puede escribir como "[BCD] {2}".

expresión	efecto
{norte}	La expresión se repite n veces, por ejemplo: "/w {2}" es equivalente a "/w/w"; "A {5}" es equivalente a "aaaaa"
{Minnesota}	La expresión se repite al menos m veces, y como máximo n veces. Por ejemplo: "BA {1,3}" puede coincidir con "ba" o "baa" o "baaa"
{metro,}	La expresión se repite al menos m veces, por ejemplo: "/w/d {2,}" puede coincidir con "A12", "_ 456", "M12344" ...
?	La expresión de coincidir 0 o 1, que es equivalente a {0,1}, por ejemplo: "A [CD]?" puede igualar "a", "ac", "anuncio"
+ +	La expresión aparece al menos una vez, que es equivalente a {1,}. Por ejemplo: "A+B" puede igualar "AB", "AAB", "AAAB" ...
*	La expresión no aparece o ocurre en ningún momento, que es equivalente a {0,}. Por ejemplo: "/^*B" puede igualar "B", "^^^ B" ...

Ejemplo 1: Cuando la expresión "/d+/.?/d*" coincide con "cuesta $ 12.5", el resultado de la coincidencia es: exitoso; El contenido coincidente es: "12.5"; La posición coincidente es: Comience a las 10 y termine a las 14.

Ejemplo 2: Cuando la expresión "GO {2,8} gle" coincide con "anuncios de GooooOgle", el resultado del partido es: Success; El contenido emparejado es: "GooooOgle"; La posición coincidente es: Comience a las 7 y termine a las 17.

1.6 Algunos otros símbolos especiales que representan un significado abstracto

Algunos símbolos representan el significado especial de la abstracción en las expresiones:

expresión	efecto
^	Coincide con el lugar donde comienza la cadena, no ningún personaje
$	Coincide con el final de la cadena, no coincide con ningún personaje
/b	Haga coincidir un límite de palabra, es decir, la posición entre la palabra y el espacio, y no coincide con ningún personaje

Otras descripciones de texto siguen siendo relativamente abstractas, así que dé ejemplos para ayudar a todos a comprender.

Ejemplo 1: Cuando la expresión "^aaa" coincide "xxx aaa xxx", el resultado coincidente es: fallado. Porque "^" requiere coincidir donde comienza la cadena, "^aaa" solo puede coincidir cuando "aaa" está al comienzo de la cadena, por ejemplo: "aaa xxx xxx".

Ejemplo 2: Cuando la expresión "AAA $" coincide con "xxx aaa xxx", el resultado coincidente es: fallado. Debido a que "$" requiere coincidir con el final de la cadena, "AAA $" puede coincidir solo cuando "AAA" está al final de la cadena, por ejemplo: "xxx xxx aaa".

Ejemplo 3: Cuando la expresión "./B". coincide con "@@@ ABC", el resultado correspondiente es: exitoso; El contenido coincidente es: "@a"; La posición coincidente es: Comience a las 2 y termine a las 4.

Explicación adicional: "/B" es similar a "^" y "$", que no coincide con ningún personaje, pero requiere que esté en los lados izquierdo y derecho de la posición en el resultado coincidente, un lado es el rango "/W" y el otro lado es el rango no-"/W".

Ejemplo 4: Cuando la expresión "/bend/b" coincide "fin de semana, final, final", el resultado correspondiente es: exitoso; El contenido coincidente es: "End"; La posición coincidente es: Comience a las 15 y termine a las 18.

Algunos símbolos pueden afectar la relación entre subexpresiones dentro de una expresión:

expresión

efecto

La relación "o" entre las expresiones en los lados izquierdo y derecho, que coinciden con los lados izquierdo o derecho

()

(1). Cuando se modifica el número de coincidencias, la expresión en los soportes se puede modificar en su conjunto.

(2). Al tomar el resultado coincidente, el contenido coincidente por la expresión en los soportes se puede obtener por separado

Ejemplo 5: Cuando la expresión "Tom | Jack" coincide con la cadena "Soy Tom, él es Jack", el resultado correspondiente es: exitoso; El contenido coincidente es: "Tom"; La posición coincidente es: Comience a 4 y finalice a las 7. Al igualar el siguiente, el resultado correspondiente es: exitoso; El contenido coincidente es: "Jack"; Al igualar la posición: comienza a los 15 y termina a las 19.

Ejemplo 6: Expresión "(Go/S*)+" Cuando coincida "¡vamos Go Go!", El resultado correspondiente es: exitoso; El contenido coincidente es: "Go Go Go Go"; La posición coincidente es: Comience a las 6 y termine a las 14.

Ejemplo 7: Cuando la expresión "￥ (/d+/.?/D*)" se combina con "￥ 10.9, ￥ 20.5", el resultado de la coincidencia es: exitoso; El contenido coincidente es: "￥ 20.5"; La posición coincidente es: Comience a las 6 y finalice a las 10. El contenido que obtiene las coincidencias de rango de soporte por separado es: "20.5".

2. Algunas reglas avanzadas en expresiones regulares

2.1 Greed y no greedia en tiempos de partido

Al usar símbolos especiales que modifican el número de coincidencias, hay varios métodos de representación que permiten que la misma expresión coincida con diferentes tiempos, como: "{m, n}", "{m,}", "?", "?", "*", "+". El número específico de coincidencias depende de la cadena coincidente. Esta expresión con un número incierto de partidos repetidos siempre coincide tantas veces como sea posible durante el proceso de coincidencia. Por ejemplo, para el texto "dxxxdxxxd", lo siguiente es:

expresión	Resultados de coincidencias
(d) (/W+)	"/w+" coincidirá con todos los personajes después del primer "d" "xxxdxxxd"
(d) (/w+) (d)	"/w+" coincidirá con todos los personajes "xxxdxxx" entre el primer "d" y el último "d". Aunque "/W+" también puede coincidir con el último "D", para que toda la expresión coincida con éxito, "/W+" puede "sacar" la última "D" que podría coincidir.

Se puede ver que cuando "/W+" coincide, siempre coincide con tantos personajes que cumplan con sus reglas como sea posible. Aunque en el segundo ejemplo, no coincide con la última "D", también es hacer que toda la expresión coincida con éxito. Del mismo modo, las expresiones con "*" y "{m, n}" coinciden con tantas como sea posible, y expresiones con "?" También se "coinciden" tanto como sea posible cuando puedan coincidir o no coincidir. Este principio coincidente se llama patrón de "codicia".

Modo no verde:

Agregar un "?" Firme después de modificar el símbolo especial del número de partidos puede hacer expresiones con un número variable de coincidencias tan pocas como sea posible, de modo que las expresiones que puedan coincidir o no coinciden se pueden "coincidir" tanto como sea posible. Este principio coincidente se llama el patrón "no verde", también llamado patrón "Barb". Si hay pocas coincidencias, hará que toda la expresión falle. Similar al modo codicioso, el modo no verde coincidirá en la medida mínima para que toda la expresión coincida con éxito. Por ejemplo, para el texto "dxxxdxxxd":

expresión	Resultados de coincidencias
(d) (/W+?)	"/W+?" coincidirá con los pocos personajes después del primer "D" como sea posible, y el resultado es: "/W+?" Solo coincide con una "x"
(d) (/w+?) (D)	Para que toda la expresión coincida con éxito, "/W+?" tiene que coincidir con "xxx" para hacer que la posterior coincida "D", de modo que toda la expresión coincida con éxito. Entonces el resultado es: "/W+?" coinciden "xxx"

Para más casos, consulte lo siguiente:

Ejemplo 1: Cuando la expresión "<TD> (.*) </td>" coincide con la cadena "<TD> aa </td> <td> bb </td>", el resultado coincidente es: Success; La coincidencia es "<td> aa </td>" toda la cadena, y el "</td>" en la expresión coincidirá con el último "</td>" en la cadena.

Ejemplo 2: en contraste, cuando la expresión "<TD> (.*?) </td>" coincide con la misma cadena en el Ejemplo 1, solo obtendrá "<TD> aa </td>". Cuando coincida con el próximo nuevamente, obtendrá el segundo "<TD> bb </td>".

2.2 Backreferencias /1, /2 ...

Cuando una expresión coincide, el motor de expresión registra la cadena coincidente por la expresión contenida en el soporte "()". Al obtener el resultado coincidente, la cadena coincidente por la expresión contenida en los soportes se puede obtener por separado. Esto se ha demostrado muchas veces en los ejemplos anteriores. En aplicaciones prácticas, cuando se usa un determinado límite para buscar, y el contenido a recuperar no contiene límites, los soportes deben usarse para especificar el rango deseado. Por ejemplo, el anterior "<TD> (.*?) </td>".

De hecho, "la cadena coincidente con la expresión contenida en los soportes" no solo se puede usar después de que termine el partido, sino también durante el proceso de coincidencia. La parte después de la expresión puede referirse a la "cadena de subprota anterior que se ha combinado" entre paréntesis. El método de referencia es agregar un número "/". "/1" se refiere a la cadena coincidente en el primer par de soportes, "/2" se refiere a la cadena coincidente en el segundo par de soportes ... y así sucesivamente, si un par de soportes contiene otro par de soportes, los soportes externos están ordenados primero. En otras palabras, si el par tiene el soporte izquierdo "(" Antes, entonces el par primero se ordenará.

Como ejemplo:

Ejemplo 1: La expresión "('|") (.*?) (/1) "Al igualar"' Hola ', "Mundo" ", el resultado del partido es: exitoso; el contenido coincidente es:"' Hola '". Al igualar el próximo nuevamente, puede coincidir con" "Mundo" ".

Ejemplo 2: Cuando la expresión "(/W)/1 {4,}" se combina con "AA BBBB ABCDEFG CCCCC 111121111 999999999999", el resultado del partido es: exitoso; El contenido coincidente es "CCCCCC". Cuando coincida con el próximo nuevamente, obtendrá 9999999999. Esta expresión requiere que los caracteres en el rango "/W" se repitan al menos 5 veces, prestando atención a la diferencia de "/W {5,}".

Ejemplo 3: La expresión "<(/w+)/s*(/w+(= ('|").*?/4)?/S*)*>.*? <// 1> "coincide" <td id =' td1 'style = "bgcolor: white"> </td> ". Si" <td> "no se combina con" </td> ", el partido no va a ser otro par de pares; el pareja también puede cambiar; exitoso.

2.3 Pre-búsqueda, desajuste; Reverse previa a la búsqueda, desajuste

En el capítulo anterior, hablé sobre varios símbolos especiales que representan significados abstractos: "^", "$", "/B". Todos tienen una cosa en común: ellos mismos no coinciden con ningún personaje, sino que solo adjuntan una condición a "dos extremos de una cadena" o "ranuras entre los caracteres". Después de comprender este concepto, esta sección continuará introduciendo otro método de representación más flexible que agrega condiciones a "dos extremos" o "hendiduras".

Reenviar pre-búsqueda: "(? = Xxxxx)", "(?! xxxxxx)"

Formato: "(? = Xxxxx)", en la cadena coincidente, la condición unida a la "hendidura" o "dos extremos" es que el lado derecho del espacio debe poder coincidir con la expresión de la parte xxxxx. Debido a que es solo una condición adicional en esta brecha, no afecta la expresión posterior para que realmente coincida con los caracteres después de esta brecha. Esto es similar a "/B", que no coincide con ningún personaje. "/B" solo toma a los personajes antes y después de la brecha y hace un juicio, y no afectará las expresiones detrás para que realmente coincidan.

Ejemplo 1: Cuando la expresión "Windows (? = NT | XP)" coincide con "Windows 98, Windows NT, Windows 2000", solo coincidirá con "Windows" en "Windows NT", y otras palabras "Windows" no se combinará.

Ejemplo 2: expresión "(/w) ((? =/1/1/1) (/1))+" Al igualar la cadena "AAA FFFFFF 9999999999", podrá coincidir con los primeros 4 de 6 "F" y el primer 7 de 9 "9". Esta expresión se puede leer e interpretar como: repetir el número alfanumérico más de 4 veces coincidirá con la pieza antes de los últimos 2 dígitos. Por supuesto, esta expresión no se puede escribir así, y el propósito aquí es para fines de demostración.

Formato: "(?

Ejemplo 3: Expresión "((? Si no hay "parar" en la cadena, toda la cadena se combinará.

Ejemplo 4: La expresión "do (? En este artículo, el efecto de usar "hacer" después "(?!/W)" y usar "/b" es el mismo.

Reverse Pre-Search: "(? <= Xxxxx)", "(? <! Xxxxxx)"

Los conceptos de estos dos formatos son similares a la búsqueda previa del avance. Los requisitos para la pre-búsqueda inversa son: el "lado izquierdo" del espacio. Los dos formatos requieren que deben poder igualar y no deben poder igualar la expresión especificada, en lugar de juzgar el lado derecho. Al igual que "Forward Pre-Search": ambos son una condición adicional para la brecha en la que se encuentran y no coinciden con ningún personaje.

Ejemplo 5: La expresión "(? <=/D {4})/d+(? =/D {4})" Al igualar "1234567890123456", los 8 números medios, excepto los primeros 4 números y los últimos 4 números se combinarán. Dado que jscript.regexp no es compatible con la pre-búsqueda inversa, este artículo no se puede demostrar. Muchos otros motores pueden admitir una prevención inversa, como: java.util.regex paquete por encima de Java 1.4, el espacio de nombres System.Text.regularexpressions en .NET, y el motor regular Deelx más simple y fácil recomendado por este sitio.

3. Otras reglas comunes

También hay algunas reglas que son más comunes entre varios motores de expresión regulares, que no se mencionaron en la explicación anterior.

3.1 en expresiones, "/xxx" y "/uxxxx" se pueden usar para representar un carácter ("x" significa un número hexadecimal)

forma	Rango de personajes
/xxx	Los caracteres con números en el rango 0 a 255, tales como: Los espacios pueden estar representados por "/x20"
/uxxxxx	Cualquier personaje puede estar representado por "/u" más su número de números hexadecimales de 4 dígitos, como "/Medium"

3.2 Mientras que las expresiones "/s", "/d", "/w", "/b" representan significados especiales, las letras mayúsculas correspondientes representan significados opuestos

expresión	Combinable
/S	Coinciden con todos los caracteres no whitpace ("/s" puede coincidir con los personajes de espacios en blanco individuales)
/D	Coincidir con todos los personajes no numéricos
/W	Coincidir con todos los personajes que no sean letras, números y subrayadores
/B	Coinciden con los límites que no son de las palabras, es decir, los espacios de caracteres cuando ambos lados son "/W" en los lados izquierdo y derecho no son "/W" en los lados izquierdo y derecho no son "/W" en los lados izquierdo y derecho no son

3.3 Hay un significado especial en la expresión, y es necesario agregar "/" para que coincida con el resumen del personaje del personaje en sí.

personaje	ilustrar
^	Coincide con la posición de inicio de la cadena de entrada. Para que coincida con el "^" personaje en sí, use "/^"
$	Coincide con la posición final de la cadena de entrada. Para que coincida con el personaje "$" en sí, use "/$"
()	Marca las posiciones de inicio y final de una subexpresión. Para que coincidan con los soportes, use "/(" y "/)"
[]	Use expresiones personalizadas que puedan coincidir con 'múltiples caracteres'. Para que coincidan con los soportes, use "/[" y "/]"
{}	Símbolos que modifican el número de coincidencias. Para coincidir con los aparatos ortopédicos, use "/{" y "/}"
.	Haga coincidir cualquier personaje, excepto la nueva línea (/n). Para que coincida con el punto decimal en sí, use "/".
?	El número de coincidencias de modificación es 0 o 1. Para que coincida con el "?" personaje mismo, usa "/?"
+ +	El número de coincidencias de modificación es al menos 1 vez. Para que coincida con el personaje "+" en sí, use "/+"
*	El número de coincidencias de modificación es 0 o cualquiera. Para que coincida con el "" personaje en sí, use "/"
\|	La relación "o" entre las expresiones en los lados izquierdo y derecho. Partido "\|" en sí mismo, por favor use "/\|"

3.4 Subexpresión en los soportes "()". Si desea que el resultado coincidente no se grabe para uso futuro, puede usar el formato "(?: xxxxx)"

Ejemplo 1: Cuando la expresión "(?: (/W)/1)+" coincide "a bbccdd efg", el resultado es "bbccdd". El resultado coincidente del soporte "(? :)" El rango no está grabado, por lo tanto "(/w)" se usa para hacer referencia a él.

3.5 Introducción a la configuración de los atributos de expresión de uso común: Ignorecase, Singline, Multiline, Global

Propiedades de expresión	ilustrar
Ignorarse	Por defecto, las letras en las expresiones son sensibles a los boscos. Configurar como Ignorecase hace que la caja sea insensible cuando coincida. Algunos motores de expresión extienden el concepto de "caso" al caso del rango Unicode.
Singlota	Por defecto, el punto decimal "." coincide con los personajes que no sean los descansos de línea (/n). Configurar como singline para que el punto decimal coincida con todos los personajes, incluidos los descansos de línea.
Multilínea	Por defecto, las expresiones "^" y "$" solo coinciden con las posiciones ① ① y fin ④ de la cadena. como: ①XXXXXXXX2/N ③XXXXXXXXXX④ Configure Multiline para hacer una coincidencia "^", y también puede coincidir con la posición ③ antes de que comience la siguiente línea, de modo que "$" coincida ④, y también puede coincidir con la posición ② antes de la nueva línea y termina con una línea.
Global	Funciona principalmente cuando se usa expresiones para reemplazar, y está configurado como global para reemplazar todas las coincidencias.

4. Otros consejos

4.1 Si desea comprender que los motores regulares avanzados también admiten una sintaxis regular compleja, consulte la documentación del motor regular Deelx en este sitio.

4.2 Si desea requerir que la expresión coincida con toda la cadena, en lugar de encontrar una parte de la cadena, puede usar "^" y "$" al principio y al final de la expresión, por ejemplo: "^/d+$" requiere que toda la cadena solo tenga números.

4.3 Si el contenido requerido para que coincida es una palabra completa y no una parte de la palabra, use "/b" al principio y al final de la expresión, por ejemplo: use "/b(iF| When.

4.4 La expresión no coincide con una cadena vacía. De lo contrario, el partido tendrá éxito todo el tiempo, y nada se combinará. Por ejemplo: cuando se está preparando para escribir una expresión que coincida con "123", "123.", "123.5", ".5", etc., enteros, puntos decimales y los números decimales se pueden omitir, pero no escriba la expresión como: "/d*/. ?/d*", porque si no hay nada, esta expresión también puede coincidir con éxito. Una mejor manera de escribirlo es: "/d+/.?/d*|/./d+".

4.5 No buce infinitamente para subprocesos que pueden igualar las cadenas vacías. Si cada parte de la subexpresión en los soportes puede coincidir 0 veces, y los soportes en su conjunto pueden igualar los tiempos infinitos, entonces la situación puede ser más grave de lo que dijo el artículo anterior, y el proceso de correspondencia puede ser un bucle muerto. Aunque algunos motores de expresión regulares ahora han evitado el bucle muerto en esta situación, como las expresiones regulares de .NET, aún debemos tratar de evitar esta situación. Si encontramos un bucle muerto al escribir expresiones, también podemos comenzar desde este punto de vista y averiguar si esta es la razón mencionada en este artículo.

4.6 Elige razonablemente el modo codicioso y el modo no verde, consulte la discusión del tema.

4.7 o "|" En los lados izquierdo y derecho, es mejor coincidir solo con un lado de cierto carácter, de modo que las expresiones en ambos lados de "|" no diferirá debido a la posición de intercambio.

Siguiente artículo ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1. Definir expresiones regulares

1) Hay dos formas de definición de expresiones regulares, una es el método ordinario y el otro es el método de constructor.

2) Método normal: var reg =/expresión/parámetros adicionales

Expresión: una cadena que representa una determinada regla, donde ciertos caracteres especiales pueden usarse para representar reglas especiales, que se explicarán en detalle más adelante.

Parámetros adicionales: se utiliza para extender el significado de la expresión, actualmente hay tres parámetros principales:

G: significa que se puede realizar la coincidencia global.

I: Significa una coincidencia insensible en el caso.

M: significa que se puede realizar una coincidencia de múltiples filas.

Los tres parámetros anteriores se pueden combinar arbitrariamente para representar el significado compuesto y, por supuesto, no se agregan parámetros.

ejemplo:

var reg =/a*b/;

var reg =/abc+f/g;

3) Método del constructor: var reg = new Regexp ("Expression", "Agregar parámetros");

El significado de "expresión" y "parámetros adicionales" es el mismo que el método de definición anterior.

ejemplo:

var reg = new Regexp ("A*B");

var reg = new Regexp ("ABC+F", "G");

4) La diferencia entre los métodos ordinarios y los métodos de constructor

Una expresión de la manera normal debe ser una cadena constante, mientras que la expresión en el constructor puede ser una cadena constante o una variable JS, como un parámetro de expresión basado en la entrada del usuario, etc.:

var reg = new Regexp (document.forms [0] .exprfiled.value, "g");

2. Patrón de expresión

1) El patrón de expresión se refiere al método de expresión y al estilo de la expresión, es decir, ¿cómo describir la "expresión" en var reg =/expresión/parámetros adicionales?

2) Desde una perspectiva estandarizada, los patrones de expresión se dividen en patrones simples y patrones compuestos.

3) Patrón simple: se refiere a un patrón expresado a través de la combinación de caracteres ordinarios, por ejemplo

var reg =/abc0d/;

Se puede ver que los patrones simples solo pueden representar coincidencias específicas.

4) Patrón de compuesto: se refiere a un patrón expresado con caracteres comodín, por ejemplo:

var reg =/a+b?/w/;

El +,? y /W son todos personajes comodín y representan significados especiales. Por lo tanto, el patrón compuesto puede expresar una lógica más abstracta.

Centrémonos en el significado y el uso de cada comodín en el modo compuesto.

5) Explicación de caracteres especiales en modo compuesto:

1>/: se usa como carácter de escape en muchos lenguajes de programación. En general

Si el símbolo / Símbolo es seguido por el carácter C ordinario C, entonces / C representa un significado especial. Por ejemplo, N representa originalmente el carácter n, pero /n representa una nueva línea.

Si el símbolo / es seguido por un carácter especial C, entonces / C representa el carácter ordinario c. Por ejemplo, / se usa generalmente como carácter de escape, pero // se usa para sintonizar el carácter ordinario /.

El uso de / en la expresión regular de JavaScript es el mismo que el anterior, pero en diferentes lenguajes de programación, las tablas de caracteres especiales pueden ser diferentes.

2>^: Haga coincidir el comienzo de la cadena de entrada. Si es una coincidencia de múltiples líneas, es decir, los parámetros adicionales de la expresión contienen M, también se combinará después de una nueva línea.

ejemplo:

/^B/coincide con la primera b en "bab bc"

Ejemplo 2:

/^B/gm coincidencia

"Badd B

CDAF

B DSFB "

La primera línea en la primera b, la primera B en la tercera línea

3> $: Haga coincidir el final de la creación de caracteres de entrada. Si se trata de una coincidencia de múltiples líneas, es decir, los parámetros adicionales de la expresión contienen M, también se combinará antes de una nueva línea.

Contrariamente al uso de ^.

Ejemplo: / t $ / coincide t en "bat", pero no coincide con "odio"

Ejemplo 2: /T $ /Match

"Etiqueta en

murciélago"

La última T de la primera línea y la T de la segunda línea.

4>*: coincide con el personaje anterior 0 o más veces.

Ejemplo: /ab* /coincide con "abbbb" en "dddabbbbc", y también coincide con "a" en "ddda"

5>+: Haga coincidir con el personaje anterior 1 o más veces.

Ejemplo: / AB+ / Matches "ABBBB" en "DDDABBBBC", pero no coincide con "DDDA"

Similar al uso de los siguientes {1,} (prototipo: {n,})

6>?: ¿El uso de? es bastante especial. En términos generales, se usa para que coincida con el personaje anterior 0 veces o 1 vez, pero tiene otros dos usos especiales:

Si inmediatamente sigue *, +,? y {}, significa el número mínimo de coincidencias de la coincidencia original, por ejemplo:

/ BA*/ Originalmente combinó "Baaaa" en "bbbaaaa", pero/ ba*?/ emparejado "b" en "bbbaaaa" (porque*significa 0 o más coincidencias, mientras más? debería significar el número mínimo de partidos, es decir, 0 coincidencias).

Del mismo modo: / ba+? / Matches "Ba" en "Baaaa".

Como símbolo de estructura de sintaxis, se usa en pre-Assert, es decir, x (? = Y) y x (?! = y) que se mencionará más adelante.

7>.: El "." Firmar en el punto decimal coincide con cualquier personaje, excepto el carácter Newline.

¿Cuáles son los personajes del estándar en total? Consulte: Conjunto de personajes

Por ejemplo: / AB / Matches "ACB" en "ACBAA", pero no coincide con "ABBB".

8> (x): significa que coincida con X (no se refiere específicamente al carácter X o se refiere específicamente a un carácter, x representa una cadena), y la coincidencia será recordada. En la sintaxis, este tipo de () se llama "capturar padres", es decir, los soportes utilizados para capturar.

Los coincidencias se recordan porque en las funciones proporcionadas por la expresión, algunas funciones devuelven una matriz que contiene todas las cadenas de coincidencia, como la función Exec ().

También tenga en cuenta que la premisa de que X in () se recuerda es coincidir con X.

Ejemplo 1:

var regx =/a (b) c/;

var rs = regx.exec ("abcddd");

Como se puede ver en lo anterior, / a (b) c / coincide "ABC" en "ABCDDD". Debido a (), B también lo grabará, por lo que el contenido de número devuelto por RS es:

{ABC, B}

Ejemplo 2:

var regx =/a (b) c/;

var rs = regx.exec ("acbcddd");

RS Devuelve nulo, porque / a (b) c / no coincide con "acbcddd", por lo que b in () no se registrará (aunque la cadena contiene b)

9> (?: X): Match X, pero no recuerde x. () En este formato se llama "padres no capturantes", es decir, paréntesis para no capturar.

ejemplo:

var regx =/a (?: b) c/;

var rs = regx.exec ("abcddd");

Como se puede ver en lo anterior, / a (?: B) C / coinciden "ABC" en "ABCDDD", debido a (? :), B no se registrará, por lo que el contenido número devuelto por RS es:

{abecedario}

10> x (? = Y): coincidir x, solo si y se sigue de inmediato. Si el partido coincide, solo X será recordado y y no será recordado.

ejemplo:

var regx =/user (? = name)/;

var rs = regx.exec ("El nombre de usuario es Mary");

Resultado: la coincidencia es exitosa y el valor de RS es {usuario}

11> x (? Si el partido coincide, solo X será recordado y y no será recordado.

ejemplo:

var regx =/user (?! name)/;

var rs = regx.exec ("El nombre de usuario es Mary");

Resultado: la coincidencia es exitosa y el valor de RS es {usuario}

Ejemplo 2:

var regx = // d+(?!/.)/;

var rs = regx.exec ("54.235");

Result: The matching result, the value of rs is {5}, and the mismatch is because 54 is followed by the "." firmar. Of course, 235 also matches, but due to the behavior of the exec method, 235 will not be returned.

12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。

ejemplo:

var regx=/beijing|shanghai/;

var rs=regx.exec(“I love beijing and shanghai”);

结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。

13>{n}：匹配前一个字符的n次出现。

n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。

ejemplo:

var regx=/ab{2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

14>{n,}：匹配前一个字符的至少n次出现。

ejemplo:

var regx=/ab{2,}c/;

var rs=regx.exec(“abbcdabbbc”);

结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。

15>{n,m}：匹配前一个字符的至少n次最多m次的出现。

只要n与m为数字，而且m>=n就不会报语法错误。

ejemplo:

var regx=/ab{2,5}c/;

var rs=regx.exec(“abbbcd”);

结果：匹配成功，rs的值为：{abbbc}。

Ejemplo 2:

var regx=/ab{2,2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

例子3：

var regx=/ab(2,5)/;

var rs=regx.exec(“abbbbbbbbbb”);

Result: The match is successful, and the value of rs is: {abbbbb}, which means that if the previous character appears more than m times, it will only match m times. además:

var regx=/ab(2,5)c/;

var rs=regx.exec(“abbbbbbbbbbc”);

结果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b后面是c，但字符串中5个b之后还是b所以会报错。

16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[xz]。

ejemplo:

var regx=/a[bc]d/;

var rs=regx.exec(“abddgg”);

结果：匹配成功，rs的值为：{abd}

Ejemplo 2:

var regx=/a[bc]d/;

var rs=regx.exec(“abcd”);

结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。

17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^xz]。

ejemplo:

var regx=/a[^bc]d/;

var rs=regx.exec(“afddgg”);

结果：匹配成功，rs的值为：{afd}

Ejemplo 2:

var regx=/a[^bc]d/;

var rs=regx.exec(“abd”);

结果：匹配失败，rs的值为：。

18>[/b]：匹配退格键。

19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。

ejemplo:

var regx=//bc./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。

20>/B：代表一个非单词边界。

ejemplo:

var regx=//Bi./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。

21>/cX，匹配一个控制字符。例如， /cM 匹配一个Control-M 或

回车符。 x 的值必须为AZ 或az 之一。否则，将c 视为一

个原义的'c' 字符。（实际的例子还需补充）

21>/d：匹配一个数字字符，等同于[0-9]。

ejemplo:

var regx=/user/d/;

var rs=regx.exec(“user1”);

结果：匹配成功，rs的值为：{user1}

22>/D：匹配一个非数字字符，等同于[^0-9]。

ejemplo:

var regx=/user/D/;

var rs=regx.exec(“userA”);

结果：匹配成功，rs的值为：{userA}

23>/f：匹配一个换页符。

24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。

ejemplo:

var regx=/a/nbc/m;

var str=“a

antes de Cristo";

var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

25>/r：匹配一个回车符

26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029].

ejemplo:

var regx=//si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ i}

27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].

ejemplo:

var regx=//Si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ei}

28>/t：匹配一个tab

ejemplo:

var regx=/a/tb/;

var rs=regx.exec(“a bc”);

结果：匹配成功，rs的值为： {a bc}

29>/v：匹配一个竖向的tab

30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。

ejemplo:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{2}

31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。

ejemplo:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{$}

32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。

ejemplo:

var regx=/user([,-])group/1role/;

var rs=regx.exec(“user-group-role”);

结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。

33>/0：匹配一个NUL字符。

34>/xhh：匹配一个由两位16进制数字所表达的字符。

35>/uhhhh：匹配一个由四位16进制数字所表达的字符。

3，表达式操作

1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。

2）表达式对象（RegExp）方法：

1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如：

var regx=//d+/;

var rs=regx.exec(“3432ddf53”);

返回的rs值为：{3432}

var regx2=new RegExp(“ab(/d+)c”);

var rs2=regx2.exec(“ab234c44”);

返回的rs值为：{ab234c,234}

In addition, if there are multiple suitable matches, exec is executed for the first time and exec is continued, the second and third matches are returned in turn. Por ejemplo:

var regx=/user/d/g;

var rs=regx.exec(“ddduser1dsfuser2dd”);

var rs1=regx.exec(“ddduser1dsfuser2dd”);

则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。

2>test(str), determines whether the string str matches the expression, and returns a boolean value. Por ejemplo:

var regx=/user/d+/g;

var flag=regx.test(“user12dd”);

flag的值为true。

3）String对象方法

1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配

ejemplo:

var regx=/user/d/g;