As palavras anteriores
A sintaxe básica das expressões regulares em JavaScript foi introduzida anteriormente. A classe Regexp de JavaScript representa expressões regulares. Os métodos de definição de string e regexp. O uso de expressões regulares pode executar uma poderosa correspondência de padrões, recuperação de texto e substituição. Este artigo apresentará objetos regexp de expressões regulares e expressões regulares envolvidas
Atributos e métodos
Objeto
Expressões regulares em JavaScript são representadas pelos objetos regexp, e há duas maneiras de escrevê -los: um é o método literal; o outro é o método do construtor
Método de escrita perl
Expressão regular A escrita literal, também conhecida como escrita perl, porque as características regulares da expressão de JavaScript são emprestadas da Perl
Literais de expressão regular são definidos como caracteres contidos entre um par de barras (/) e 3 sinalizadores podem ser definidos
var expressão = /padrão /sinalizadores;
O padrão de correspondência de expressões regulares suporta os três sinalizadores a seguir:
G: significa padrão global, ou seja, o padrão será aplicado a todas as cordas, em vez de parar imediatamente quando a primeira partida for encontrada
I: indica o modo insensível ao caso, ou seja, o caso do padrão e da string é ignorado ao determinar a correspondência.
M: Representa o padrão de multilina, ou seja, quando o final de uma linha de texto é atingido, continuará procurando se há um item que corresponda ao padrão na próxima linha.
// corresponde a todas as instâncias de 'em' da string var p =/at/g; // test () o método retorna um valor booleano para indicar se a correspondência pode ser encontrada console.log (p.test ('Ata')); // truconsole.log (p.test ('Aba'); // falseConstrutor regexp
Como objetos incorporados comuns, os objetos de expressão regular regexp também suportam a forma do construtor de novos+regexp ().
O construtor regexp recebe dois parâmetros: o padrão da string a ser correspondente e a string opcional da string (sinalizadores). As três bandeiras da string da bandeira e o literal têm o mesmo significado: 'g', 'i', 'm'
Ambos os parâmetros do construtor regexp são strings. E qualquer expressão definida usando forma literal pode usar construtores
// corresponde a todas as instâncias de 'em' da string var p1 =/at/g; // o mesmo que acima var p2 = new regexp ('at', 'g');[Nota] A especificação do ECMAScript3 estipula que uma quantidade direta de expressão regular será convertida em um objeto regexp quando executado nele. Cada operação da quantidade regular de expressão direta representada pelo mesmo código retorna o mesmo objeto. A especificação ECMAScript5 faz as disposições opostas, e a expressão regular representada pelo mesmo código é contada diretamente a cada vez.
Todas as operações retornam novos objetos. O IE6-8 sempre foi implementado de acordo com a especificação Ecmascript5, portanto não há problema de compatibilidade
Como os literais de expressões regulares não suportam variáveis, se as variáveis aparecerem em expressões regulares, você só poderá usar o construtor regexp para unir as variáveis nos parâmetros do construtor regexp como splicing de string.
【Dicas】 Obtenha elemento através do nome da classe
function getByClass (obj, className) {var elements = obj.getElementsByTagName ('*'); var resultado = []; var padrão = novo regexp ('(^| // s)' + className + '(// s | $)'); for (var i = 0; i <elements.Length; i ++) {if (padring.test (elementos [i] .className)) {result.push (elementos [i]); }} Retornar resultado;}Propriedades da instância
Cada objeto de instância regexp contém as 5 propriedades a seguir
Global: o valor booleano indica se o Ginga G Ignorecase: Valor Booleano indica se o sinalizador I LastIndex: Inteiro indica a posição do caractere da partida em busca da próxima correspondência. Ele conta de 0 multilina: o valor booleano indica se a bandeira msource: representação da string da expressão regular, que retorna na forma literal, em vez do padrão de string passado no construtor
var padrão = new regexp ('// [bc //] em', 'i'); console.log (padron.global); // Falseconsole.log (padrão.ignorecase); // true console.log (Pattern.Multiline); // FalSeconsole.log (Pattern.lastindex); // 0console.log (Pattern.source); // '/[bc/] at'Se você usar a função EXEC () ou teste () do regexp e definir o padrão global 'g', a correspondência da expressão regular começará a partir da posição do LastIndex, e o LastIndex será redefinido após o sucesso de cada partida. Dessa forma, você pode iterar repetidamente na string e encontrar cada resultado correspondente em sequência. No entanto, se você precisar chamar o mesmo método regexp exec () ou test () para seqüências diferentes, essa variável também pode trazer resultados correspondentes inesperados. Portanto, ao substituir a string, você deve definir explicitamente o LastIndex de Regexp para 0
// método EXEC () retorna a correspondência em uma 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']
Propriedades do construtor
As propriedades do construtor regexp são consideradas propriedades estáticas que variam com base na operação de expressão regular mais recente realizada.
Existem duas maneiras de acessá -los, ou seja, nomes de atributos longos e nomes de atributos curtos. A maioria dos nomes de atributos curtos não são identificadores de eCMAScript válidos, portanto, eles devem ser acessados através da sintaxe do suporte quadrado.
Nome do atributo longo Nome do atributo curto Nome de entrada $ _ A última sequência para corresponder ao último $ $ e à última partida LastParen $+ a última partida Last Match Capturando Grupo LeftContext $ `Texto de entrada Antes de LastMatch Multiline $* Valor Boolean, indicando se todas as expressões usam padrão multiline RightContext $ 'O texto após a últimamarca na sequência de entrada
Usando essas propriedades, informações mais específicas podem ser extraídas das operações executadas pelo método EXEC () ou Test ()
// teste () é usado para testar se uma string corresponde a uma expressão regular e retorna um valor booleano var text = 'Este tem sido um verão curto'; var padring =/(.) Hort/g; if (padring.test (text)) {console.log (regexp.input); // 'tem sido um curto verão'; console.log (regexp.rightContext); // 'verão' console.log (regexp.lastmatch); // 'curto' console.log (regexp.lastparen); // 's' console.log (regexp.multiline); // False Console.log (regexp [regexp [regexp.multiline); console.log (regexp ['$ `']); // 'Este tem sido um' console.log (regexp ['$'"]); // 's verão' console.log (regexp ['$ &']); // 'short console.log (regexp [' $+'); }O JavaScript possui 9 propriedades do construtor para armazenar grupos de captura. Essas propriedades são preenchidas automaticamente ao ligar para os métodos Exec () ou Test ().
[Nota] Teoricamente, o regexp. $ 0 que deve ser salvo para toda a expressão que corresponda ao texto, o valor é indefinido
//Regexp.$1/Regexp.$2/Regexp.$3… para regexp. $ 9 são usados para armazenar o primeiro, segundo e nono grupo de captura correspondente var texto = 'Este foi um verão curto'; var padring =/(..) ou (.)/G; if (padrão.test (text)); console.log (regexp. $ 2); // t}
Método de exemplo
Existem 5 métodos de instância de objetos regexp, divididos em duas categorias. Incluindo três métodos gerais de objeto: tostring (), tolocalstring (), valueof () e métodos de correspondência regulares de teste () e exec ()
Método comum do objeto
O objeto regexp herda três métodos: ToString (), Tolocalestring () e ValueOf () do objeto Objeto.
【ToString ()】
O método tostring () retorna o literal da expressão regular
【Tolocalestring ()】
O método tolocalestring () retorna o literal da expressão regular
【Valueof ()】
O método valueof () retorna o próprio objeto de expressão regular
[Nota] Não importa o que a expressão regular seja criada, esses três métodos retornam apenas sua forma literal
var padrão = new regexp ('[bc] em', 'gi'); console.log (padrony.toString ()); // '/[bc] em/gi'console.log (padron.tolocalestring ()); // '/[bc] em/gi'console.log (padron.valueof ()); ///[bc] em/gintar padrão =/[bc] em/gi; console.log (padron.toString ()); // '/[bc] em/gi'console.log (padron.tolocalestring ()); // '[bc] em/gi'console.log (padron.valueof ()); ///[bc] em/giMétodo de correspondência regular
Existem apenas dois métodos de correspondência regulares para objetos regexp: EXEC () e Test (), respectivamente.
【Exec ()】
O método EXEC () foi projetado especificamente para capturar grupos e aceita um parâmetro, a saber, a sequência à qual o padrão deve ser aplicado. Em seguida, retorne uma matriz contendo informações de correspondência e retorne nulo se não houver correspondência.
Na matriz, o primeiro item é uma string que corresponde a todo o padrão e os outros itens são uma string que corresponde ao grupo de captura no padrão. Se não houver grupo de captura no padrão, a matriz contém apenas um
A matriz retornada contém duas propriedades adicionais: índice e entrada. Índice significa que a correspondência está na posição da string, entrada significa a string onde a expressão regular é aplicada
var text = 'mamãe e papai e bebê e outros'; var padrão =/mamãe (e papai (e bebê)?)?/gi; var matches = padring.exec (text); console.log (padrão, fósforos); // padrony.lastindex: 20 // corresponde a [0]: 'mãe e papai e bebê' // fósforos [1]: 'e e madrões. baby '// Matches.index: 0 // Matches.input:' Mamãe e papai e bebê e outros '
Para o método EXEC (), mesmo que o sinalizador global (g) esteja definido no padrão, ele retornará apenas uma correspondência por vez. Sem definir o sinalizador global, ligar para Exec () várias vezes na mesma string sempre retornará as informações da primeira partida; Ao definir o sinalizador global, cada chamada para EXEC () continuará procurando uma nova correspondência na string.
var text = 'gato, morcego, sat, gordura'; var padration1 = /.at/;Var Matches = Pattern1.exec (text); console.log (Pattern1, Matches); // Pattern1.LastIndex: 0 // Matches [0]: 'Cat' // Matches.index: 0 // Matches.inv: CAT, CAT, SAT, SAT, SAT '// Matches.index: 0 // Matches.Input: Cat, Cat, Cat, Sat'v, Sat' // Matches.index: 0 // Matches.inv: Cat, Cat, Cat, Sat'v, Sat's // Matches.index: 0 // Matches.inv: Cat, Cat, Cat, Sat'v, Sat's // Matches. Pattern1.Exec (texto); 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'; var Pattern2 = /. //pattern2.lastindex:3//matches[0 ]:'cat'//matches.index:0//matches.input:'cat.bat.sat.fat'var text = 'Cat, bat, gordura'; fósforos = padrão2.exec (text); console.log (padronizes2, fósforos); //pattern2.lastindex:7//matches[0 ]:'bat'//matches.index:4//matches.input:'cat,bat.sat,at '
【Dicas】 Use o método EXEC () para encontrar todas as posições correspondentes e todos os valores
var string = 'J1H342JG24G234J 3G24J1'; var Pattern = // d/g; var valuearray = []; // valor var indexArray = []; // Posição var temp; while (temp = padrony.exec (string)! indexArray.push (temp.index); } // ["1", "3", "4", "2", "2", "4", "2", "3", "4", "3", "2", "4", "1", 1 "] [1, 3, 4, 5, 8, 9, 11, 12, 13, 16, 19, 19, 21] Console.Log (Valyrayrayray,, 11, 11, 12, 13, 18, 18, 19, 21, 21] Console.Log (Valyrayrayray,, RayArra,
【teste()】
O método test () é usado para testar se a expressão regular pode encontrar texto correspondente em uma string, receber um parâmetro de string e retornar true ao corresponder, caso contrário, retorna false
var text = '000-00-000'; var padrão = // d {3}-/d {2}-/d {4}/; if (padrony.test (text)) {console.log ('o padrão foi correspondido');}Da mesma forma, quando o método test () é chamado, a propriedade LastIndex do objeto regexp será alterada. Se um padrão global for especificado, sempre que o método test () for executado, o valor do LastIndex Offset na sequência será tentado corresponder. Portanto, seqüências diferentes são verificadas várias vezes com o mesmo regexp. O valor do LastIndex deve ser definido como 0 após cada chamada.
var Pattern = /^/d {4a }-/d {2age-/d {2a) /^/d {4a }-/d {2age-/d {2a }$/G ;console.log(pattern.test('2016-06-23'); 0; console.log (Pattern.test ('2016-06-23')); // trruepattern.lastindex = 0; console.log (padrão.test ('2016-06-23')); // trueComo mencionado anteriormente, o JavaScript possui 9 propriedades do construtor para armazenar grupos de captura. Essas propriedades serão preenchidas automaticamente ao ligar para o método EXEC () ou Test ().
[Nota] Teoricamente, o regexp. $ 0 que deve ser salvo para toda a expressão que corresponda ao texto, o valor é indefinido
if (/^(/d {4})-(/d {2})-(/d {2}) $/. test ('2016-06-23')) {console.log (regexp. $ 1); // '2016' console.log (regex. $ 2); // '06' Console.Og.Ong (console.Log.Log. console.log (regexp. $ 0); // indefinido}O acima é o tipo JavaScript System_Regex REGEXP Explicação detalhada dos detalhes. Espero que todos suportem wulin.com ~