Notas sobre RegExp JavaScript RegExp objeto

Resumo

O construtor RegExp cria um objeto de expressão regular, usando o padrão para correspondência de texto.

Para uma introdução aos padrões regulares, leia o capítulo sobre padrões regulares no Guia JavaScript.

Sintaxe

Textos e símbolos de construtor são possíveis:
/pattern/flags new RegExp(pattern [, flags])

Parâmetros

pattern
Texto da expressão regular
flags
Se especificado, o sinal pode ter qualquer combinação dos seguintes valores:

g
Correspondência global
i
Ignorar maiúsculas e minúsculas
m
Múltiplas linhas; Deixe que os caracteres de início e fim (^ e $) funcionem no modo de múltiplas linhas (por exemplo, ^ e $ podem correspondência ao início e ao fim de cada linha do texto, e não apenas ao início e ao fim do texto de entrada completo).
u
Unicode. Trate o padrão como uma sequência de pontos de código (code points) Unicode.
y
Viscosidade; No texto de destino, a correspondência começa apenas a partir da posição especificada pela propriedade lastIndex da expressão regular (e não tenta correspondência a partir de qualquer índice posterior).
Descrição
Existem duas maneiras de criar um objeto de expressão regular: o formato literal e o construtor. Para representar uma string, o formato literal não usa aspas, enquanto os parâmetros passados para o construtor usam aspas. A seguinte expressão cria a mesma expressão regular:

/ab+c/i;
new RegExp('ab+c', 'i');
new RegExp(/ab+c/, 'i');

Quando uma expressão é atribuída, o formato literal fornece o estado de compilação (compilation) da expressão regular, usando-o quando a expressão regular é mantida como constante. Por exemplo, quando você usa um formato literal para construir uma expressão regular em um loop, a expressão regular não será recompilada (recompiled) em cada iteração.
Enquanto isso, o construtor do objeto de expressão regular, como new RegExp('ab+c') fornece a compilação em tempo de execução da expressão regular (runtime compilation). Se você souber que o padrão da expressão regular será alterado ou se não souber o que o padrão será antes, mas obtê-lo de outra fonte, como entrada do usuário, esses casos podem usar o construtor.
do ECMAScript 6A partir de, quando o primeiro parâmetro é uma expressão regular e o segundo parâmetro de sinalizador existe, new RegExp(/ab+c/, 'i') já não lança um erro TypeError (‘Não é suportado o sinalizador ao construir a partir de outra expressão regular’) e, em vez disso, cria uma nova expressão regular usando esses parâmetros.

Quando se cria um objeto de expressão regular usando o construtor, é necessário seguir as regras de escapamento de caracteres normais (adicionar um backslash \ antes). Por exemplo, o seguinte é equivalente:

var re = new RegExp("\\w+");
var re = /\w+/;

Definindo expressão regular por literal
var expression = /pattern/ flags;
pattern pode ser qualquer expressão regular simples ou complexa
flage para indicar o comportamento da expressão regular 1.g: Modo global, não para após encontrar o primeiro item correspondente 2.i: Modo sem distinção de maiúsculas e minúsculas 3.m: Modo de múltiplas linhas
Exemplo:

var pattern1 = /at/g; //Corresponde a todos os "at" na string
var pattern2 = /.valueOf());/i; //Corresponde ao primeiro "bat" ou "cat", sem distinção de maiúsculas e minúsculas
var pattern3 = /.at/gi; //Correspondência global de três caracteres que terminam em ".at". Sem distinção de maiúsculas e minúsculas

Todos os caracteres meta usados no padrão devem ser escapados. Os caracteres meta no expressão regular incluem:([{\^$|?*+.}])
Exemplo:

var pattern4 = /\[bc\]at/i; //Corresponde ao primeiro "[bc]at", sem distinção de maiúsculas e minúsculas

Usando o construtor RegExp, aceita2um parâmetro, parâmetro1:O padrão de string a ser correspondido, parâmetro2：Opcional, comportamento de sinalizador
Exemplo:

var pattern5 = new RegExp("[bc]at", "i");

Nota: Como os parâmetros de padrão do construtor RegExp são strings, em alguns casos, é necessário fazer dupla escapamento. Todos os caracteres meta precisam ser escapados

Exemplo:
Literais 　　　　　　　　Strings equivalentes
/\[bc\]at/ 　　　　 "\\[bc\\]at"
/.at/ 　　　　　　 "\\.at"
/name/\age/ 　　 "name\\/age"
/\d.\d{1,2}/ 　　 "\\d.\\d{1,2"
/\w\\hello\\123/ \\w\\\\hello\\\\123"

"}}3Nota: A criação de expressões regulares usando literals e instâncias é diferente, literals sempre compartilham a mesma instância RegExp (ECMAScript

) Cada nova instância de RegExp criada pelo construtor é uma nova instância.

console.log(pattern5Atributos de instância RegExp //.global);
console.log(pattern5false Se foi configurado o sinal g //.ignoreCase);
console.log(pattern5true Se foi configurado o sinal i //.multiline);
console.log(pattern5false Se foi configurado o sinal m //.lastIndex);
console.log(pattern50 Posição de início da busca pela próxima correspondência //.source);

[bc]at Representação de string da expressão regular

console.log(pattern5Atributos herdados // /.valueOf());/[bc]at Representação de string da expressão regular
console.log(pattern5.toString()); // /.valueOf());/[bc]at Representação de string da expressão regular
console.log(pattern5.toLocaleString()); // /.valueOf());/[bc]at Representação de string da expressão regular

i Representação literal de expressão regular
métodos de instância RegExp

método um: exec(), aceita um parâmetro, que é uma string de padrão. Retorna um array contendo informações sobre o primeiro item correspondente, retornando null em caso de ausência, o array retornado contém duas propriedades index (posição do item correspondente no caractere) e input (string aplicada ao padrão regular).
var pattern6 var text = "huang jin liang shi ge hao ren";63= new RegExp("huang( jin liAng( shi ge hao ren)?)&#
;", "i");6var matches = pattern
.exec(text); 
//console.log(matches);
// [ 'huang jin liang shi ge hao ren',
// 'jin liang shi ge hao ren',
// 'shi ge hao ren',
// index: 0,
método dois: test(), aceita um parâmetro, que é uma string de padrão. Se o padrão coincide com o parâmetro, retorna true, caso contrário, false1 input: 'huang jin liang shi ge hao ren' ]
var pattern7 = "cat, bat, sat";
sat1 var matches7= pattern1);
.exec(text1); //= new RegExp(".at", "gm");
var pattern8 = new RegExp(".at")
sat2 var matches8= pattern1);
.exec(text2); //= new RegExp(".at", "gm");
sat3 var matches8= pattern1);
.exec(text3); //cat
sat4 var matches8= pattern1);
.exec(text4); //bat
sat5 var matches8= pattern1);
.exec(text5); //console.log(matches

null

método dois: test(), aceita um parâmetro, que é uma string de padrão. Se o padrão coincide com o parâmetro, retorna true, caso contrário, false2 = "000-00-0000";
var pattern9 = new RegExp("\\d{3}-2}-4}
console.log(pattern9.test(text2))
console.log(text2);
if (pattern9.test(text2)) {
console.log("Sucesso na match");
} else {
console.log("Falha na match");
}

propriedades do construtor (não suportado em alguns navegadores)
nomes longos de atributo 　　 nomes curtos de atributo Descrição
input 　　　　 $_ 　　 string mais recente a ser matchada
lastMatch 　　 $& 　　 item de match mais recente
lastParen 　　 $+ 　　 último grupo capturado
leftContext 　　 $` 　　 texto da string de entrada antes do lastMatch
multiline 　　 $* 　　 booleano, se é um modo de multi-linha
rightContext $' 　　 texto da string de entrada após o lastMatch
　　　　　　　　$1~$9 usados para armazenar o grupo de captura qual

nas limitações do ECMAScript
1.âncoras \A e \Z de início e fim de string
2.busca para trás
3.classes de unión e interseção
4.grupos atômicos
5.suporte Unicode (exceto caracteres únicos)
6.grupos de captura nomeados
7.padrão de s e x
8.combinação de condições
9.comentário de expressão regular

Achou um método para匹配多行 no js

<script>
var s = "Please yes\nmake my day!";
alert(s.match(/yes.*day/));
// Retorna null
alert(s.match(/yes[^]*day/));
// Retorna 'yes\nmake my day'
</script>

Infelizmente, o editplus não pode ser usado, muitas vezes é mais conveniente usar o dw.