Referências de regex

Question

Tendo a seguinte expressão regular:

([a-z])([0-9])\1

Corresponde a5a, existe alguma maneira de combinar também a5b, a5c, a5d e assim por diante?

---

EDITAR: Ok, eu entendo que eu poderia usar ([a-z])([0-9])([a-z]) Mas tenho uma expressão regular muito longa e complicada (combinando Sub-sub-sub -...- domínios ou Combinando um endereço IPv4) isso realmente se beneficiaria do comportamento descrito acima. De alguma forma, isso é possível alcançar com referências de fundo ou qualquer outra coisa?

---

Anon. responda é o que eu preciso, mas parece errôneo.

Answer 1

Você não precisa de referências de volta se a segunda letra for independente da primeira, certo?

([a-z])([0-9])([a-z])+

EDITAR

Se você simplesmente não quiser repetir a última parte repetidamente, então:

([a-z])([0-9])([a-z])

Apenas tirando o '+'.

Answer 2

A resposta é Não com referências de fundo

A referência de back -referência significa corresponder ao valor que foi correspondido anteriormente. Isso não significa corresponder à expressão anterior. Mas se o seu idioma permitir, você poderá substituir uma variável em uma string em sua expressão antes de compilá -la.

TCL:

set exp1 "([a-z])"
regexp "${exp1}([0-9])${exp1}+" $string

JavaScript:

var exp1 = '([a-z])';
var regexp = new RegExp(exp1 + '([0-9])' + exp1 + '+');
string.match(regexp);

Perl:

my $exp1 = '([a-z])';
$string =~ /${exp1}([0-9])${exp1}+/;

Answer 3

O ponto principal de uma referência de volta em uma expressão regular é corresponder à mesma coisa que a sub-expressão indicada, portanto não há como desativar esse comportamento.

Para obter o comportamento que você deseja, de poder reutilizar uma parte de uma expressão regular mais tarde, você pode simplesmente definir as partes da expressão regular que deseja reutilizar em uma string separada e (dependendo do idioma em que você está trabalhando ) Use interpolação ou concatenação de string para construir a expressão regular das peças.

Por exemplo, em Ruby:

>> letter = '([a-z])'
=> "([a-z])"
>> /#{letter}([0-9])#{letter}+/ =~ "a5b"
=> 0
>> /#{letter}([0-9])#{letter}+/ =~ "a51"
=> nil

Ou em JavaScript:

var letter = '([a-z])';
var re = new RegExp(letter + '([0-9])' + letter + '+');
"a5b".match(re)

Answer 4

Eu suspeito que você está querendo algo semelhante ao perl (?PARNO) construto (não é apenas para recursão;).

/([a-z])([0-9])(?1)+/

combinará com o que você deseja - e quaisquer alterações no primeiro grupo de captura se refletirão no que (?1) fósforos.

Answer 5

Eu não sigo sua pergunta?

[a-z][0-9][a-z] Exactly 1
[a-z][0-9][a-z]? One or 0
[a-z][0-9][a-z]+ 1 or more
[a-z][0-9][a-z]* 0 or more

Answer 6

As backreferências são para recuperar dados do início no Regex e usá -los posteriormente. Eles não são para corrigir problemas estilísticos. Um regex com referências não funcionará como um sem. Você pode precisar apenas se acostumar com as regexas sendo repetitivas e feias.

Talvez tente o Python, o que facilita a criação de regexes a partir de blocos menores. Não está claro se você tem permissão para mudar seu ambiente ... você tem sorte de ter referências em primeiro lugar.