JavaScript Tipo System_Detailed Explicación del tipo Regexp

Las palabras anteriores

La sintaxis básica de las expresiones regulares en JavaScript se ha introducido anteriormente. La clase Regexp de JavaScript representa expresiones regulares. Tanto la cadena como la regexp definen métodos. El uso de expresiones regulares puede realizar una potente coincidencia de patrones, recuperación de texto y reemplazo. Este artículo introducirá objetos regexp de expresiones regulares y expresiones regulares involucradas

Atributos y métodos

Objeto

Las expresiones regulares en JavaScript están representadas por objetos regexp, y hay dos formas de escribirlas: una es el método literal; el otro es el método del constructor

Método de escritura de Perl

Escritura literal de expresión regular, también conocida como escritura de Perl, porque las características de expresión regulares de JavaScript se toman prestadas de Perl

Los literales de expresión regulares se definen como caracteres contenidos entre un par de barras (/) y se pueden establecer 3 banderas

VAR Expression = /Pattern /Flags;

El patrón coincidente de expresiones regulares admite las siguientes 3 banderas:

G: significa patrón global, es decir, el patrón se aplicará a todas las cadenas, en lugar de detenerse inmediatamente cuando se encuentra la primera coincidencia

I: indica el modo de insensible a caso, es decir, el caso del patrón y la cadena se ignora al determinar la coincidencia.

M: Representa el patrón multilínea, es decir, cuando se alcanza el final de una línea de texto, continuará buscando si hay un elemento que coincida con el patrón en la siguiente línea.

 // el método de combinación de todas las instancias de 'At' de la cadena var p =/at/g; // test () devuelve un valor booleano para indicar si la coincidencia se puede encontrar console.log (p.test ('ata')); // trueConsole.log (p.test ('aba')); // falso

Constructor regexp

Al igual que los objetos integrados ordinarios, los objetos de expresión regulares Regexp también admiten la forma del constructor nuevo+regexp ().

El constructor RegExp recibe dos parámetros: el patrón de cadena para que coincida y la cadena de bandera opcional (indicadores). Las tres banderas de la cuerda de la bandera y el literal tienen el mismo significado: 'g', 'i', 'm'

Ambos parámetros del constructor regexp son cadenas. Y cualquier expresión definida usando forma literal puede usar constructores

 // Haga coincidir todas las instancias de 'At' de la cadena var p1 =/at/g; // igual que arriba var p2 = new Regexp ('at', 'g');

[Nota] La especificación ECMAScript3 estipula que una cantidad directa de expresión regular se convertirá en un objeto regexp cuando se ejecute a él. Cada operación de la cantidad directa de expresión regular representada por el mismo código devuelve el mismo objeto. La especificación ECMAScript5 hace las disposiciones opuestas, y la expresión regular representada por el mismo código se cuenta directamente cada vez.

Todas las operaciones devuelven nuevos objetos. IE6-8 siempre se ha implementado de acuerdo con la especificación ECMAScript5, por lo que no hay problema de compatibilidad

Dado que los literales de las expresiones regulares no admiten variables, si las variables aparecen en expresiones regulares, solo puede usar el constructor REGEXP para empalmar las variables en los parámetros del constructor REGEXP como empalme de cadena.

【Consejos】 Obtener elemento a través del nombre de clase

 function getByClass (obj, classname) {var elements = obj.getElementsByTagName ('*'); resultado var = []; Var Pattern = new Regexp ('(^| // s)' + classname + '(// s | $)'); for (var i = 0; i <elements.length; i ++) {if (patrón.test (elements [i] .classname)) {result.push (elements [i]); }} Resultado de retorno;}

Propiedades de instancia

Cada objeto de instancia de regexp contiene las siguientes 5 propiedades

 Global: el valor booleano indica si la bandera G Ignorecase: Boolean Value indica si el indicador I LastIdex: Integer indica la posición del carácter del inicio en busca de la siguiente coincidencia. Cuenta desde 0 multiline: el valor booleano indica si el indicador msource: representación de cadena de la expresión regular, que regresa en la forma literal en lugar del patrón de cadena pasada en el constructor

 Var Pattern = new Regexp ('// [bc //] at', 'i'); console.log (patrón.global); // falseconsole.log (patrón.ignorecase; // true console.log (Pattern.multiline); // Falseconsole.log (Pattern.lastIndex); // 0console.log (patrón.source); // '/[bc/] at'

Si usa la función EXEC () o Test () de REGEXP y establece el patrón global 'G', la coincidencia de la expresión regular comenzará desde la posición de LastIdex, y el LastIdex se restablecerá después de que cada subproceso sea exitoso. De esta manera, puede iterar repetidamente en la cadena y encontrar cada resultado coincidente en la secuencia. Sin embargo, si necesita llamar al mismo método regexp exec () o test () para diferentes cadenas, esta variable también puede traer resultados coincidentes inesperados. Por lo tanto, al reemplazar la cadena, debe establecer explícitamente el LastIdex de Regexp en 0

 // El método Exec () Devuelve la coincidencia en una matriz var p = // w/g; var s = 'AB'; console.log (p.lastindex); // 0console.log (p.exec (s)); // ['a'] console.log (p.lastindex); // 1console.log ( p.exec (s)); // ['b'] console.log (p.lastindex); // 2console.log (p.exec (s)); // nullconsole.log (p.lastindex); // 0

 var p = // w/g; var s1 = 'ab'; var s2 = 'ba'; console.log (p.lastindex); // 0console.log (p.exec (s1)); // ['a'] console.log (p.lastindex); // 1console.log (p.exec (s2)); // ['a'] console.log (p.lastindex); // 2

Propiedades constructoras

Las propiedades del constructor de regexp se consideran propiedades estáticas que varían según la operación de expresión regular más reciente realizada.

Hay dos formas de acceder a ellos, a saber, nombres de atributos largos y nombres de atributos cortos. La mayoría de los nombres de atributos cortos no son identificadores de ECMAScript válidos, por lo que se debe acceder a ellos a través de la sintaxis del soporte cuadrado.

 Nombre del atributo largo de atributo corto Entrada de nombre de atributo $ _ La última cadena para que coincida con LastMatch $ y el último partido LastParen $+ el último partido de la última coincidora Capturación del grupo LeftContext $ `Ingrese el texto antes de LastMatch Multiline $* Valor booleano que indica si todas las expresiones usan el patrón multilín

Usando estas propiedades, se puede extraer información más específica de las operaciones realizadas por el método exec () o test ()

 // test () se usa para probar si una cadena coincide con una expresión regular y devuelve un valor booleano var text = 'this ha sido un verano corto'; var patrón =/(.) Hort/g; if (patrón.test (text)) {console.log (regexp.input); // 'ha sido un corto' console.log (REGEXP.leftContextContext); // '' ' console.log (regexp.rightcontext); // 'summer' console.log (regexp.lastmatch); // 'short' console.log (regexp.lastparen); // 's' console.log (recegexp.multiline); // false console.log (regexp ['$ _']); /// ' console.log (regexp ['$ `']); // 'Esto ha sido un' console.log (regexp ['$'"]); // 's verano' console.log (regexp ['$ &']); // 'short' console.log (regexp ['$+' ']; //' s 'console.log (regexp ['; }

JavaScript tiene 9 propiedades del constructor para almacenar grupos de captura. Estas propiedades se poblan automáticamente al llamar a los métodos ejecut () o test ().

[Nota] Teóricamente, el Regexp. $ 0 que debe ahorrarse a toda la expresión que no existe el texto coincidente, el valor no está definido

 //Regexp.$1/regexp.$2/regexp.$3…to Regexp. $ 9 se utilizan para almacenar el primer, segundo, noveno grupo de captura coincidente, var Text = 'este ha sido un verano corto'; var patrón =/(..) o (.)/G; if (patrón.test (texto)) {console.log (regexp. $ 1); // sh. console.log (regexp. $ 2); // t}

Método de ejemplo

Hay 5 métodos de instancia de objetos REGEXP, divididos en dos categorías. Incluyendo tres métodos generales de objeto: toString (), tolocalString (), valueOf () y métodos de coincidencia regulares de test () y exec ()

Método común de objetos

El objeto Regexp hereda tres métodos: toString (), tolocaleString () y valueOf () del objeto objeto.

【ToString ()】

El método toString () devuelve el literal de la expresión regular

【TolocalEstring ()】

El método tolocaleString () devuelve el literal de la expresión regular

【Valor de ()】

El método valueOf () devuelve el objeto de expresión regular en sí mismo

[Nota] No importa lo que se cree la expresión regular, estos tres métodos solo devuelven su forma literal

 Var Pattern = new Regexp ('[BC] at', 'Gi'); console.log (patrón.toString ()); // '/[bc] at/gi'console.log (patrón.tolocaleString ()); // '/[bc] at/gi'console.log (patrón.valueOf ()); ///[bc] at/givar patrón =/[bc] at/gi; console.log (patrón.toString ()); // '/[bc] at/gi'console.log (patrón.tolocaleString ()); // '[bc] at/gi'console.log (patrón.valueOf ()); ///[BC] AT/GI

Método de coincidencia regular

Solo hay dos métodos de coincidencia regulares para objetos REGEXP: Exec () y Test () respectivamente.

【Exec ()】

El método Exec () está diseñado específicamente para capturar grupos y acepta un parámetro, a saber, la cadena a la que se aplicará el patrón. Luego devuelva una matriz que contenga información de coincidencia y devuelva nulo si no hay coincidencia.

En la matriz de coincidencias, el primer elemento es una cadena que coincide con todo el patrón, y los otros elementos son una cadena que coincide con el grupo de captura en el patrón. Si no hay un grupo de captura en el patrón, la matriz solo contiene uno

La matriz devuelta contiene dos propiedades adicionales: índice y entrada. El índice significa que la coincidencia está en la posición de la cadena, la entrada significa la cadena donde se aplica la expresión regular

 var text = 'mamá y papá y bebés y otros'; var patrón =/mamá (y papá (y bebé)?)?/gi; var coincidentes = patrón.exec (text); console.log (patrones, coincidencias); // patrones.lastindex: 20 // fósforos [0]: 'mamá y papá y bebé' // coincides [1]: 'y papá y bebé' // mates [2]: 'y' y 'y' y 'y' y 'y' y 'y' y 'y' y ' Baby '// Matches.Index: 0 // Matches.Input:' Mamá, papá y bebé y otros '

Para el método EXEC (), incluso si el indicador global (g) se establece en el patrón, solo devolverá una coincidencia a la vez. Sin configurar el indicador global, llamar a Exec () varias veces en la misma cadena siempre devolverá la información de la primera coincidencia; Mientras que al configurar el indicador global, cada llamada a exec () continuará buscando una nueva coincidencia en la cadena.

 var text = 'cat,bat,sat,fat';var pattern1 = /.at/;var matches = pattern1.exec(text);console.log(pattern1,matches);//pattern1.lastIndex:0//matches[0]:'cat'//matches.index:0//matches.input:'cat,bat,sat,fat'var text = 'cat,bat,sat,fat';matches = patrón1.exec (texto); console.log (patrón1, coincidencias); //pattern1.lastindex:0//matches§0fontenco:'cat'//matches.index:0//matches.input:'cat.bat,sat.fat '

 var text = 'cat, bat, sat, fat'; var patrón2 = /.at/g;var coincidentes = patrón2.exec (text); console.log (patrones2, coincidencias); //pattern2.lastindex:3//matches§0fontrese:'cat'//matches.index:0//matches.input:'cat,bat,sat,fat'var text = 'gat, bat, sat, fat'; coincidentes = patrones 2.exec (text); console.log (patrones2, coincidencias); //pattern2.lastindex:7//matches§0font>:'bat'//matches.index:4//matches.input:'cat.bat,sat.fat '

【Consejos】 Use el método Exec () para encontrar todas las posiciones coincidentes y todos los valores

 var string = 'j1h342jg24g234j 3g24j1'; var patrón = // d/g; var valueArray = []; // value var indexArray = []; // posicion var temp; while indexarray.push (temp.index); } // ["1", "3", "4", "2", "2", "4", "2", "3", "4", "3", "2", "4", "1"] [1, 3, 4, 5, 8, 9, 11, 12, 13, 16, 18, 19, 21] Console.Log (Valuearray, Indexarray);

【prueba()】

El método test () se usa para probar si la expresión regular puede encontrar texto coincidente en una cadena, recibir un parámetro de cadena y devolver verdadero al coincidir, de lo contrario devuelve falso

 Var text = '000-00-00-000'; var patrón = // d {3}-/d {2}-/d {4}/; if (patrón.test (text)) {console.log ('el patrón se combinó');}

Del mismo modo, cuando se llama el método test (), se cambiará la propiedad LastIdex del objeto REGEXP. Si se especifica un patrón global, cada vez que se ejecute el método test (), el valor de compensación de LastIndex en la cadena se intentará coincidir. Por lo tanto, diferentes cadenas se verifican varias veces con la misma regexp. El valor de LastIdex debe establecerse en 0 después de cada llamada.

 Var Pattern = /^/d ]-/d{2h}-/d{2}$/g;console.log(pattern.test('2016-06-23'));//trueconsole.log(pattern.test('2016-06-23'));//false//the correcto forma correcta de hacer esto es restablecer el último inyx a 0var /^/d{4h}-/d{2}-/d{2}$/g;console.log(pattern.test('2016-06-23')) ;//truepattern.lastindex = 0; console.log (patrón.test ('2016-06-23')); // truepattern.lastindex = 0; console.log (patrón.test ('2016-06-23')); // truePattern.lastIndex = 0; console.log (patrón.test ('2016-06-23')); // true

Como se mencionó anteriormente, JavaScript tiene 9 propiedades del constructor para almacenar grupos de captura. Estas propiedades se llenarán automáticamente al llamar al método Exec () o Test ().

[Nota] Teóricamente, el Regexp. $ 0 que debe ahorrarse a toda la expresión que no existe el texto coincidente, el valor no está definido

 if (/^(/d {4})-(/d {2})-(/d {2}) $/. test ('2016-06-23-23')) {console.log (regexp. $ 1); // '2016' console.log (regexp. $ 2); // '06' console.log (regexp. $ 3); console.log (regexp. $ 0); // indefinido}

Lo anterior es el tipo JavaScript System_regex Regexp Tipo Explicación detallada de los detalles. Espero que todos apoyen a Wulin.com ~