Coleção abrangente de expressões regulares VUE

1. Sintaxe básica de expressões regulares

var expression = /pattern(模式)/flags(标识符);

2. Como criar uma expressão regular

1. Criação literal

código mostrado abaixo:

//匹配字符串中所有“at”的实例
var e = /at/g;
//匹配第一个“bat”或“cat”,不区分大小写
var e = /[bc]at/i;

2. Criação do construtor RegExp

O construtor RegExp recebe dois parâmetros, o primeiro parâmetro é o padrão de string a ser correspondido e o segundo parâmetro é uma string identificadora opcional. código mostrado abaixo:

//匹配第一个“bat”或“cat”,不区分大小写
var e = new RegExp("[bc]at","i");

Comparação de dois métodos de criação :

No ECMAScript3, a diferença entre a criação literal e a criação de objetos RegExp é: a criação literal sempre compartilha a mesma instância RegExp, e cada instância RegExp criada pelo construtor é uma nova instância. ECMAScript5 estipula claramente que o uso de literais de expressão regular deve ser como chamar o construtor RegExp diretamente, uma nova instância RegExp é criada a cada vez. IE9+, Firefox 4+ e Chrome fizeram alterações.

Deve-se observar que os metacaracteres em expressões regulares devem ter escape . Metacaracteres são:

( [ { \ ^ $ | ) ? * + . ] }

Por exemplo:

//匹配第一个“[bc]at”,不区分大小写
var e = /\[bc\]at/i;
//在RegExp构造函数创建时，元字符需要双重on转义
var e = new RegExp("\\[bc\\]at","i");

3. Propriedades e métodos de instâncias RegExp

Propriedades da instância RegExp

ignoreCase retorna um valor booleano indicando se o objeto RegExp possui flag i
global retorna um valor booleano indicando se o objeto RegExp possui representação g
multiline retorna um valor booleano indicando se o objeto RegExp possui representação m
lastIndex é um número inteiro que identifica a posição do caractere onde começa a próxima correspondência.
soure retorna o texto original da expressão regular (excluindo barras invertidas)
eu executo uma correspondência sem distinção entre maiúsculas e minúsculas
g executa uma correspondência global (encontra todas as correspondências em vez de parar após a primeira correspondência ser encontrada)
m realiza correspondência multilinha

Correspondência de classe de personagem

[...] Encontre qualquer caractere entre colchetes
[^..] Encontra qualquer caractere que não esteja entre colchetes
[az] encontra qualquer caractere de a minúsculo a z minúsculo
[AZ] Encontra qualquer caractere de A maiúsculo a Z maiúsculo
[Az] Encontra qualquer caractere de A maiúsculo a z minúsculo
. Encontra caracteres únicos, exceto novas linhas e terminadores de linha
\w encontra caracteres de palavras, equivalentes a [a-zA-Z0-9]
\W procura caracteres que não sejam palavras, equivalente a [^a-zA-Z0-9]
\s encontra caracteres de espaço em branco
\S encontra caracteres que não sejam espaços em branco
\d procura um número equivalente a [0-9]
\D procura caracteres não numéricos, equivalente a [^0-9]
\b corresponde aos limites das palavras
\r Encontre o caractere de retorno de carro
\t Localizar caractere de tabulação
\0 encontra caractere NULL
\n Encontre o caractere de nova linha

Repetir correspondência de caracteres

{n,m} corresponde ao item anterior pelo menos n vezes, mas não mais do que m vezes
{n,} corresponde ao item anterior n ou mais vezes
{n} corresponde ao item anterior n vezes
n? corresponde ao item anterior 0 ou 1 vezes, o que significa que o item anterior é opcional e equivale a {0,1}
n+ corresponde ao item anterior uma ou mais vezes, equivalente a {1,}
n* corresponde ao item anterior 0 ou mais vezes, equivalente a {0,}
n$ corresponde a qualquer string que termine em n
^n corresponde a qualquer string começando com n
? =n corresponde a qualquer string imediatamente seguida pela string especificada n
?!n corresponde a qualquer string que não seja imediatamente seguida pela string especificada n

combinar números específicos

^[1-9]\d*$ corresponde a números inteiros positivos
^-[1-9]\d*$ corresponde a números inteiros negativos
^-?[0-9]\d*$ corresponde a números inteiros
^[1-9]\d*|0$ corresponde a números inteiros não negativos (números inteiros positivos + 0)
^-[1-9]\d*|0$ corresponde a números inteiros não positivos (números inteiros negativos + 0)
^[1-9]\d*.\d*|0.\d*[1-9]\d*$ corresponde a números de ponto flutuante positivos
^-([1-9]\d*.\d*|0.\d*[1-9]\d*)$ corresponde a números de ponto flutuante negativo
^-?([1-9]\d*.\d*|0.\d*[1-9]\d*|0?.0+|0)$ corresponde a números de ponto flutuante
^[1-9]\d*.\d*|0.\d*[1-9]\d*|0?.0+|0$ corresponde a números de ponto flutuante não negativos (números de ponto flutuante positivos + 0 )
^(-([1-9]\d*.\d*|0.\d*[1-9]\d*))|0?.0+|0$ corresponde a números de ponto flutuante não positivos ( números de ponto flutuante negativo + 0)

4. Quais são os métodos de expressões regulares regulares?

Método 1.exec()

O método exec() é projetado para o grupo de captura do padrão. Este método recebe um parâmetro, que é a string a ser correspondida. O método retorna um Array contendo o grupo de captura. Se nenhum grupo de captura corresponder, ele retorna nulo. Na matriz retornada Array, o primeiro item é a string que corresponde a todo o padrão e os outros itens são strings que correspondem aos grupos de captura no padrão. Existem também dois parâmetros no array Array: entrada (retorna a string a ser correspondida) e índice (retorna a posição do item correspondente na string).O grupo de captura no padrão refere-se à string entre parênteses.

Por exemplo:

var e = /do(es)(d)?/;
e.exec("ssdoesdo");
/**
array[0]:"doesd",
array[1]:"es",
array[2]:"d",
index:2,
input:"ssdoesdo"
**/

No exemplo, o padrão contém dois grupos de captura "es" e "d", que são strings entre parênteses.

Método 2.test()

O método test() recupera o valor especificado na string. Este método recebe um parâmetro e retorna verdadeiro se a string contiver texto que corresponda ao padrão, caso contrário retorna falso.

Por exemplo:

var e = /do(es)?/;
e.test("doesdo");
//true

Se houver um identificador g na expressão regular, cada chamada ao método test e ao método exec começará a partir do final da correspondência anterior; se não houver nenhum identificador g na expressão regular, então cada chamada ao método começará a partir de a string. Comece a combinar a partir da posição inicial.

Por exemplo:

var e = /do(es)?/g;
e.exec("ssdoesdoesdoes");
/*
array[0]:"does",
array[1]:"es",
index:2,
input:"ssdoesdoesdoes"
*/
e.exec("ssdoesdoesdoes");
/*
array[0]:"does",
array[1]:"es",
index:6,
input:"ssdoesdoesdoes"
*/

var e = /do(es)?/g;
console.log(e.test("ssdoesdoesdoes"));
console.log(e.lastIndex);
//true
//6
console.log(e.test("ssdoesdoesdoes"));
console.log(e.lastIndex);
//true
//10
console.log(e.test("ssdoesdoesdoes"));
console.log(e.lastIndex);
//true
//14

var e = /do(es)?/;
console.log(e.test("ssdoesdoesdoes"));
console.log(e.lastIndex);
//true
//0
console.log(e.test("ssdoesdoesdoes"));
console.log(e.lastIndex);
//true
//0

5. Várias expressões de verificação regulares comumente usadas

1. Combine o número do celular

/^1[34578]\d{9}$/

3. Combine números inteiros positivos

/^[0-9]\d*$/

4. Combine o endereço IP

/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/

5. Combine e-mail

/^(\w-*\.*)+@(\w-?)+(\.\w{2,})+$/

6. Cartão de identificação correspondente

/^(\d{14}|\d{17})(\d|[xX])$/