sed, un editor di flusso: Espressioni regolari

3.3 Sintassi delle principali espressioni regolari

Per imparare a usare sed, si dovrebbe aver familiarità con le espressioni regolari (regexp in breve). Un’espressione regolare è un modello di confronto per ricercare corrispondenze in un testo, scandito partendo da sinistra verso destra. La maggior parte dei caratteri sono ordinari: rappresentano se stessi in un modello, e corrispondono allo stesso carattere nel testo oggetto del confronto. Per fare un esempio banale, il modello

The quick brown fox

corrisponde a una parte del testo che è identica all’espressione regolare. La potenza delle espressioni regolari deriva dalla capacità di includere nel modello alternative e ripetizioni. Queste vengono codificate nel modello mediante l’uso di caratteri speciali, che non rappresentano se stessi ma vengono invece interpretati in modo speciale. Segue una breve descrizione della sintassi delle espressioni regolari come vengono usate da sed.

car

Un singolo carattere ordinario corrisponde a se stesso.

*

Corrisponde a una sequenza di zero o più occorrenze di elementi rappresentati dall’espressione regolare che lo precede, che può essere un carattere ordinario, un carattere speciale preceduto da \, un ., un’espressione regolare raggruppata (si veda più avanti), o un’espressione fra parentesi. Come estensione GNU, un’espressione regolare con un suffisso può anche essere seguita da un *; per esempio, a** è equivalente a a*. Secondo POSIX 1003.1-2001 * rappresenta se stesso quando appare all’inizio di un’espressione o sotto-espressione regolare, ma molte implementazioni nonGNU non supportano questo comportamento, per cui gli script portabili dovrebbero usare \* in questi contesti.

\+

Come *, ma corrisponde a una o più. È un’estensione GNU.

\?

Come *, ma corrisponde a zero o una. È un’estensione GNU.

\{i\}

Come *, ma corrisponde esattamente a i sequenze (i è un intero decimale; per questioni di portabilità, va tenuto tra 0 e 255 compresi).

\{i,j\}

Corrisponde a un numero di sequenze tra i e j inclusi.

\{i,\}

Corrisponde a sequenze in numero maggiore o uguale a i.

$regexp$

Raggruppa la regexp interna in un insieme, e viene usata per:

Applicare operatori di suffisso, come $abcd$*: questo ricerca zero o più sequenze intere di ‘abcd’, mentre abcd* ricercherà ‘abc’ seguito da zero o più occorrenze di ‘d’. Si noti che il supporto per $abcd$* è richiesto da POSIX 1003.1-2001, però implementazioni non-GNU non lo supportano e perciò non è universalmente portabile.
Usare riferimenti all’indietro (si veda più avanti).

.

Corrisponde a qualsiasi carattere, compreso il newline.

^

Corrisponde alla stringa nulla all’inizio del pattern space, cioè quello che compare dopo l’accento circonflesso deve comparire all’inizio del pattern space.

Nella maggior parte degli script, il pattern space è inizializzato al contenuto di ogni riga (vedi Funzionamento di sed). Così è un’utile semplificazione ritenere che ^#include ritrovi le righe dove ‘#include’ è la prima cosa sulla riga—se ci sono degli spazi prima, per esempio, la corrispondenza non c’è. Questa semplificazione è valida finché non viene modificato il contenuto originale del pattern space, per esempio con un comando s.

^ agisce come un carattere speciale solo all’inizio dell’espressione o sotto-espressione regolare (cioè dopo \( o \|). Gli script portabili dovrebbero comunque evitare ^ all’inizio di una sotto-espressione, poiché POSIX consente implementazioni che trattano ^ come carattere ordinario in quel contesto.

$

È lo stesso di ^, ma designa la fine del pattern space. Inoltre $ si comporta come carattere speciale solo alla fine dell’espressione o sotto-espressione regolare (cioè prima di \) o \|), e il suo uso alla fine di una sotto-espressione non è portabile.

[lista]

[^lista]

Corrisponde a ogni singolo carattere presente nella lista: per esempio, [aeiou] corrisponde a ogni vocale. Una lista può includere sequenze come car1-car2, che corrispondono a qualsiasi carattere compreso tra car1 e car2 (entrambi inclusi).

Un ^ iniziale inverte il significato di lista, cosicché corrisponde a ogni singolo carattere che non è in lista. Per includere ] nella lista, esso dev’essere il primo carattere (dopo il ^ se necessario), per includere - nella lista, si deve metterlo all’inizio o alla fine; per includere ^ si deve metterlo dopo il primo carattere.

I caratteri $, *, ., [ e \ normalmente non sono speciali se compaiono in una lista. Per esempio, [\*] corrisponde sia a ‘\’ che a ‘*’, perché \ qui non è speciale. Tuttavia, stringhe come [.ch.], [=a=] e [:space:] sono speciali all’interno di lista e rappresentano rispettivamente simboli di collazione, classi di equivalenza e classi di carattere, e di conseguenza [ è speciale all’interno di lista quando è seguito da ., = o :. Inoltre, quando non sono in modalità POSIXLY_CORRECT, protezioni speciali come \n e \t vengono riconosciute all’interno di lista. Vedi Protezioni.

regexp1\|regexp2

Corrisponde sia a regexp1 che a regexp2. Usare le parentesi per usare espressioni regolari complesse alternative. Il processo di confronto tenta ogni alternativa una per volta, da sinistra a destra, e viene usata la prima che viene trovata. È un’estensione GNU.

regexp1regexp2

Corrisponde alla concatenazione di regexp1 e regexp2. La concatenazione lega più strettamente di \|, ^ e $, ma meno strettamente degli altri operatori delle espressioni regolari.

\cifra

Corrisponde alla cifra-esima $…$ sotto-espressione tra parentesi nell’espressione regolare. Questo è noto come riferimento all’indietro (back reference). Le sotto-espressioni sono implicitamente numerate contando le occorrenze di \( da sinistra a destra.

\n

Corrisponde al carattere di newline.

\car

Corrisponde a car, dove car è uno fra i caratteri $, *, ., [, \ o ^. Da notare che le sole sequenze di barra inversa (\) in stile C che si può supporre siano interpretate in modo portabile sono \n e \\; in particolare, \t non è portabile, e nella maggior parte delle implementazioni di sed individua una ‘t’ piuttosto che un carattere di tabulazione.

Si noti che l’interpretazione dell’espressione regolare è “avida” (greedy), cioè le corrispondenze vengono cercate da sinistra verso destra, e se sono possibili due o più corrispondenze che partono dallo stesso carattere, si sceglie la più lunga.

Esempi:

‘abcdef’: Corrisponde a ‘abcdef’.
‘a*b’: Corrisponde a zero o più ‘a’ seguite da una singola ‘b’. Per esempio, ‘b’ o ‘aaaaab’.
‘a\?b’: Corrisponde a ‘b’ o ‘ab’.
‘a\+b\+’: Trova una o più ‘a’ seguite da una o più ‘b’: ‘ab’ è la corrispondenza più corta possibile, però altri esempi sono ‘aaaab’ o ‘abbbbb’ o ‘aaaaaabbbbbbb’.
‘.*’
‘.\+’: Corrispondono entrambe a tutti i caratteri in una stringa; tuttavia, la prima trova tutte le stringhe (compresa la stringa vuota), mentre la seconda trova solo le stringhe contenenti almeno un carattere.
‘^main.*(.*)’: Corrisponde a una stringa che inizia con ‘main’, seguita da una parentesi aperta e da una chiusa. Non è necessario che ‘n’, ‘(’ e ‘)’ siano adiacenti.
‘^#’: Corrisponde a una stringa che inizia con ‘#’.
‘\\$’: Corrisponde a una stringa che termina con una singola barra inversa. La regexp ne contiene due per proteggerla.
‘\$’: Questa invece corrisponde a una stringa costituita da un simbolo del dollaro, perché è preceduta da un carattere di protezione.
‘[a-zA-Z0-9]’: Nella localizzazione C, individua qualsiasi numero o lettera ASCII.
‘[^ tab]\+’: (qui tab rappresenta un carattere di tabulazione). Trova una stringa di uno o più caratteri, nessuno dei quali è uno spazio o un carattere di tabulazione. Solitamente ciò significa una parola.
‘^$.*$\n\1$’: Trova una stringa consistente di due sotto-stringhe uguali separate da un newline.
‘.\{9\}A$’: Trova nove caratteri seguiti da una ‘A’.
‘^.\{15\}A’: Trova l’inizio di una stringa che contiene 16 caratteri, l’ultimo dei quali è una ‘A’.