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> <p> aa </p> </td> <td> <p> bb </p> </td>", el resultado coincidente es: Success; La coincidencia es "<td> <p> aa </p> </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> <p> aa </p> </td>". Cuando coincida con el próximo nuevamente, obtendrá el segundo "<TD> <p> bb </p> </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;
var str=“user13userddduser345”;
var rs=str.match(regx);
rs的值为:{user1,user3}
2>search(expr),返回字符串中与expr相匹配的第一个匹配的index值。
ejemplo:
var regx=/user/d/g;
var str=“user13userddduser345”;
var rs=str.search(regx);
rs的值为:0
3>replace(expr,str),将字符串中匹配expr的部分替换为str。另外在replace方法中,str中可以含有一种变量符号$,格式为$n,代表匹配中被记住的第n的匹配字符串(注意小括号可以记忆匹配)。
ejemplo:
var regx=/user/d/g;
var str=“user13userddduser345”;
var rs=str.replace(regx,”00”);
rs的值为:003userddd0045
Ejemplo 2:
var regx=/u(se)r/d/g;
var str=“user13userddduser345”;
var rs=str.replace(regx,”$1”);
rs的值为:se3userdddse45
对于replace(expr,str)方法还要特别注意一点,如果expr是一个表达式对象则会进行全局替换(此时表达式必须附加参数g,否则也只是替换第一个匹配),如果expr是一个字符串对象,则只会替换第一个匹配的部分,例如:
var regx=“user”
var str=“user13userddduser345”;
var rs=str.replace(regx,”00”);
rs的值为: 0013userddduser345
4>split(expr),将字符串以匹配expr的部分做分割,返回一个数组,而且表达式是否附加参数g都没有关系,结果是一样的。
ejemplo:
var regx=/user/d/g;
var str=“user13userddduser345”;
var rs=str.split(regx);
rs的值为:{3userddd,45}
4,表达式相关属性
1)表达式相关属性,是指和表达式相关的属性,如下面的形式:
var regx=/myexpr/;
var rs=regx.exec(str);
其中,和表达式自身regx相关的属性有两个,和表达式匹配结果rs相关的属性有三个,下面将逐一介绍。
2)和表达式自身相关的两个属性:
1>lastIndex,返回开始下一个匹配的位置,注意必须是全局匹配(表达式中带有g参数)时,lastIndex才会有不断返回下一个匹配值,否则该值为总是返回第一个下一个匹配位置,例如:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex1=regx.lastIndex;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex2=regx.lastIndex;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex3=regx.lastIndex;
上面lastIndex1为9,第二个lastIndex2也为9,第三个也是9;如果regx=/user/d/g,则第一个为9,第二个为18,第三个为0。
2>source, return the expression string itself. Por ejemplo:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var source=regx.source;
source的值为user/d
3)和匹配结果相关的三个属性:
1>index, return the current matching position. Por ejemplo:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var index1=rs.index;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var index2=rs.index;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var index3=rs.index;
index1为4,index2为4,index3为4,如果表达式加入参数g,则index1为4,index2为13,index3会报错(index为空或不是对象)。
2>input, used for matching strings. Por ejemplo:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var input=rs.input;
input的值为sdsfuser1dfsfuser2。
3>[0],返回匹配结果中的第一个匹配值,对于match而言可能返回一个多值的数字,则除了[0]外,还可以取[1]、[2]等等。例如:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var value1=rs[0];
rs=regx.exec(“sdsfuser1dfsfuser2”);
var value2=rs[0];
value1的值为user1,value2的值为user2
5,实际应用
1)实际应用一
描述:有一表单,其中有一个“用户名”input域
要求:汉字,而且不能少于2个汉字,不能多于4个汉字。
lograr:
<script>function checkForm(obj){ var username=obj.username.value; var regx=/^[/u4e00-/u9fa5]{2,4}$/g if(!regx.test(username)){ alert(“Invalid username!”); return false; } return true;}</script><form name=“myForm”onSubmit=“return checkForm(this)”> <input type=“text” name=“username”/> <input type=“submit” vlaue=“submit”/></form>2)实际应用二
描述:给定一个含有html标记的字符串,要求将其中的html标记去掉。
lograr:
<script>function toPlainText(htmlStr){ var regx=/<[^>]*>|<//[^>]*>/gm; var str=htmlStr.replace(regx,""); return str;}</script><form name=“myForm”> <textarea id=“htmlInput”></textarea> <input type=“button” value=“submit” onclick=“toPlainText(document.getElementById('htmlInput').value”/></form>三,小结
1,Javascript正则表达式,我想在一般的程序员之中,使用者应该不是很多,因为我们处理的页面一般都不是很复杂,而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转,富客户端已经被越来越多的人接受,而Javascript就是其中的关键技术,对于复杂的客户端逻辑而言,正则表达式的作用也是很关键的,同时它也是Javascript高手必须要掌握的重要技术之一。
2,为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识,我将前面的一些关键点和容易犯糊涂的地方再系统总结一下,这部分很关键!
总结1:附件参数g的用法
表达式加上参数g之后,表明可以进行全局匹配,注意这里“可以”的含义。我们详细叙述:
1) For the exec method of the expression object, if g is not added, it will only return the first match, no matter how many times it is executed, if g is added, the first execution will also return the first match, and then the execution will return the second match, and so on. Por ejemplo
var regx=/user/d/;
var str=“user18dsdfuser2dsfsd”;
var rs=regx.exec(str);//此时rs的值为{user1}
var rs2=regx.exec(str);//此时rs的值依然为{user1}
如果regx=/user/d/g;则rs的值为{user1},rs2的值为{user2}
通过这个例子说明:对于exec方法,表达式加入了g,并不是说执行exec方法就可以返回所有的匹配,而是说加入了g之后,我可以通过某种方式得到所有的匹配,这里的“方式”对于exec而言,就是依次执行这个方法即可。
2)对于表达式对象的test方法,加入g于不加上g没有什么区别。
3) For the match method of the String object, g is not added, and it only returns the first match. If the match method is executed all the time, it always returns the first match. If g is added, then all matches will be returned at once (note that this is different from the exec method of the expression object. For exec, even if g is added, all matches will not be returned at once). Por ejemplo:
var regx=/user/d/;
var str=“user1sdfsffuser2dfsdf”;
var rs=str.match(regx);//此时rs的值为{user1}
var rs2=str.match(regx);//此时rs的值依然为{user1}
如果regx=/user/d/g,则rs的值为{user1,user2},rs2的值也为{user1,user2}
4)对于String对象的replace方法,表达式不加入g,则只替换第一个匹配,如果加入g,则替换所有匹配。(开头的三道测试题能很好的说明这一点)
5)对于String对象的split方法,加上g与不加g是一样的,即:
var sep=/user/d/;
var array=“user1dfsfuser2dfsf”.split(sep);
则array的值为{dfsf, dfsf}
此时sep=/user/d/g,返回值是一样的。
6)对于String对象的search方法,加不加g也是一样的。
总结2:附加参数m的用法
附加参数m,表明可以进行多行匹配,但是这个只有当使用^和$模式时才会起作用,在其他的模式中,加不加入m都可以进行多行匹配(其实说多行的字符串也是一个普通字符串),我们举例说明这一点
1)使用^的例子
var regx=/^b./g;var str=“bd76 dfsdf sdfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);
此时加入g和不加入g,都只返回第一个匹配{bd},如果regx=/^b./gm,则返回所有的匹配{bd,b7},注意如果regx=/^b./m,则也只返回第一个匹配。所以,加入m表明可以进行多行匹配,加入g表明可以进行全局匹配,综合到一起就是可以进行多行全局匹配
2)使用其他模式的例子,例如
var regx=/user/d/;var str=“sdfsfsdfsdf sdfsuser3 dffs b76dsf user6”;var rs=str.match(regx);
此时不加参数g,则返回{user3},加入参数g返回{user3,user6},加不加入m对此没有影响。
3)因此对于m我们要清楚它的使用,记住它只对^和$模式起作用,在这两种模式中,m的作用为:如果不加入m,则只能在第一行进行匹配,如果加入m则可以在所有的行进行匹配。我们再看一个^的例子
var regx=/^b./;var str=“ret76 dfsdf bjfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);
此时rs的值为null,如果加入g,rs的值仍然为null,如果加入m,则rs的值为{bj}(也就是说,在第一行没有找到匹配,因为有参数m,所以可以继续去下面的行去找是否有匹配),如果m和g都加上,则返回{bj,b7}(只加m不加g说明,可以去多行进行匹配,但是找到一个匹配后就返回,加入g表明将多行中所有的匹配返回,当然对于match方法是如此,对于exec呢,则需要执行多次才能依次返回)
总结3:
在HTML的textarea输入域中,按一个Enter键,对应的控制字符为“/r/n”,即“回车换行”,而不是“/n/r”,即“换行回车”,我们看一个前面我们举过的例子:
var regx=/a/r/nbc/;var str=“a bc”;var rs=regx.exec(str);
结果:匹配成功,rs的值为:{ },如果表达式为/a/n/rbc/,则不会被匹配,因此在一般的编辑器中一个”Enter”键代表着“回车换行”,而非“换行回车”,至少在textarea域中是这样的。
The above article briefly discusses the use of RegExp objects and brackets for JS regular expressions is all the content I share with you. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.