# Expressões Regulares
expressão regular é uma expressão usada para encontrar uma expressão [Recursos] especificado, regras de correspondência.
# Expressões regulares para definir o caminho
`` `
var reg = / ABC /;
var reg = new RegExp ( 'ABC');
Uso recomendado maneira literal, como matrizes e objetos, criar recomendado maneira literal
# Utilize expressões regulares
`` `
reg.test (str);
str.match (reg);
Especialidades # i / g / m
G é o representante global do jogo Global
i ignorar caso em nome de ignoreCase,
m representa uma multiplicidade de filas de múltiplas linhas corresponder,
# caracteres especiais
Caracteres que têm significado especial.
\ Carácter de escape
| Ou
## colchetes
`` `
[Abc] para encontrar qualquer caractere único entre colchetes
[^ Abc] Procurar qualquer caractere não nos suportes
[0-9] para encontrar um número entre 0-9
[Az] encontrar letras minúsculas
[AZ] encontrar todas as letras maiúsculas
[Az] para encontrar qualquer letra
(Red | azul | verde) especificado seqüência de pesquisa (subexpressão)
## metacharacters
`` `
Encontrar um único caractere, exceto para quebras de linha e finais de linha.
\ W para encontrar um caractere de palavra
\ W Encontre um caractere não-palavra
\ D para encontrar digitais
\ D Encontre um não-digital
\ S Encontre um caractere em branco
\ S Encontre um caracteres não-espaço em branco
\ B palavra Find fronteira
\ B Encontre um não-limite de palavra
\ N Encontrar uma nova linha
\ F caractere de alimentação Find
\ Retorno de carro Find R
\ T guia Localizar
\ V Encontrar guia verticais
\ Uxxx encontrar caracteres Unicode a dezesseis hexadecimais disposições número xxxx
## quantificador
A seguir estão a seguir jogo com avidez:
n + n corresponde a um carácter inclui, pelo menos, uma
n * corresponde a qualquer caractere contém zero ou mais ocorrências de n
n? corresponde a qualquer caractere ou um 0 n de
n sequência correspondente {X} cadeia de X n,
n {X, Y} cadeia de caracteres correspondendo a sequência de Y para X n,
n n $ string terminando com um
^ N corresponde a qualquer cadeia começando com n
? N = qualquer cadeia que corresponde à cadeia especificado é imediatamente seguido pela n
?! N corresponde a qualquer cadeia que não é imediatamente seguido pela cadeia de caracteres n especificado
jogo não-ganancioso:
n +? n *? ...
## suplemento
`` `
(:? N) correspondente sub-expressão não é um presente (não encha ganhou agrupamento)
# RegExp propriedades do objecto
Verifique se o objeto RegExp global que tem o sinalizador g
Verifique se objeto ignoreCase RegExp com a marca i
Verifique se objeto de várias linhas RegExp com a marca m
Ver fonte expressão regular texto de origem
lastIndex uma bandeira inteiro inicia a próxima partidas posição de caracteres (tipicamente utilizados com Exec)
# RegExp métodos de objetos
compilar expressão regular de compilação. (Isto é para alterar a expressão regular)
valor Exec especificado na cadeia de caracteres de pesquisa. O valor de retorno do achado e determinar a sua localização.
teste de recuperar o valor especificado na cadeia. Retorna verdadeiro ou falso.
# Método de Cordas
pesquisa de expressão regular recuperado partidas valor
Encontrar todos os resultados dos jogos estão em linha com a condição de correspondência normal
Alternativamente substituir seqüência de correspondência da expressão regular
A separação em uma matriz de cadeias (Nota: a divisão da palavra permanecerá se subexpressão expressão)
`` `
// regular forma de expressão aabb em bbaa
// var str = 'AABBCCDD';
// var reg = / (\ W) \ 1 (\ W) \ 2 / g;
// var seq1 = str.replace (reg, função ($, $ 1, $ 2) {
// retorna $ 2 + $ 2 + $ 1 + $ 1;
//})
// console.log (seq1); // bbaaddcc
// 10 bilhões três RBI para se tornar 10.000.000.000
// var str = '10000000000';
// var reg = / (? = (\ B) (\ d {3}) + $) / g;
// str.replace (reg, ''); //10.000.000.000
// abc corda para se tornar aaaaaaaaaaaaaaaaaaaaaabbbbbbbbcccccccccc pesado
// var str = 'aaaaaaaaaaaaaaaaaaaaaabbbbbbbbcccccccccc';
// var reg = / (\ W) \ 1 * (\ W) \ 2 * (\ W) \ 3 * / g;
// str.replace (reg, função ($, $ 1, $ 2, $ 3) {
// retorna $ 1 + $ 2 + $ 3;
//}); //"abc"
// converter o primeiro nome na fórmula corcova pequena theFirstName
// var str = 'a-primeira-name';
// var reg = / - (\ W) / g;
// str.replace (reg, function ($, $ 1) {
// retorna $ 1.toUpperCase ();
//}) // theFirstName
// coincidir com o final do digitais
// var str = 'dkfdj1232';
// var reg = / \ d $ / g;
// str.match (reg); // [ "2"]
// número unificado de espaços
// var str = 'fkjdf';
// var reg = / \ s + / g;
// str.replace (reg, ' '); // "fkjdf"
Analisando // cadeia não é formado por uma câmera digital
// var str = 'fdjfd214234234';
// var reg = / (\ d *:? [A-zA-Z]) / g;
// reg.test (str); // false
// exclui os espaços na string
// espaços à direita de exclusão
// var str = 'd kdfjd dfjdkf';
// var reg = / (^ \ s *) | (\ s *) $ / g;
// str.replace (reg, ''); // "d kdfjd dfjdkf"
// remover todos os espaços
// var reg = / (\ S *) / g;
// str.replace (reg, ''); // "dkdfjddfjdkf"
// jogo número de identificação
// var str = '12345678976543879X';
// var reg = / (^ \ d {15} $) | (^ \ d {18} $) | (^ \ d {17} (\ d | X | X) $) /; // necessidade de globalmente corresponder
// reg.test (str);
// verificação de endereço de e-mail
foi str = '[email protected]';
foi reg = /^[0-9a-zA-Z_-]+@[0-9a-zA-Z_-]+(\.[0-9a-zA-Z_-]+)+$/;
reg.test (str);
