Quantificador ganancioso:
Vamos primeiro ver se a string inteira corresponde. Se nenhuma correspondência for encontrada, ele remove o último caractere na última sequência e tenta novamente. Se nenhuma correspondência for encontrada, remova a última string novamente e o processo será repetido até que uma correspondência seja encontrada ou a string não tenha caracteres restantes. Quantificadores simples são todos quantificadores gananciosos.
Quantificador preguiçoso:
Vamos primeiro ver se a primeira letra na string corresponde. Se nenhuma correspondência for encontrada, o quantificador preguiçoso continuará a adicionar caracteres da string até que uma correspondência seja encontrada ou a string inteira tenha sido verificada e não haverá correspondência. Quantificadores preguiçosos funcionam exatamente da maneira oposta.
Quantificadores dominantes:
Tente corresponder apenas a string inteira. Se a string inteira não produzir uma correspondência, nenhuma tentativa adicional será feita.
Quantificadores gananciosos Quantificadores preguiçosos dominam a descrição do quantificador
-------------------------------------------------------- -------------------------------------
?
* *?
+ +? ++ aparece uma vez ou mais
{n} {n}?
{n, m} {n, m}?
{n,} {n,}?
1. Palavras de medição gananciosas
A cópia do código é a seguinte:
var regexp = /.*bbb/g;
var a = str.match (regexp);
Alerta (A.Length);
alerta (a [0]);
O processo de trabalho de quantificadores gananciosos pode ser expresso dessa maneira:
a) Abbbaabbbaabbb1234
b) Abbaabbbaabbb123
c) AbbabbaabbaAABBB12
d) AbbababbaabbaAabbb1
e) Abbabbaabbaaabbb // true
Você pode ver que o quantificador ganancioso parará de funcionar após obter uma partida, embora tenhamos adicionado 'g' (Match Global)
2. Palavras de medição preguiçosas
A cópia do código é a seguinte:
var regexp = /.*?bbb/g;
var a = str.match (regexp);
alerta (A.Length);
alerta (a [0]);
alerta (a [1]);
Alerta (A [2]);
O processo de trabalho dos quantificadores preguiçosos pode ser expresso da seguinte maneira:
a) a
b) ab
c) Abb
d) abbb // salve o resultado e comece novamente no próximo local
e) a
f) aa
g) AAB
h) AABB
j) AABBB // salve o resultado e comece a partir do próximo local
e) a
e) aa
e) aaa
e) AAAB
e) AAABB
e) AAABBB // Salve o resultado e comece a partir da próxima posição.
A cópia do código é a seguinte:
String string = "AbbbaabbbaAabbbb1234";
Padrão p = padrão.compile (".*+Bbb");
Matcher M = P.Matcher (String);
System.out.println (M.Find ());
Como os quantificadores dominantes adotam um método de correspondência de tamanho único, como:
a) AbbabbaabbaAabbbB1234 // false
O acima é o conteúdo inteiro deste artigo.
Reserve algum tempo para compartilhar o artigo com seus amigos ou deixar um comentário. Agradecemos sinceramente o seu apoio!