Construindo resumo das expressões regulares
Construto correspondência
personagem
x caracteres x
// caracteres de barriga
/0n caractere n com valor octal 0 (0 <= n <= 7)
/0nn caractere nn com valor octal 0 (0 <= n <= 7)
/0mnn caractere mnn com valor octal 0 (0 <= m <= 3, 0 <= n <= 7)
/xhh caractere hh com valor hexadecimal 0x
/uhhhh personagem hhhhh com valor hexadecimal 0x
/t tab ('/u0009')
/n Novo caractere (quebra de linha) ('/u000a')
/r Caractere de retorno de carruagem ('/u000d')
/f Página quebra ('/u000c')
/um símbolo de alarme (sino) ('/u0007')
/e escape caractere ('/u001b')
/cx correspondente a x
Classe de personagem
[ABC] A, B ou C (classe simples)
[^ABC] Qualquer personagem, exceto A, B ou C (negativo)
[A-ZA-Z] A a Z ou A a Z, as letras nas duas extremidades estão incluídas (intervalo)
[AD [MP]] A a D ou M para P: [A-DM-P] (Union)
[AZ && [def]] D, E ou F (interseção)
[az && [^bc]] a a z, exceto b e c: [ad-z] (menos)
[AZ && [^MP]] A a Z, não para P: [a-lq-z] (menos)
Classes de caracteres predefinidas
. Qualquer personagem (pode ou não corresponder ao personagem final da linha)
/D Número: [0-9]
/D Não-número: [^0-9]
/s caractere de espaço em branco: [/t/n/x0b/f/r]
/S caracteres não-whitespace: [^/s]
/W Personagens da palavra: [A-ZA-Z_0-9]
/W personagens não-palavras: [^/w]
Classe de personagens POSIX (somente US-ASCII)
/p {inferior} caracteres alfabetistas minúsculos: [AZ]
/P {Upper} Caracteres da letra capital: [AZ]
/P {ASCII} All ASCII: [/x00-/x7f]
/p {alpha} alfa caracteres: [/p {inferior}/p {Upper}]
/P {Digit} Número decimal: [0-9]
/p {alnum} caracteres alfanuméricos: [/p {alpha}/p {digit}]
/p {punt} pontuação:! "#$%& '()*+,-./:; <=>?@[/]^_` {|} ~
/p {Graph} caracteres visíveis: [/p {alnum}/p {punt}]
/p {print} caracteres imprimíveis: [/p {Graph}/x20]
/P {Blank} Space ou Tab Character: [ /T]
/p {cntrl} caracteres de controle: [/x00-/x1f/x7f]
/p {xdigit} número hexadecimal: [0-9a-fa-f-f]
/P {Space} CARACTAR WHITESPACE: [/T/N/X0B/F/R]
Java.lang.Character Class (tipo de caractere java simples)
/p {javalowercase} é equivalente a java.lang.character.islowerCase ()
/p {javaAppercase} é equivalente a java.lang.character.isuppercase ()
/p {javawhitapace} é equivalente a java.lang.character.iswhitespace ()
/p {javamirrorado} é equivalente a java.lang.character.ismirrored ()
Blocos e classes Unicode
/p {Ingreek} caracteres em um bloco grego (bloco simples)
/p {Lu} letras maiúsculas (categoria simples)
/p {sc} símbolo da moeda
/P {Ingreek} Todos os caracteres, exceto no bloco grego (negativo)
[/p {l} && [^/p {lu}]] todas as letras, exceto letras maiúsculas (menos)
Matcário de limite
^ O começo da linha
O fim da linha $
/b limites da palavra
/B Limite não-palavras
/Um início de entrada
/G no final da partida anterior
O final da entrada /z, apenas para o último personagem final (se houver)
O fim da entrada /z
Palavra quantitativa gananciosa
X? X, uma vez ou uma vez, não
X* x, zero ou várias vezes
X+ x, uma vez ou mais
X {n} x, exatamente n vezes
X {n,} x, pelo menos n vezes
X {n, m} x, pelo menos n vezes, mas não mais do que M vezes
Palavra quantitativa relutante
X ?? X, uma vez ou uma vez, não
X*? X, zero ou várias vezes
X+? X, uma vez ou mais
X {n}? X, exatamente n vezes
X {n,}? X, pelo menos n vezes
X {n, m}? X, pelo menos n vezes, mas não mais do que M vezes
Palavras quantitativas possessivas
X?+ X, uma vez ou uma vez, não
X*+ x, zero ou várias vezes
X ++ x, uma ou mais
X {n}+ x, exatamente n vezes
X {n,}+ x, pelo menos n vezes
X {n, m}+ x, pelo menos n vezes, mas não mais do que M vezes
Operador lógico
Xy x calcanhar y
X | yx ou y
(X) x, como um grupo de captura
Citação traseira
/n qualquer grupo de captura correspondente
Citar
/Nada, mas cite os seguintes caracteres
/Q nada, mas cita todos os personagens até /e
/E nada, mas termina a referência começando com /q
Construção especial (não capturada)
(?: X) x, como um grupo não-captura
(? IDMSUX -IDMSUX) Nada, mas corresponderá ao sinalizador IDMSUX - OFF
(? IDMSUX -IDMSUX: X) x, como IDMSUX ON - OFF com a bandeira dada
Grupo que não capturou (? = x) x, através da largura de largura zero
(?! X) x, através de zero largura negativa lookahead
(? <= X) x, através de um visual positivo de largura zero
(?
(?> X) x, como um grupo independente de não captura
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Barras de barriga, fuga e referências
O caractere de barragem ('/') é usado para fazer referência a construções de escape, conforme definido na tabela acima, e também para fazer referência a outros caracteres que serão interpretados como construções não escapadas. Portanto, a expressão // corresponde a uma única barra de barriga e /{corresponde ao suporte esquerdo.
É errado usar barras -barras antes de quaisquer caracteres alfabéticos que não representam construções de fuga; Eles são reservados para extensões futuras de linguagens de expressão regular. Uma barra de barriga pode ser usada antes de um caráter não alfabético, independentemente de o caráter não fazer parte do construto escapado.
De acordo com os requisitos da especificação do idioma Java, as barras nas cordas do código -fonte Java são interpretadas como escapadas de unicode ou outras fugas de caracteres. Portanto, duas barras de barriga devem ser usadas no literal da corda para indicar que a expressão regular é protegida e não interpretada pelo compilador Java ByteCode. Por exemplo, quando interpretada como uma expressão regular, o string literal "/b" corresponde a um único caractere de backspace e "// b" corresponde à palavra limite. A string literal "/(hello/)" é ilegal e causará um erro de tempo de compilação; Para corresponder à string (hello), a string literal "// (hello //)" deve ser usada.
Classe de personagem
As classes de caracteres podem aparecer em outras classes de caracteres e podem conter operadoras sindicais (implicitamente) e operadores de interseção (&&). O operador da União representa uma classe que contém pelo menos todos os caracteres em uma de suas classes de operando. O operador de interseção representa uma classe que contém todos os caracteres em suas duas classes de operando ao mesmo tempo.
A prioridade dos operadores de classe de caracteres é a seguinte, organizada em ordem do mais alto para o mais baixo:
1 fuga literal/x
2 agrupamento [...]
3 faixa az
4 Union [ae] [iu]
5 Interseção [AZ && [aeiou]]
Observe que diferentes conjuntos de metacaracters estão realmente localizados dentro da classe de caracteres, não fora da classe de caracteres. Por exemplo, expressões regulares. O significado especial é perdido dentro de uma classe de caracteres, e a expressão - torna -se o alcance que forma metacharacters.
Caráter final de linha
Um caractere final de linha é uma sequência de um ou dois caracteres que marca o final da linha da sequência do caractere de entrada. O código a seguir é reconhecido como um caractere final de linha:
Caractere de nova linha (Line Newline) ('/n'),
O caractere de retorno do carruagem ("/r/n") seguido pelo novo caractere de linha,
Um caractere de retorno de carro separado ('/r'),
Próximo caractere de linha ('/u0085'),
Delimitador de linha ('/u2028') ou
Separador de parágrafos ('/u2029).
Se o modo Unix_Lines for ativado, o novo caractere de linha será o caractere final de linha reconhecido exclusivamente.
Se o sinalizador dotall não for especificado, a expressão regular. pode corresponder a qualquer caractere (exceto o final da linha).
Por padrão, expressões regulares ^ e $ ignoram as terminações da linha e correspondem apenas ao início e final de toda a sequência de entrada, respectivamente. Se o modo multilina for ativado, ocorre uma correspondência somente após o início da entrada e o final da linha (o final da entrada). Quando no modo multilina, $ corresponde apenas antes do final da linha ou no final da sequência de entrada.
Grupo e captura
Os grupos de captura podem ser numerados calculando seus colchetes abertos da esquerda para a direita. Por exemplo, na expressão ((a) (b (c)))), existem quatro desses grupos:
1 ((a) (b (c)))
2 /a
3 (b (c))
4 (c)
Os zeros do grupo sempre representam toda a expressão.
Os grupos de captura são nomeados dessa maneira porque, na partida, cada subsequência da sequência de entrada correspondente a esses grupos é salva. A subsequência capturada pode ser usada posteriormente na expressão por meio de referências traseiras ou pode ser obtida do Matcher após a conclusão da operação de correspondência.
A entrada de captura associada a um grupo é sempre a subseqüência que corresponde ao grupo mais recentemente. Se o grupo for calculado novamente devido à quantização, seu valor capturado anteriormente será retido na segunda falha de cálculo (se houver). Por exemplo, combinar a string "ABA" com a expressão (a (b)?)+ Definirá o segundo grupo como "B". No início de cada partida, todas as entradas capturadas são descartadas.
Os grupos que começam com (?) Grupos não de captura pura são que não capturam o texto e não contam contra a contagem de combinações.
O exposto acima é todo o conteúdo da expressão regular (recomendada pelo artigo da gramática) trazida a você pelo editor. Espero que todos possam apoiar mais wulin.com ~