Uma breve discussão sobre o uso de objetos e colchetes regexp para expressões regulares JS

Criação do objeto regexp:

A criação de expressões regulares regulares pode ser feita diretamente, ou seja, caracteres cercados por Slash "/". No entanto, em um ambiente em que as mudanças de parâmetros são necessárias, o construtor regexp () é uma escolha melhor:

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

var reg2 = novo regexp ('/' // w+/'', 'g');

Comparando os dois métodos de criação, o primeiro parâmetro no regexp é a sequência regular a ser criada. Por um lado, não é uma representação direta da quantidade, portanto, não está fechada com uma barra "/"; Em vez disso, a cotação marca "'" e o símbolo de escape "/" devem ser escapes quadráticos na corda.

Além disso, seja a quantidade direta ou o construtor regexp (), um novo objeto regexp é gerado e atribuído a uma variável.

Similaridades e diferenças entre Match () e EXEC ():

Match e Exec são maneiras comuns de combinar strings para expressões regulares. As funções implementadas pelos dois são semelhantes, com algumas diferenças sutis:

1. Como usar

Match é um método de embrulhar objetos com strings, uso: string.match (regexp);

Exec é um método de um objeto de expressão regular, uso: regexp.exec (string);

2. Resultados retornados

Quando o Regexp não define a bandeira global "G":

Os resultados de retorno de ambos são os mesmos. Ou seja, quando não há valor correspondente, ele retorna nulo e, quando há um valor correspondente, ele retorna uma matriz (vamos matriz). Array [0] é uma string correspondente, matriz [1], Array [2] ... corresponde a substâncias correspondentes aos parênteses em expressões regulares. Ao mesmo tempo, a matriz tem duas propriedades. Array.index representa a posição inicial da string correspondente e o Array.Input representa a sequência que está sendo recuperada.

Quando o Regexp tem o conjunto de "G" da bandeira global:

O Match retorna uma matriz quando houver um valor. Cada item da matriz representa todas as cordas que correspondem, portanto, não há mais substringas que correspondam aos parênteses. No momento, a matriz não possui atributo de índice e atributo de entrada.

O EXEC não é diferente do desempenho sem o rótulo global "G". A matriz de retorno, Array [0] é a string atual correspondente, matriz [1], Array [2] ... é a string de correspondência atual. Neste momento, preste atenção à propriedade LastIndex do objeto regexp, que representa a última posição no final da string correspondente na string original. Quando não há resultado mais correspondente, a propriedade LastIndex está definida como 0. Portanto, você pode usar o loop LastIndex para encontrar todas as seqüências de caracteres correspondentes.

Suportar vários métodos de correspondência:

Código JS

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

Além disso, você também pode usar o teststr.match (re), mas, dessa maneira, não há opção para G, e você só pode obter a primeira partida.

1. Regras de expressão regular

1.1 caracteres normais

Cartas, números, caracteres chineses, sublinhados e marcas de pontuação que não são especificamente definidos nos capítulos seguintes são todos "caracteres comuns". Quando um caractere normal em uma expressão corresponde a uma string, ela corresponde ao mesmo caractere que ele.

Exemplo 1: Quando a expressão "C", ao corresponder a string "ABCDE", o resultado correspondente é: sucesso; O conteúdo correspondente é: "C"; A posição correspondente é: Inicie em 2 e termine às 3. (Nota: o subscrito começa de 0 ou 1, o que pode variar dependendo da linguagem de programação atual)

Exemplo 2: Quando a expressão "BCD", ao corresponder à string "ABCDE", o resultado correspondente é: bem -sucedido; O conteúdo correspondente é: "BCD"; A posição correspondente é: Comece em 1 e termine em 4.

1.2 caracteres de fuga simples

Para alguns caracteres inconvenientes para escrever, use o método de adicionar "/" à frente. Já estamos familiarizados com esses personagens.

Existem outros pontos de pontuação que são especiais para uso nos capítulos seguintes. Depois de adicionar "/" à frente, eles representam o próprio símbolo. Por exemplo: ^ e $ têm significados especiais. Se você deseja corresponder aos caracteres "^" e "$" em uma string, a expressão precisa ser escrita como "/^" e "/$".

O método de correspondência desses caracteres escapados é semelhante a "caracteres normais". Também corresponde ao mesmo personagem.

Exemplo 1: Quando a expressão "/$ d", ao corresponder à string "ABC $ de", o resultado correspondente é: sucesso; O conteúdo correspondente é: "$ d"; A posição correspondente é: Comece em 3 e termine em 5.

1.3 Expressões que podem corresponder a 'vários caracteres'

Alguns métodos de representação em expressões regulares podem corresponder a qualquer um dos "vários caracteres". Por exemplo, a expressão "/d" pode corresponder a qualquer número. Embora possa corresponder a qualquer caractere nele, ele pode ser apenas um, não múltiplo. É como ao jogar cartas de pôquer, os reis grandes e pequenos podem substituir qualquer cartão, mas eles só podem substituir uma carta.

Exemplo 1: Quando a expressão "/d/d", ao corresponder "ABC123", o resultado da partida é: sucesso; O conteúdo correspondente é: "12"; A posição correspondente é: Comece em 3 e termine em 5.

Exemplo 2: Quando a expressão "A./D", ao corresponder "AAA100", o resultado da partida é: sucesso; O conteúdo correspondente é: "AA1"; A posição correspondente é: Comece em 1 e termine em 4.

1.4 Personalize expressões que podem corresponder a 'vários caracteres'

Use colchetes quadrados [] para conter uma série de caracteres que podem corresponder a qualquer um deles. Se você usa [^] para conter uma série de caracteres, pode corresponder a qualquer personagem que não seja os caracteres. Da mesma forma, embora possa corresponder a qualquer um deles, pode ser apenas um, não múltiplo.

Exemplo 1: Quando a expressão "[BCD] [BCD]" corresponde "ABC123", o resultado da correspondência é: sucesso; O conteúdo correspondente é: "BC"; A posição correspondente é: Comece em 1 e termine em 3.

Exemplo 2: Quando a expressão "[^abc]" corresponde "ABC123", o resultado da correspondência é: sucesso; O conteúdo correspondente é: "1"; A posição correspondente é: Comece em 3 e termine em 4.

1.5 Símbolos especiais que modificam o número de correspondências

As expressões mencionadas no capítulo anterior podem corresponder apenas a um caractere ou qualquer um dos vários caracteres. Se você usar uma expressão mais um símbolo especial que modifica o número de correspondências, poderá repetir a correspondência sem escrever repetidamente a expressão.

O método de uso é: "Número de modificação" é colocado após a "expressão modificada". Por exemplo: "[bcd] [bcd]" pode ser escrito como "[bcd] {2}".

Exemplo 1: Quando a expressão "/d+/.?/d*" é comparada com "custa US $ 12,5", o resultado da correspondência é: bem -sucedido; O conteúdo correspondente é: "12.5"; A posição correspondente é: Comece às 10 e termine aos 14.

Exemplo 2: Quando a expressão "Go {2,8} GLE" é comparada com "anúncios de gooooogle", o resultado da partida é: sucesso; O conteúdo correspondente é: "Gooooogle"; A posição correspondente é: Comece às 7 e termine aos 17 anos.

1.6 Alguns outros símbolos especiais que representam significado abstrato

Alguns símbolos representam o significado especial da abstração nas expressões:

Outras descrições de texto ainda são relativamente abstratas; portanto, dê exemplos para ajudar todos a entender.

Exemplo 1: Quando a expressão "^aaa" corresponde "xxx aaa xxx", o resultado correspondente é: falhou. Porque "^" requer correspondência onde a string começa, "^aaa" pode corresponder apenas quando "AAA" estiver no início da string, por exemplo: "AAA XXX XXX".

Exemplo 2: Quando a expressão "AAA $" é comparada com "XXX AAA XXX", o resultado correspondente é: falhou. Como "$" requer correspondência com o final da string, "aaa $" pode corresponder apenas quando "AAA" estiver no final da string, por exemplo: "xxx xxx aaa".

Exemplo 3: quando a expressão "./b". é comparado com "@@@ ABC", o resultado correspondente é: bem -sucedido; O conteúdo correspondente é: "@A"; A posição correspondente é: Comece em 2 e termine em 4.

Explicação adicional: "/b" é semelhante a "^" e "$", que não corresponde a nenhum caractere, mas exige que esteja no lados esquerdo e direito da posição no resultado correspondente, um lado é a faixa "/w" e o outro lado é a faixa não-"/w".

Exemplo 4: Quando a expressão "/bend/b" corresponde "fim de semana, final, final,", o resultado correspondente é: bem -sucedido; O conteúdo correspondente é: "End"; A posição correspondente é: Comece aos 15 anos e termine aos 18.

Alguns símbolos podem afetar a relação entre subexpressões dentro de uma expressão:

Exemplo 5: Quando a expressão "Tom | Jack" corresponde à corda "Eu sou Tom, ele é Jack", o resultado correspondente é: bem -sucedido; O conteúdo correspondente é: "Tom"; A posição correspondente é: Comece às 4 e termine às 7. Ao corresponder a próxima, o resultado correspondente é: bem -sucedido; O conteúdo correspondente é: "Jack"; Quando a posição correspondente: começa aos 15 anos e termina aos 19 anos.

Exemplo 6: Expressão "(Go/S*)+" Ao corresponder "Vamos ir!", O resultado correspondente é: bem -sucedido; O conteúdo correspondente é: "Go Go Go"; A posição correspondente é: Comece às 6 e termine aos 14.

Exemplo 7: Quando a expressão "￥ (/d+/.?/D*)" é comparada com "￥ 10,9, ￥ 20,5", o resultado da correspondência é: bem -sucedido; O conteúdo correspondente é: "￥ 20,5"; A posição correspondente é: Comece em 6 e termine em 10. O conteúdo que obtém a faixa de suporte corresponde separadamente é: "20,5".

2. Algumas regras avançadas em expressões regulares

2.1 ganância e não-greeda nos tempos de partida

Ao usar símbolos especiais que modificam o número de correspondências, existem vários métodos de representação que permitem a mesma expressão para corresponder a diferentes tempos, como: "{m, n}", "{m,}", "?", "?", "*", "+". O número específico de correspondências depende da sequência correspondente. Essa expressão com um número incerta de correspondências repetidas sempre corresponde a quantas vezes possível durante o processo de correspondência. Por exemplo, para o texto "dxxxdxxxd", o seguinte é:

Pode -se observar que, quando "/w+" corresponde, ele sempre corresponde ao maior número possível de caracteres que atendem às suas regras. Embora no segundo exemplo, ele não corresponda ao último "D", é também fazer com que toda a expressão corresponda com sucesso. Da mesma forma, expressões com "*" e "{m, n}" combinam o máximo possível e expressões com "?" também são "combinados" o máximo possível quando podem corresponder ou incompatíveis. Esse princípio correspondente é chamado de padrão "ganância".

Modo sem graça:

Adicionando um "?" O sinal depois de modificar o símbolo especial do número de correspondências pode fazer expressões com um número variável de correspondências correspondentes o máximo possível, para que expressões que possam corresponder ou incompatibilidade possam ser "correspondentes o máximo possível. Esse princípio correspondente é chamado de padrão "não-greedoso", também chamado de padrão "Barb". Se houver poucas correspondências, fará com que toda a expressão falhe. Semelhante ao modo ganancioso, o modo não-greedoso corresponderá à extensão mínima para fazer com que toda a expressão corresponda com sucesso. Por exemplo, para o texto "dxxxdxxxd":

Para mais casos, consulte o seguinte:

Exemplo 1: Quando a expressão "<td> (.*) </td>" corresponde à string "<td> <p> aa </p> </td> <td> <p> bb </p> </td>", o resultado correspondente é: sucesso; A correspondência é "<td> <p> aa </p> </td>" a sequência inteira, e o "</td>" na expressão corresponderá ao último "</td>" na sequência.

Exemplo 2: Por outro lado, quando a expressão "<td> (.*?) </td>" corresponde à mesma string no Exemplo 1, você só obterá "<td> <p> aa </p> </td>". Ao combinar o próximo novamente, você receberá o segundo "<td> <p> bb </p> </td>".

2.2 BackReferências /1, /2 ...

Quando uma expressão corresponde, o mecanismo de expressão registra a sequência correspondente pela expressão contida no suporte "()". Ao obter o resultado correspondente, a string correspondente pela expressão contida entre colchetes pode ser obtida separadamente. Isso foi demonstrado muitas vezes nos exemplos anteriores. Em aplicações práticas, quando um determinado limite é usado para pesquisar, e o conteúdo a ser recuperado não contém limites, os suportes devem ser usados para especificar o intervalo desejado. Por exemplo, o "<td> (.*?) </td>".

De fato, "a string correspondente pela expressão contida entre colchetes" pode não apenas ser usada após o término da partida, mas também durante o processo de correspondência. A peça após a expressão pode se referir à "string sub-match que foi correspondente" anterior entre parênteses. O método de referência é adicionar um número "/". "/1" refere -se à string correspondente no primeiro par de colchetes, "/2" refere -se à string correspondente no segundo par de colchetes ... e assim por diante, se um par de colchetes contiver outro par de colchetes, os colchetes forem classificados primeiro. Em outras palavras, se o par tiver o suporte esquerdo "(" antes, o par será classificado primeiro.

Como exemplo:

Exemplo 1: A expressão "('|") (.*?) (/1) "ao corresponder"' hello ', "World" ", o resultado da correspondência é: bem -sucedido; o conteúdo correspondente é:"' Hello '.

Exemplo 2: Quando a expressão "(/w)/1 {4,}" é comparada com "AA BBBB ABCDEFG CCCCC 111121111 9999999999999", o resultado da partida é: bem -sucedido; O conteúdo correspondente é "CCCCCC". Quando você combina o próximo novamente, você receberá 999999999. Essa expressão requer caracteres no intervalo "/w" para serem repetidos pelo menos 5 vezes, prestando atenção à diferença de "/w {5,}".

Exemplo 3: a expressão "<(/w+)/s*(/w+(= ('|").*?/4)?/S*)*>.*? bem-sucedido.

2.3 Pré-pesquisa, incompatibilidade; Pesquisa reversa, incompatibilidade

No capítulo anterior, falei sobre vários símbolos especiais representando significados abstratos: "^", "$", "/b". Todos eles têm uma coisa em comum: eles mesmos não correspondem a nenhum personagem, mas apenas anexam uma condição a "duas extremidades de uma corda" ou "fendas entre os personagens". Depois de entender esse conceito, esta seção continuará introduzindo outro método de representação mais flexível que adiciona condições a "duas extremidades" ou "fendas".

Avanço de pré-pesquisa: "(? = Xxxxx)", "(?! Xxxxx)"

Formato: "(? = Xxxxx)", na sequência correspondente, a condição conectada à "fenda" ou "duas extremidades" é que o lado direito da lacuna deve ser capaz de corresponder à expressão da parte xxxxx. Por ser apenas uma condição adicional nessa lacuna, não afeta a expressão subsequente para corresponder verdadeiramente aos caracteres após essa lacuna. Isso é semelhante a "/b", que não corresponde a nenhum personagem. "/b" apenas pega os personagens antes e depois da lacuna e faz um julgamento, e não afetará as expressões para trás para realmente corresponder.

Exemplo 1: Quando a expressão "Windows (? = Nt | xp)" é correspondida com "Windows 98, Windows NT, Windows 2000", ele só corresponderá ao "Windows" em "Windows NT" e outras palavras "Windows" não serão correspondentes.

Exemplo 2: Expressão "(/w) ((? =/1/1/1) (/1))+" Ao corresponder a string "aaa ffffff 9999999999", será capaz de corresponder aos 4 primeiros de 6 "f" e os primeiros 7 de 9 "9". Essa expressão pode ser lida e interpretada como: repetir o número alfanumérico mais de 4 vezes corresponderá à peça antes dos últimos 2 dígitos. Obviamente, essa expressão não pode ser escrita assim, e o objetivo aqui é para fins de demonstração.

Formato: "(?! Xxxxx)", o lado direito da lacuna não deve corresponder à expressão xxxxx.

Exemplo 3: Expressão "((?!/Bstop/b).)+" Ao corresponder "fdjka ljfdl stop fjdsla fdj", será correspondente do início à posição antes de "parar". Se não houver "parar" na string, a string inteira será correspondida.

Exemplo 4: A expressão "do (?!/W)" só pode corresponder "a" ao combinar a string ", faça, cachorro". Neste artigo, o efeito de usar "Do" depois "(?!/W)" e usar "/b" é o mesmo.

Pesquisa reversa: "(? <= Xxxxx)", "(? <! Xxxxx)"

Os conceitos desses dois formatos são semelhantes à pré-pesquisa avançada. Os requisitos para a pré-pesquisa reversa são: o "lado esquerdo" da lacuna. Os dois formatos exigem que possam ser capazes de corresponder e não devem ser capazes de corresponder à expressão especificada, em vez de julgar o lado direito. Como "Avançar a Pesquisa": ambos são uma condição adicional para a lacuna em que estão localizados e não correspondem a nenhum personagem.

Exemplo 5: A expressão "(? <=/D {4})/d+(? =/D {4})" ao corresponder "1234567890123456", os 8 números do meio, exceto os 4 primeiros números e os últimos 4 números serão correspondidos. Como o JScript.Regexp não suporta a pré-pesquisa reversa, este artigo não pode ser demonstrado. Muitos outros motores podem suportar a pré-pesquisa reversa, como: pacote java.util.Regex acima do jamespace java 1.4, o espaço de nome do System.Text.ReGularexpressions no .NET e o motor regular de Deelx mais simples e fácil recomendado por este site.

3. Outras regras comuns

Existem também algumas regras mais comuns entre vários motores de expressão regular, que não foram mencionados na explicação anterior.

3.1 nas expressões, "/xxx" e "/uxxxx" pode ser usado para representar um caractere ("x" significa um número hexadecimal)

3.2 Enquanto as expressões "/s", "/d", "/w", "/b" representam significados especiais, as letras maiúsculas correspondentes representam significados opostos

3.3 Existe um significado especial na expressão e é necessário adicionar "/" para corresponder ao resumo do personagem do próprio personagem.

3.4 Subexpressão entre colchetes "()". Se você deseja que o resultado correspondente não seja gravado para uso futuro, você pode usar o formato "(?: xxxxx)"

Exemplo 1: Quando a expressão "(?: (/W)/1)+" corresponde a "um bbccdd efg", o resultado é "bbccdd". O resultado correspondente do suporte "(? :)" Range não está gravado, então "(/w)" é usado para fazer referência a ele.

3.5 Introdução às configurações de atributo de expressão comumente usadas: Ignorecase, Singleline, Multiline, Global

4. Outras dicas

4.1 Se você deseja entender que os motores regulares avançados também suportam sintaxe regular complexa, consulte a documentação do mecanismo regular Deelx neste site.

4.2 Se você deseja exigir a expressão para corresponder a toda a string, em vez de encontrar uma peça da string, você pode usar "^" e "$" no início e no final da expressão, por exemplo: "^/d+$" exige que a sequência inteira tenha apenas números.

4.3 Se o conteúdo necessário para corresponder for uma palavra completa e não faz parte da palavra, use "/b" no início e no final da expressão, por exemplo: use "/b(iflighhile|Else|Void|Int...)/b" para corresponder às palavras -chave no programa.

4.4 A expressão não corresponde a uma corda vazia. Caso contrário, a partida será bem -sucedida o tempo todo e nada será correspondido. Por exemplo: quando você está se preparando para escrever uma expressão que corresponda a "123", "123.", "123.5", ".5", etc., números inteiros, pontos decimais e números decimais podem ser omitidos, mas não escreva a expressão como: "/d*/.?/d*", porque não há nada, isso também pode corresponder com sucesso. Uma maneira melhor de escrever é: "/d+/.?/d*|/./d+".

4.5 Não faça loop infinitamente para sub-matches que podem corresponder a strings vazios. Se cada parte da subexpressão entre os colchetes puder corresponder 0 vezes e os colchetes como um todo podem corresponder aos tempos infinitos, a situação poderá ser mais grave do que o artigo anterior dizia, e o processo de correspondência pode ser um loop morto. Embora alguns mecanismos regulares de expressão tenham evitado o loop morto nessa situação, como expressões regulares .NET, ainda devemos tentar evitar essa situação. Se encontrarmos um loop morto ao escrever expressões, também podemos começar deste ponto de vista e descobrir se esse é o motivo mencionado neste artigo.

4.6 Escolha razoavelmente o modo ganancioso e o modo não-greedoso, consulte a discussão do tópico.

4.7 ou "|" Nos lados esquerdo e direito, é melhor combinar apenas um lado de um determinado personagem, para que as expressões de ambos os lados de "|" não diferirá devido à posição de troca.

Próximo artigo ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1. Defina expressões regulares

1) Existem duas formas de definição de expressões regulares, uma é o método comum e o outro é o método do construtor.

2) Método normal: var reg =/expressão/parâmetros adicionais

Expressão: Uma sequência representando uma certa regra, onde certos caracteres especiais podem ser usados para representar regras especiais, que serão explicadas em detalhes posteriormente.

Parâmetros adicionais: usado para estender o significado da expressão, atualmente existem três parâmetros principais:

G: significa que a correspondência global pode ser realizada.

I: Isso significa correspondência insensível ao caso.

M: Significa que a correspondência de múltiplas linhas pode ser executada.

Os três parâmetros acima podem ser combinados arbitrariamente para representar o significado do composto e, é claro, não há parâmetros adicionados.

exemplo:

var reg =/a*b/;

var reg =/abc+f/g;

3) Método do construtor: var reg = new regexp ("expressão", "add parâmetros");

O significado de "expressão" e "parâmetros adicionais" é o mesmo que o método de definição acima.

exemplo:

var reg = novo regexp ("a*b");

var reg = novo regexp ("abc+f", "g");

4) A diferença entre métodos comuns e métodos construtores

Uma expressão da maneira normal deve ser uma sequência constante, enquanto a expressão no construtor pode ser uma string constante ou uma variável JS, como um parâmetro de expressão com base na entrada do usuário, etc.:

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

2. Padrão de expressão

1) Padrão de expressão refere -se ao método e estilo de expressão da expressão, ou seja, como descrever a "expressão" em var =/expressão/parâmetros adicionais?

2) De uma perspectiva padronizada, os padrões de expressão são divididos em padrões simples e padrões compostos.

3) Padrão simples: refere -se a um padrão expresso através da combinação de caracteres comuns, por exemplo

var reg =/abc0d/;

Pode -se ver que padrões simples podem representar apenas correspondências específicas.

4) Padrão de composto: refere -se a um padrão expresso com caracteres curinga, por exemplo:

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

O +,? e /w são todos caracteres curinga e representam significados especiais. Portanto, o padrão composto pode expressar mais lógica abstrata.

Vamos nos concentrar no significado e no uso de cada curinga no modo composto.

5) Explicação de caracteres especiais no modo composto:

1>/: é usado como um caractere de fuga em muitas linguagens de programação. De um modo geral

Se o símbolo for seguido pelo caractere comum C, então / c representa um significado especial. Por exemplo, n representa originalmente o caractere n, mas /n representa uma nova linha.

Se o / símbolo for seguido por um caractere especial C, então / c representa o caractere comum c. Por exemplo, / é geralmente usado como um caractere de fuga, mas // é usado para ajustar o caractere comum /.

O uso de / na expressão regular de JavaScript é o mesmo que acima, mas em diferentes linguagens de programação, as tabelas de caracteres especiais podem ser diferentes.

2>^: Combine o início da sequência de entrada. Se for uma correspondência de várias linhas, ou seja, os parâmetros adicionais da expressão contêm M, ela também será correspondida após uma nova linha.

exemplo:

/^B/corresponde ao primeiro b em "Bab BC"

Exemplo 2:

/^B/gm correspondência

“Badd b

CDAF

B dsfb ”

A primeira linha no primeiro B, o primeiro B na terceira linha

3> $: corresponda ao final da criação de caracteres de entrada. Se for uma correspondência de várias linhas, ou seja, os parâmetros adicionais da expressão contêm M, ela também será correspondida antes de uma nova linha.

Ao contrário do uso de ^.

Exemplo: / T $ / Matches em "Bat", mas não corresponde a "Hate"

Exemplo 2: /T $ /Match

“Tag em

bastão"

O último T da primeira linha e o T da segunda linha.

4>*: Combine o caractere anterior 0 ou mais vezes.

Exemplo: /ab* /corresponde "abbbb" em "dddabbbbbc", e também combina "a" em "ddda"

5>+: Combine o caractere anterior 1 ou mais vezes.

Exemplo: / ab+ / corresponde "abbbb" em "dddabbbbbc", mas não corresponde a "ddda"

Semelhante ao uso dos seguintes {1,} (protótipo: {n,})

6>?: O uso de? é bastante especial. De um modo geral, é usado para corresponder ao personagem anterior 0 vezes ou 1 tempo, mas possui outros dois usos especiais:

Se imediatamente segui -se *, +,? e {}, significa o número mínimo de correspondências da partida original, por exemplo:

/ ba*/ originalmente correspondente "baaaa" em "bbbaaaaa", mas/ ba*?/ correspondente "b" em "bbbaaaa" (porque*significa 0 ou mais correspondências, enquanto mais?

Da mesma forma: / ba+? / Corresponde "ba" em "baaaa".

Como um símbolo da estrutura de sintaxe, ele é usado na pré-avaliação, ou seja, x (? = Y) e x (?! = Y) a ser mencionado posteriormente.

7>.: O "." Assinar o ponto decimal corresponde a qualquer caractere, exceto o caractere de nova linha.

Quais são os personagens do padrão no total? Consulte: Conjunto de personagens

Por exemplo: / ab / corresponde "ACB" em "ACBAA", mas não corresponde a "Abbb".

8> (x): significa corresponder x (não se referindo especificamente ao caractere x ou se referindo especificamente a um caractere, x representa uma string) e a correspondência será lembrada. Em sintaxe, esse tipo de () é chamado de "captura de pais", ou seja, os colchetes usados para capturar.

As correspondências são lembradas porque, nas funções fornecidas pela expressão, algumas funções retornam uma matriz que mantém todas as seqüências de correspondência, como a função EXEC ().

Observe também que a premissa de que x () é lembrada é corresponder a x.

Exemplo 1:

var regx =/a (b) c/;

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

Como pode ser visto no acima, / a (b) C / corresponde a "ABC" em "ABCDDD". Por causa de (), B também o gravará, então o conteúdo numérico retornado por RS é:

{abc, b}

Exemplo 2:

var regx =/a (b) c/;

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

RS retorna nulo, porque / a (b) c / não corresponde a "acbcddd", portanto b em () não será gravado (embora a string contenha b)

9> (?: X): Combine x, mas não se lembre de x. () Nesse formato, é chamado de "pais não capturados", ou seja, suportes para não captura.

exemplo:

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

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

Como pode ser visto no exposto, / a (?: b) c / corresponde "ABC" em "ABCDDD", por causa de (? :), B não será gravado, então o conteúdo numérico retornado por rs é:

{abc}

10> x (? = Y): corresponde a x, apenas se Y for seguido imediatamente. Se as partidas das partidas, apenas X será lembrado e Y não será lembrado.

exemplo:

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

var rs = regx.exec ("O nome de usuário é Mary");

Resultado: a correspondência é bem -sucedida e o valor de Rs é {user}

11> x (?! Y): Combine x, apenas se Y não for seguido imediatamente. Se as partidas das partidas, apenas X será lembrado e Y não será lembrado.

exemplo:

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

var rs = regx.exec ("o nome do usuário é Mary");

Resultado: a correspondência é bem -sucedida e o valor de Rs é {user}

Exemplo 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 "." sinal. 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。

exemplo:

var regx=/beijing|shanghai/;

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

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

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

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

exemplo:

var regx=/ab{2}c/;

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

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

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

exemplo:

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

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

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

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

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

exemplo:

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

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

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

Exemplo 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. além disso:

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]。

exemplo:

var regx=/a[bc]d/;

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

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

Exemplo 2:

var regx=/a[bc]d/;

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

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

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

exemplo:

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

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

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

Exemplo 2:

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

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

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

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

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

exemplo:

var regx=//bc./;

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

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

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

exemplo:

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]。

exemplo:

var regx=/user/d/;

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

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

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

exemplo:

var regx=/user/D/;

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

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

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

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

exemplo:

var regx=/a/nbc/m;

var str=“a

bc”;

var rs=regx.exec(str);

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

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

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

exemplo:

var regx=//si/;

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

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

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

exemplo:

var regx=//Si/;

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

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

28>/t：匹配一个tab

exemplo:

var regx=/a/tb/;

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

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

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

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

exemplo:

var regx=//w/;

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

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

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

exemplo:

var regx=//w/;

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

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

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

exemplo:

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 exemplo:

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 exemplo:

var regx=/user/d+/g;

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

flag的值为true。

3）String对象方法

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

exemplo:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.match(regx);

rs的值为：{user1,user3}

2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。

exemplo:

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的匹配字符串（注意小括号可以记忆匹配）。

exemplo:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为：003userddd0045

Exemplo 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都没有关系，结果是一样的。

exemplo:

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 exemplo:

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 exemplo:

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 exemplo:

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个汉字。

concluir:

 <script>function checkForm(obj){ var username=obj.username.value; var regx=/^[/u4e00-/u9fa5]{2,4}$/g if(!regx.test(username)){ alert("Invalid username!"); retornar falso; } return true;}</script><form name="myForm" onSubmit="return checkForm(this)"> <input type="text" name="username"/> <input type="submit" vlaue="submit"/>

2）实际应用二

描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。

concluir:

 <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 exemplo

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 exemplo:

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 possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.