Trovare quello che ha trovato e altre funzioni avanzate

A volte, tutto ciò che ti serve è sapere è se il testo di input corrisponde un modello. Più comunemente, si desidera trattare ulteriormente i dati specifici che sono stati abbinati. Ad esempio, è la speranza che i dati dal vostro web form contiene un numero valido di carta di credito - una sequenza di 13 a 16 cifre. Tu non vogliono semplicemente per verificare la presenza di questo modello, quello che si vuole fare è quello di estrarre la sequenza di cifre che è stato abbinato, in modo che si potrebbe applicare controlli di verifica ulteriore. Espressioni regolari consentono di definire gruppi di elementi del modello, un modello generale può, ad esempio, hanno un certo testo letterale, un gruppo con una sequenza di caratteri di lunghezza variabile da qualche classe, il testo più letterale, un altro gruppo con caratteri diversi, e così via. Se il modello è abbinato, l'espressione regolare funzioni corrispondenti memorizzerà i dettagli della partita in generale e le parti abbinato a ciascuno dei gruppi specifici. Questi dati sono memorizzati in variabili globali definiti nel core Perl. I gruppi di elementi del modello, le cui corrispondenze nella stringa sono necessari, sono collocati in parentesi. Così, un modello per l'estrazione di un sub-string 13-16 cifre da qualche stringa di più potrebbe essere / \ D (\ d (13,16)) \ D /, se una stringa corrisponde questo modello, la variabile $ 1 si terrà la cifra stringa. Il seguente esempio illustra l'estrazione di due campi da una linea di input. La linea di ingresso dovrebbe essere un messaggio che contiene una quantità di dollari. L'importo del dollaro dovrebbe consistere in un segno di dollaro, un certo numero di cifre, un punto decimale e opzionale per un importo opzionale frazione. Il modello utilizzato per questa partita è il seguente:

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

I suoi elementi sono:

\ $ A segno letterale del dollaro ([0-9] +) Una sequenza non vuota di cifre che formano primo gruppo \?. Un punto opzionale decimale ([0-9] *) una sequenza opzionale di cifre che formano secondo gruppo \ D Qualsiasi 'non a due cifre' character

Il testo che corrisponde al primo sottogruppo tra parentesi si svolge nella variabile di core Perl $ 1; il testo corrispondente al secondo gruppo di cifre sarebbe andato in $ 2. Dato che l'espressione secondo sottogruppo specifica 'cifre zero o più', è possibile per 2 dollari per contenere una stringa vuota dopo una partita di successo. Le variabili $ 1, $ 2 ecc sono di sola lettura, i valori dei dati deve essere copiato da queste variabili prima di poter essere cambiato.

while (1) (print "Inserire la stringa:"; $ str =  If ($ str = ~ / Esci / i) (last;) if ($ str = ~ / \ $ ([0-9] +) \.? ([0-9] *) \ D /) (if ($ 2) ($ centesimi = $ 2;) else ($ cents = 0;) print "Dollari $ 1 e $ centesimi centesimi \ n";) else (print "non ha prodotto risultati di estrazione del dollaro \ n";))

Esempi di input e output di prova sono i seguenti:

Inserire la stringa: Questa è una prova del programma di $. Non ha prodotto risultati di estrazione del dollaro Inserisci stringa: Questo programma costa $ 0. Dollari 0 e centesimi 0 Inserire la stringa: Questo programma dovrebbe costare $ 34,99 dollari e 34 centesimi 99 Inserire la stringa: QUIT

Spesso, è necessario un modello come:

Alcuni testo fisso;

Una stringa il cui valore è arbitraria, ma è necessaria per la trasformazione;

Testo più fisso.

Si utilizza .* a corrispondere una stringa arbitraria, quindi se state cercando di estrarre i sub-string tra le parole 'fissi' e 'testo', si potrebbe utilizzare il modello / Fisso (.*) text /:

while (1) (print "Inserire la stringa:"; $ str =  If ($ str = ~ / Esci / i) (last;) if ($ str = ~ / Fisso (.*) text /) (print "abbinate con sottostringa $ 1 \ n";) else (print "Didn't match \ n ";))

Esempio di ingressi e uscite:

Inserire la stringa: Fixed a testo sulla diapositiva. Abbinate con sottostringa fino Inserisci stringa: Fixed a questo testo. Ora di iniziare a lavorare su un altro testo. Abbinate con sottostringa su questo testo. Ora di iniziare a lavorare su altri

L'abbinamento delle stringhe arbitrarie possono a volte problematico. L'algoritmo di confronto è 'golosi' - si tenta di trovare la stringa più lunga che corrisponde. Non ci sono controlli più sottili, è possibile utilizzare i modelli come .*? che corrispondono a una stringa minima (così nel secondo degli esempi di cui sopra, si otterrà la partita 'questa'). A volte, vi è la necessità di modelli più complessi, come:

fixed_text (somepattern) other_stuffSAMEPATTERNrest_of_line

Questi modelli possono essere definiti attraverso l'uso di 'riferimenti indietro' nella stringa modello. Riferimenti Torna sono relative al sub-abbinate strings.When matcher il modello è il modello di controllo, trova una corrispondenza possibile per la prima sub-string (l' elemento '(somepattern)' nel nostro esempio) e salva questo testo nella variabile di core Perl $ 1. Un riferimento all'indietro, nella forma \ 1, che si verifica in seguito nel modello partita sarà sostituito dinamicamente da questa partita salvata parziale. Il matcher pattern può quindi confermare che lo stesso schema si ripete. Riferimenti Torna sono illustrati nelle seguenti frammenti di codice. Questi frammenti potrebbero formare una parte di uno script Perl che era quello di effettuare una traduzione approssimativa di codice Pascal al codice C. Una tale trasformazione non può essere completamente automatizzata (le lingue hanno alcune differenze fondamentali, come la capacità di Pascal a nidificare dichiarazioni di procedura), ma gran parte del compito di traduzione può essere automatizzato. Le operazioni più semplici di trasformazione che si vorrebbe sono i seguenti:

Count: = count + 1; => count + +; Count: = Count * Mul; => Count *= Mul; Sum: = Sum + 17; => Somma + = 17;

Per questi, è necessario un modello che:

Corrisponde a un nome (value), questo è da abbinare sub-string $ 1.

Partite di Pascal: = operatore di assegnamento.

Corrisponde un altro nome che è identico alla prima cosa che ha trovato, quindi è necessario ritornare riferimento \ 1 nel modello.

Corrisponde a un Pascal +, -, *, / operatore, questo deve associarsi sub-string $ 2.

Corrisponde un numero o un altro nome; match sub-string $ 3.

Partite di Pascal che chiude ';'.

Consente spazi extra ovunque.

Se una linea di ingresso corrisponde al pattern, il programma può uscita una linea di revisione che utilizza gli operatori di assegnazione modificando C (+ +, + =, ecc); ingressi che non corrispondono può essere output invariato. Un quadro piccolo test che illustra le trasformazioni solo per '+' e '-' Gli operatori sono:

while (1) (print "Inserire la stringa:"; $ str =  If ($ str = ~ / Esci / i) (last;) if ($ str A ABBASTANZA COMPLESSO pattern match!) (# Sostituire x: = x 1 con x + +, allo stesso modo x - if (($ 3 == 1 ) & & ($ 2 eq "+")) (print "\ t $ 1 + +; \ n";) elsif (($ 3 == 1) & & ($ 2 eq "-")) (print "\ t $ 1 -; \ n ";) # Sostituire x: = x + y con x + = y, analogamente per - else (print" \ t $ 1 $ 2 = $ 3; \ n ";)) else (print" $ str \ n ";))

Il modello qui è necessario:

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

Le parti sono:

 s * match qualsiasi numero di spazi più o caratteri di tabulazione.

([A-Za-z] \ w *) corrispondono a una stringa che inizia con una lettera, ha quindi un numero arbitrario di lettere, cifre e caratteri di sottolineatura (dovrebbe acquisire validi identificatori Pascal variabile). Questo è abbinato sottogruppo $ 1; il suo valore si farà riferimento più avanti nel modello attraverso il rinvio \ 1. Il suo valore può essere utilizzato il codice di elaborazione.

'*' Uno spazio con un quantificatore * (zero o più), questo corrisponde eventuali spazi che compaiono dopo il nome della variabile e prima che l'operatore di assegnamento Pascal: =.

: = La stringa letterale che corrisponde operatore di Pascal di assegnazione.

'*' Ancora una volta, prevedere spazi aggiuntivi.

\ 1, il modello di riferimento indietro. Necessarie per accertare che esso sta lavorando su forme come somma: = somma + val;.

'*' La disposizione abituale per gli spazi aggiuntivi.

(\ + | \ * \ \ / | -) Corrispondono a un operatore di Pascal binario. (Personaggi come '+' essere 'sfuggito' perché la loro interpretazione è normale, come elementi di controllo nella definizione del modello.)

'*' Gli spazi possibili.

(([0-9 ]+)|([ A-Za-z] \ w *)) ha trovato un sub-string che sia o una sequenza di cifre - [0-9] + - o un nome di Pascal variabile.

'*' Come di consueto, gli spazi.

; Separatore dichiarazione Pascal Le espressioni regolari per il pattern matching complessi possono diventare abbastanza grandi. Ho sentito, via e-mail, le voci di una espressione 4.000 caratteri in grado di catturare gli elementi importanti da indirizzo di posta elettronica, tenendo conto per la maggior parte delle variazioni nelle forme di indirizzi e-mail!

Programmi che il testo si trasforma elaborate, come una versione più ambizioso del giocattolo 'Pascal al convertitore di C', in genere necessità di applicare molte trasformazioni diverse per la stessa linea di input. Ad esempio, un Pascal se ... deve quindi essere riscritto in C, se (...)... stile. Se la parte condizionale di tale dichiarazione comporta una Pascal non operatore, esso deve essere riscritto in C's! operatore. Programmi di trasformazione del genere non semplicemente leggere una riga, applicare una trasformazione e la produzione della linea trasformata. Invece, sono successivamente applicata alla stringa in situ. Al termine di ogni trasformazione, la stringa di aggiornamento viene confrontato con altri modelli possibili e le loro sostituzioni. Perl ha un operatore di sostituzione che esegue queste trasforma in situ di stringhe. Un modello di sostituzione è costituito da una espressione regolare che definisce le caratteristiche della stringa di origine e il testo di sostituzione. I modelli e le sostituzioni possono incorporare abbinate sub-corde, per cui è possibile estrarre una parte variabile del testo incorporato in un contesto fisso e definire una sostituzione in cui il testo variabile è inserita in un contesto leggermente cambiato. L'immaginario 'Pascal a C trasformatore 'fornisce un altro esempio. Si sarebbe bisogno di cambiare di Pascal non all'operatore di C's! operatore. I casi comuni, che sarebbe facile da tradurre, sono i seguenti:

Value: = non espressione; =>! Value = espressione; se (non l'espressione) e poi => if (! Espressione) e poi

L'istruzione if avrebbe dovuto essere sottoposto ad ulteriori trasformazioni per sostituire il se ... allora sotto forma di un importo equivalente C costrutto. Un modello di sostituzione che potrebbe rendere queste trasformazioni è il seguente:

s /(:=| \ () * non è + / \ 1! /;

Il modello definisce:

Un sottogruppo che contiene sia la sequenza letterale: = o una parentesi sinistra (escape come \ ().

Optional spazi.

Il non letterale.

Uno o più spazi.

La sostituzione è il testo che ha trovato il sottogruppo (o: = o parentesi sinistra), uno spazio e di C! operatore. Questo modello di sostituzione potrebbe essere utilizzata nel codice come il seguente:

while ($ str =  ) (Chomp ($ str); # applicano sequenza di trasformazioni a $ str ... # prossimo, si occupano di Pascal non operatore $ str = ~ s /(:=| \ () * non è + / \ 1! /;. .. print $ str, "\ n";)

Le applicazioni prima di espressioni regolari userà solo le forme più semplici di modelli. Vostri compiti saranno, dopo tutto, sono le cose semplici, come l'estrazione di un importo in dollari da parte di testo di input, isolando un indirizzo IP da un registro del server, o per identificare quali società emittente della carta di credito è preferito. Ma è possibile, ed è spesso utile a provare più sofisticati partite e si trasforma. È possibile ottenere molte idee da perlretut Perl tutorial e perlre documentazione di riferimento.

---

Disclaimer:Il nostro sito non è responsabile per il contenuto di questo articolo. Webarticles è una risorsa gratuita di informazioni.
Importante: Questo articolo "Trovare quello che ha trovato e altre funzioni avanzate" è stato tradotto da un software automatico. Ci dispiace per eventuali errori di ortografia che possono essersi verificati. Grazie per la vostra comprensione.

---