Encontrar o que combinados e outros recursos avançados

Às vezes, tudo que você precisa é de saber é se o texto de entrada correspondente a um padrão. Mais comumente, que pretende ainda processar os dados específicos que foram correspondidos. Por exemplo, você espera que os dados do formulário da Web contêm um número válido de cartão de crédito - uma seqüência de 13 a 16 dígitos. Você simplesmente não deseja verificar a ocorrência desse padrão, o que você gostaria de fazer é extrair a seqüência de dígitos que foi combinado, de modo que você poderia aplicar verificações complementares. Expressões regulares permitem-lhe definir grupos de elementos de modelo; um padrão global pode, por exemplo, tem algum texto literal, um grupo com uma seqüência de comprimento variável de caracteres de alguma classe, o texto mais literal, um outro agrupamento com personagens diferentes, e assim por diante. Se o modelo é alcançado, a expressão regular as funções correspondentes vão armazenar os detalhes do jogo global e as peças de correspondência para cada um dos grupos específicos. Esses dados são armazenados em variáveis globais definidas no núcleo do Perl. Os grupos de elementos padrão, cujos resultados na seqüência são necessárias, são colocados entre parênteses. Assim, um padrão para extrair um sub 13-16 dígitos seqüência de alguns seqüência mais longa poderia ser / \ D (\ d (13,16)) \ D /; se uma seqüência de partidas esse padrão, a variável $ 1 vai realizar o dígito string. O exemplo a seguir ilustra a extração de dois campos de uma linha de entrada. A linha de entrada é suposto ser uma mensagem que contém uma quantidade de dólar. O montante de dólar deverá consistir de um sinal de dólar, um número de dígitos, um ponto decimal opcional e uma quantidade fração opcional. O padrão utilizado para esta partida é:

/ \ $ ([0-9] +) \.? ([0-9] *) \ D /

Seus elementos são:

\ $ Um sinal de dólar literal ([0-9] +) A non-empty seqüência de dígitos formando o primeiro grupo \.? Um ponto decimal opcional ([0-9] *) Uma seqüência opcional de dígitos formando o segundo grupo \ D Qualquer "não dígito" caráter

O texto que corresponde ao primeiro subgrupo entre parênteses é realizada no núcleo do Perl variável $ 1, o texto correspondente ao segundo grupo de dígitos iria em US $ 2. Desde a segunda expressão subgrupo especifica 'dígitos zero ou mais', é possível por US $ 2 para manter uma seqüência vazia após um bom jogo. As variáveis $ 1, $ 2, etc são só de leitura; valores dos dados deve ser copiado a partir dessas variáveis, antes de poderem ser alterados.

while (1) (print "Enter string:"; $ str =  If ($ str = ~ / Quit / i) (last;) if ($ str = ~ / \ $ ([0-9] +) \.? ([0-9] *) \ D /) (if ($ 2) ($ centavos = $ 2;) else ($ centavos = 0;) print "US $ 1 e $ centavos centavos \ n";) else (print "Não jogo extrator dólar \ n";))

Exemplos de entradas e saídas de teste são:

Digite seqüência: Este é um teste do programa $. Didn't fósforo extrator dólar Digite seqüência: Este programa custa $ 0. Dollars 0 cêntimos e 0 Enter seqüência: Este programa deve custar $ 34,99 dólares e 34 centavos 99 Enter string: QUIT

Muitas vezes, você precisa de um padrão como:

Alguns texto fixo;

Uma seqüência de caracteres cujo valor é arbitrário, mas é necessária para a transformação;

Alguns texto mais fixos.

Você usa .* para coincidir com uma seqüência arbitrária, por isso, se você estava procurando extrair o sub-seqüência fixa entre as palavras 'texto' e ', você pode usar o padrão / Fixo (.* texto) /:

while (1) (print "Enter string:"; $ str =  If ($ str = ~ / Quit / i) (last;) if ($ str = ~ / Fixo (.* texto) /) (print "Combinado com substring $ 1 \ n";) else (print "Didn't match \ n ";))

Exemplo de entradas e saídas:

Enter string: Fixa-se o texto no slide. Matched com substring até Enter string: fixa-se neste texto. Agora a começar a trabalhar em outro texto. Matched com substring até este texto. Agora a começar a trabalhar em outras

A correspondência de seqüências arbitrárias pode, por vezes problemática. O algoritmo de correspondência é 'guloso' - ele tenta encontrar a seqüência mais longa que corresponda. Há controles mais sutis, você pode usar padrões como .*? que correspondem a uma seqüência mínima (assim, no segundo dos exemplos acima, você começaria a partida 'up this'). Às vezes, há uma necessidade de padrões mais complexos como:

fixed_text (somepattern) other_stuffSAMEPATTERNrest_of_line

Esses padrões podem ser definidos através da utilização de 'referências para trás "na cadeia de caracteres padrão. Referências Voltar estão relacionados com a sub compensadas strings.When o Matcher padrão é verificar o padrão, ele encontra uma correspondência possível para a primeira sub-string (o elemento '(somepattern) "no exemplo) e salva este texto no núcleo Perl variável $ 1. Uma referência para trás, sob a forma \ 1, que ocorre mais tarde no padrão de jogo será substituído dinamicamente por este jogo guardado parcial. O combinador padrão pode então confirmar que o mesmo padrão se repete. Voltar referências são ilustradas nos fragmentos de código a seguir. Esses fragmentos podem formar uma parte de um script Perl que foi realizar uma tradução aproximada de código Pascal ao código C. Essa transformação não pode ser totalmente automatizado (as línguas têm algumas diferenças fundamentais, declarações como a habilidade de Pascal ao ninho do procedimento), porém, grande parte da tarefa de tradução pode ser automatizado. As operações mais simples de transformação que você gostaria são:

Count: = Count + 1; => Count + +; Count: = Count * Mul; => Count *= Mul; Soma: = Soma + 17; Soma => + = 17;

Para estes, você precisa de um padrão que:

Corresponde a um nome (Lvalue), o que deverá ser complementado sub-string $ 1.

Partidas de Pascal: operador de atribuição =.

Combine com outro nome que é idêntico a primeira coisa que corresponder, então você precisa voltar referência \ 1 no padrão.

Corresponde a um Pascal +, -, *, / operador, este deverá ser complementado sub-string $ 2.

Coincide com qualquer número de um ou outro nome; jogo sub-string $ 3.

Partidas de Pascal encerra ";".

Permite espaço em branco extra em qualquer lugar.

Se uma linha de entrada corresponde ao padrão, o programa pode enviar uma linha de revistas que utiliza os operadores de atribuição modificando C (+ +, + =, etc); entradas que não correspondem a saída pode ser alterada. Um quadro pequeno teste que ilustra as transformações só para '+' e '-' operadores é:

while (1) (print "Enter string:"; $ str =  If ($ str = ~ / Quit / i) (last;) if ($ str Um bastante complexo MATCH PADRÃO!) (# Replace x: = x +1 por x + +, similarmente x - if (($ 3 == 1 ) & & ($ 2 eq "+")) (print "\ t $ 1 + +; \ n";) elsif (($ 3 == 1) & & ($ 2 eq "-")) (print "\ t $ 1 -; \ n ";) # Substitua x: = x + y = a x + y, de igual modo para - else (print" \ t $ 1 $ 2 = $ 3; \ n ";)) else (print" $ str \ n ";))

O padrão aqui é necessária:

/ \ s * ([A-Za-z] \ w *) *: = * \ 1 * (\ + | \ * | \ / | -) * (([0-9 ]+)|([ A - Za-z] \ w *)) *; /)

As peças são:

 s * corresponder a qualquer número de espaços à esquerda ou caracteres de tabulação.

([A-Za-z] \ w *) que correspondem a uma seqüência que começa com uma letra, então tem um número arbitrário de letras, números e caracteres de sublinhado (deve capturar identificadores válidos Pascal variável). Esta é correspondida subgrupo $ 1, seu valor será referenciado mais tarde no padrão através da referência de volta \ 1. O seu valor pode ser usado no código de processamento.

"*" Um espaço com um quantificador * (zero ou mais), o que corresponde a qualquer espaços que aparecem após o nome da variável e antes que o operador de atribuição Pascal: =.

: = Seqüência de caracteres literal que corresponde ao operador de Pascal atribuição.

'*' Novamente, prever espaços extras.

\ 1 do padrão de referência para trás. Necessários para provar que ele está trabalhando em formas como soma: = soma + val;.

'*' A disposição habitual para os espaços extras.

(\ + | \ * \ \ / | -) Correspondem a um operador binário Pascal. (Personagens como '+' tem que ser "escapou", porque sua interpretação é normal como elementos de controle na definição padrão.)

'*' Espaços possíveis.

(([0-9 ]+)|([ A-Za-z] \ w *)) uma sub-string combinado que é ou uma seqüência de dígitos - [0-9] + - ou o nome de uma variável Pascal.

'*' Como de costume, espaços.

; Pascal separador declaração expressões regulares para correspondência de padrões complexos podem se tornar muito grande. Ouvi dizer, via e-mail, os boatos de uma expressão de 4000 caracteres que capta os elementos importantes do endereço de e-mail, fazendo provisão para a maioria das variações nas formas de endereços de e-mail!

Programas que o texto elaborado não transforma, como uma versão mais ambiciosa do brinquedo 'Pascal ao conversor de C', tipicamente necessário aplicar muitas transformações diferentes para a mesma linha de entrada. Por exemplo, um Pascal se ... então precisa ser reescrita em C se é (...)... estilo. Se a parte condicional de que a declaração envolve Pascal um operador, não deve ser reescrito usando C's! operador. Tais programas de transformação não simplesmente ler uma linha, aplicar uma transformação e saída da linha de transformação. Em vez disso, elas são aplicadas sucessivamente para a cadeia in situ. Após cada transformação, a seqüência de actualização é verificada em relação a outros padrões possíveis e seus substitutos. Perl tem um operador que realiza a substituição destas transformações in situ de seqüências. Um padrão de substituição consiste em uma expressão regular que define as características na seqüência de fonte e texto de substituição. Os padrões e substituições podem incorporar combinado sub-strings, assim é possível extrair uma parte variável de texto incorporado em algum contexto fixo e definir uma substituição na qual o texto variável está inserida em um contexto ligeiramente alterada. O imaginário "de Pascal para C transformador "é outro exemplo. Seria necessário mudar de operador de Pascal para C não é! operador. Os casos mais comuns, o que seria fácil de traduzir, são:

Lvalue: = expressão não; => lvalue! Expressão = if (expressão não), então => if (expressão!), Então

Se a declaração teria que ser submetido a novas transformações para substituir a forma de se ... então pelo C equivalente const. Um padrão de substituição que pode fazer essas transformações é:

s /(:=| \ () * Não + / \ 1! /;

O padrão define:

Um subgrupo quer que contém a seqüência literal: = ou um parêntese esquerdo (escapou como \ ().

Espaços opcionais.

O que não é literal.

Um ou mais espaços.

A substituição é qualquer texto correspondente ao subgrupo (ou: = ou parêntese esquerdo), um espaço e C's! operador. Esse padrão de substituição seria usado no código como o seguinte:

while ($ str =  ) (Chomp ($ str); # aplicar seqüência de transformações para $ str ... # negócio, junto com o operador de Pascal não $ str = ~ s /(:=| \ () * Não + / \ 1! /;. .. print $ str, "\ n";)

Suas primeiras aplicações de expressões regulares usará somente as formas mais simples de padrões. Suas tarefas serão, afinal, ser coisas simples como extrair um valor em dólar de algum texto de entrada, isolando um endereço IP de um log do servidor, ou identificar qual empresa de cartão de crédito é preferido. Mas é possível, e é muitas vezes vale a pena, para tentar mais sofisticados jogos e transforma. Você pode obter muitas idéias do perlretut Perl tutorial e perlre documentação de referência.

um artigo submetido por Andrew Peterson

Isenção de responsabilidade:O nosso site não se responsabiliza pelo conteúdo deste artigo. Webarticles é uma fonte de informação livre.
Importante: Este artigo "Encontrar o que combinados e outros recursos avançados" foi traduzida por um software automático. Nós sentimos muito por quaisquer erros de ortografia que pode ter ocorrido. Obrigado pela sua compreensão.