9.1.3 Funzioni di manipolazione di stringhe

Le funzioni in questa sezione leggono o modificano il testo di una o più stringhe.

gawk implementa la localizzazione (vedi la sezione Il luogo fa la differenza) ed effettua ogni manipolazione di stringhe trattando ogni singolo carattere, non ogni singolo byte. Questa distinzione è particolarmente importante da comprendere per quelle localizzazioni in cui un singolo carattere può essere rappresentato da più di un byte. Quindi, per esempio, la funzione length() restituisce il numero di caratteri in una stringa, e non il numero di byte usato per rappresentare quei caratteri. Allo stesso modo, index() restituisce indici di caratteri, e non indici di byte.

ATTENZIONE: Un certo numero di funzioni riguarda indici all’interno di stringhe. Per queste funzioni, il primo carattere di una stringa è alla posizione (all’indice) uno. Questo comportamento è differente da quello del C e dei linguaggi che da esso discendono, nei quali il primo carattere è alla posizione zero. È importante ricordarlo quando si fanno calcoli sugli indici, in particolare se si ha familiarità con il linguaggio C.

Nella lista seguente, i parametri opzionali sono racchiusi tra parentesi quadre ([ ]). Parecchie funzioni operano sostituzioni in una stringa; la spiegazione completa di ciò è contenuta nella descrizione della funzione sub(), che si trova quasi alla fine di questa lista, ordinata alfabeticamente.

Le funzioni specifiche di gawk sono contrassegnate col simbolo del cancelletto (‘#’). Tali funzioni non sono disponibili in modalità compatibile (vedi la sezione Opzioni sulla riga di comando):

asort(sorgente [, destinazione [, come ] ]) #

asorti(sorgente [, destinazione [, come ] ]) #

Queste due funzioni sono abbastanza simili, e quindi sono descritte insieme.

NOTA: La seguente descrizione ignora il terzo argomento, come, perché richiede la conoscenza di funzionalità di cui non si è ancora parlato. Per questo motivo la seguente trattazione è volutamente semplificata. (In seguito l’argomento verrà trattato in maniera più esauriente; si veda Ordinare valori e indici di un vettore con gawk per la descrizione completa.)

Entrambe le funzioni restituiscono il numero di elementi nel vettore sorgente. Con asort(), gawk ordina i valori di sorgente e rimpiazza gli indici dei valori ordinati di sorgente con numeri interi sequenziali, a partire da uno. Se si specifica il vettore opzionale destinazione, sorgente è copiato in destinazione. destinazione viene quindi ordinato, lasciando immodificati gli indici di sorgente.

Nel confronto tra stringhe, la variabile IGNORECASE influenza l’ordinamento (vedi la sezione Ordinare valori e indici di un vettore con gawk). Se il vettore sorgente contiene sottovettori come valori (vedi la sezione Vettori di vettori), questi saranno alla fine, dopo tutti i valori scalari. I sottovettori non vengono ordinati ricorsivamente.

Per esempio, se i contenuti del vettore a sono i seguenti:

a["ultimo"] = "de"
a["primo"] = "sac"
a["mediano"] = "cul"

Una chiamata a asort():

asort(a)

genera i seguenti contenuti di a:

a[1] = "cul"
a[2] = "de"
a[3] = "sac"

La funzione asorti() si comporta in maniera simile ad asort(); tuttavia l’ordinamento avviene in base agli indici, e non in base ai valori. Quindi, nell’esempio seguente, a partire dallo stesso insieme iniziale di indici e valori nel vettore a, la chiamata di ‘asorti(a)’ produrrebbe:

a[1] = "mediano"
a[2] = "primo"
a[3] = "ultimo"

NOTA: Per limitazioni dovute all’implementazione, non si possono usare né SYMTAB né FUNCTAB come argomenti di queste funzioni, neppure se si specifica un secondo vettore da utilizzare per effettuare l’ordinamento. Se si tenta di farlo, viene generato un errore fatale. Questa limitazione potrebbe venire meno in futuro.

gensub(regexp, rimpiazzo, come [, obiettivo]) #

Ricerca nella stringa obiettivo delle corrispondenze all’espressione regolare regexp. Se come è una stringa che inizia con ‘g’ o ‘G’ (abbreviazione di “global”), sostituisce ogni occorrenza di regexp con la stringa rimpiazzo. Altrimenti, come è visto come un numero che indica quale corrispondenza di regexp va rimpiazzata. Valori numerici inferiori a uno vengono gestiti come se avessero il valore uno. Se non si specifica il nome dell’obiettivo, si opera su $0. La funzione restituisce come risultato la stringa modificata, e la stringa originale di partenza non viene modificata.

gensub() è una funzione generale di sostituzione. Mira a fornire più funzionalità rispetto alle funzioni standard sub() e gsub().

gensub() prevede una funzionalità ulteriore, non disponibile in sub() o gsub(): la possibilità di specificare componenti di una regexp nel testo da sostituire. Questo è fatto utilizzando delle parentesi nella regexp per designare i componenti, e quindi inserendo ‘\N’ nel testo di rimpiazzo, dove N è una cifra da 1 a 9. Per esempio:

$ gawk '
> BEGIN {
>      a = "abc def"
>      b = gensub(/(.+) (.+)/, "\\2 \\1", "g", a)
>      print b
> }'
-| def abc

Come con sub(), occorre battere due barre inverse, per ottenerne una come componente della stringa. Nel testo di rimpiazzo, la sequenza ‘\0’ rappresenta l’intero testo corrispondente, e lo stesso vale per il carattere ‘&’.

Il seguente esempio mostra come è possibile usare il terzo argomento per controllare quale corrispondenza della regexp sia da modificare:

$ echo a b c a b c |
> gawk '{ print gensub(/a/, "AA", 2) }'
-| a b c AA b c

In questo caso, $0 è la stringa obiettivo di default. gensub() restituisce la nuova stringa come risultato, e questa è passata direttamente a print per essere stampata.

Se l’argomento come è una stringa che non inizia con ‘g’ o ‘G’, o se è un numero minore o uguale a zero, si effettua solo una sostituzione. Se come è zero, gawk emette un messaggio di avvertimento.

Se regexp non viene trovata in obiettivo, il valore restituito da gensub() è il valore originale e non modificato di obiettivo.

gsub(regexp, rimpiazzo [, obiettivo])

Ricerca in obiettivo tutte le sottostringhe corrispondenti al criterio di ricerca, le più lunghe possibili partendo da sinistra, non sovrapposte tra loro, e le sostituisce con rimpiazzo. La lettera ‘g’ in gsub() significa “global”, e richiede di sostituire dappertutto. Per esempio:

{ gsub(/Inghilterra/, "Regno Unito"); print }

sostituisce tutte le occorrenze della stringa ‘Inghilterra’ con ‘Regno Unito’ in tutti i record in input.

La funzione gsub() restituisce il numero di sostituzioni effettuate. Se la variabile da cercare e modificare (obiettivo) è omessa, viene usato l’intero record in input. Come in sub(), i caratteri ‘&’ e ‘\’ sono speciali, e il terzo argomento dev’essere modificabile.

index(dove, cosa)

Ricerca nella stringa dove la prima occorrenza della stringa cosa, e restituisce la posizione in caratteri dell’inizio di quest’occorrenza nella stringa dove. Si consideri il seguente esempio:

$ awk 'BEGIN { print index("noccioline", "oli") }'
-| 6

Se cosa non viene trovato, index() restituisce zero.

In BWK awk e gawk, è un errore fatale usare una costante regexp per cosa. Altre implementazioni lo consentono, considerando semplicemente la costante regexp come un’espressione che significa ‘$0 ~ /regexp/’. (a.b.)

length([stringa])

Restituisce il numero di caratteri in stringa. Se stringa è un numero, viene restituita la lunghezza della stringa di cifre che rappresenta quel numero. Per esempio, length("abcde") è cinque. Invece, length(15 * 35) restituisce tre. In questo esempio, 15 * 35 = 525, e 525 è quindi convertito alla stringa "525", che è composta da tre caratteri.

Se non si specifica alcun argomento, length() restituisce la lunghezza di $0.

NOTA: In alcune delle prime versioni di awk, la funzione length() poteva essere richiamata senza alcuna parentesi. Farlo è considerata una cattiva abitudine, sebbene il POSIX standard 2008 lo consenta esplicitamente, per compatibilità con la vecchia prassi. Per garantire la massima portabilità ai programmi, è meglio mettere sempre le parentesi.

Se length() è chiamata con una variabile che non è stata usata, gawk considera la variabile come uno scalare. Altre implementazioni di awk non assegnano nessun tipo alla variabile. (a.b.) Si consideri:

$ gawk 'BEGIN { print length(x) ; x[1] = 1 }'
-| 0
error→ gawk: riga com.:1: fatale: tentativo di usare
error→                            scalare 'x' come vettore

$ nawk 'BEGIN { print length(x) ; x[1] = 1 }'
-| 0

Se --lint è stato specificato sulla riga di comando, gawk emette un avvertimento a questo riguardo.

In gawk e in parecchie altre implementazioni awk, se l’argomento è un vettore, la funzione length() restituisce il numero di elementi nel vettore. (e.c.) Ciò è meno utile di quel che sembra a prima vista, in quanto non è affatto detto che il vettore abbia come indici i numeri da 1 al numero di elementi che contiene. Se --lint è stato specificato sulla riga di comando, (vedi la sezione Opzioni sulla riga di comando), gawk avvisa che l’uso di un vettore come argomento non è portabile. Se si specifica l’opzione --posix, l’uso di un vettore come argomento genera un errore fatale (vedi la sezione Vettori in awk).

match(stringa, regexp [, vettore])

Ricerca in stringa la sottostringa più lunga, a partire da sinistra, che corrisponde all’espressione regolare regexp e restituisce la posizione del carattere (indice) con cui inizia la sottostringa (uno, se la corrispondenza parte dall’inizio di stringa). Se non viene trovata alcuna corrispondenza, restituisce zero.

L’argomento regexp può essere sia una costante regexp (/…/) che una costante stringa ("…"). In quest’ultimo caso, la stringa è trattata come una regexp per la quale cercare una corrispondenza. Vedi la sezione Usare regexp dinamiche per una spiegazione sulla differenza tra le due forme e sulle loro implicazioni riguardo al modo per scrivere correttamente un programma.

L’ordine dei primi due argomenti è l’opposto di molte altre funzioni che trattano stringhe e che hanno a che fare con espressioni regolari, come sub() e gsub(). Potrebbe essere di aiuto ricordare che per match(), l’ordine è lo stesso che per l’operatore ‘~’ : ‘stringa ~ regexp’.

La funzione match() imposta la variabile predefinita RSTART all’indice. Imposta anche la variabile predefinita RLENGTH alla lunghezza in caratteri della sottostringa individuata. Se non viene trovata alcuna corrispondenza, RSTART è impostata a zero, e RLENGTH a -1.

Per esempio:

{
    if ($1 == "TROVA")
        regexp = $2
    else {
        dove = match($0, regexp)
        if (dove != 0)
            print "Corrispondenza di", regexp, "alla posiz.", \
            dove, "in", $0
       }
}

Questo programma ricerca delle righe che corrispondono all’espressione regolare contenuta nella variabile regexp. Quest’espressione regolare può essere modificata. Se la prima parola in una riga è ‘TROVA’, regexp diventa la seconda parola su quella riga. Quindi, dato:

TROVA or+e
Il mio programma corre
ma non troppo velocemente
TROVA Melvin
JF+KM
Questa riga appartiene a Reality Engineering Co.
Melvin è passato da qui.

awk stampa:

Corrispondenza di or+e alla posiz. 19 in Il mio programma corre
Corrispondenza di Melvin alla posiz. 1 in Melvin è passato da qui.

Se vettore esiste già, viene cancellato, e quindi l’elemento numero zero di vettore è impostato all’intera parte di stringa individuata da regexp. Se regexp contiene parentesi, gli elementi aventi per indici numeri interi in vettore sono impostati per contenere ognuno la parte di stringa individuata dalla corrispondente sottoespressione delimitata da parentesi. Per esempio:

$ echo pippoooopaperpluttttttt |
> gawk '{ match($0, /(pippo+).+(plut*)/, vett)
>         print vett[1], vett[2] }'
-| pippoooo pluttttttt

Inoltre, sono disponibili indici multidimensionali che contengono la posizione di partenza e la lunghezza di ogni sottoespressione individuata:

$ echo pippoooopaperpluttttttt |
> gawk '{ match($0, /(pippo+).+(plut*)/, vett)
>           print vett[1], vett[2]
>           print vett[1, "start"], vett[1, "length"]
>           print vett[2, "start"], vett[2, "length"]
> }'
-| pippoooo pluttttttt
-| 1 8
-| 14 10

Possono non esserci indici che individuino inizio e posizione per ogni sottoespressione fra parentesi, perché non tutte potrebbero aver individuato del testo; quindi, andrebbero esaminati usando l’operatore in (vedi la sezione Come esaminare un elemento di un vettore).

L’argomento vettore di match() è un’estensione gawk. In modalità compatibile (vedi la sezione Opzioni sulla riga di comando), l’impiego di un terzo argomento causa un errore fatale.

patsplit(stringa, vettore [, regexpdelim [, separatori ] ]) #

Divide stringa in pezzi (o “campi”) definiti da fieldpat e memorizza i pezzi in vettore e le stringhe di separazione nel vettore separatori. Il primo pezzo è memorizzato in vettore[1], il secondo pezzo in vettore[2], e così via. Il terzo argomento, regexpdelim, è una regexp che descrive i campi in stringa (allo stesso modo in cui FPAT è una regexp che descrive i campi nei record in input). Può essere una costante regexp o una stringa. Se regexpdelim è omesso, viene usato il valore di FPAT. patsplit() restituisce il numero di elementi creati. separatori[i] è la stringa (che potrebbe anche essere la stringa nulla) dopo l’elemento vettore[i]. Il separatore iniziale (che potrebbe anche essere la stringa nulla) sarà in separatori[0]. Quindi, una stringa non nulla, con n campi avrà n+1 separatori. Una stringa nulla non avrà né campi né separatori.

La funzione patsplit() divide delle stringhe in pezzi in modo simile a quello con cui le righe in input vengono divise in campi usando FPAT (vedi la sezione Definire i campi in base al contenuto).

Prima di dividere la stringa, patsplit() cancella ogni elemento che fosse eventualmente presente nei vettori vettore e separatori.

split(stringa, vettore [, separacampo [, separatori ] ])

Divide stringa in pezzi separati da separacampo e memorizza i pezzi in vettore e le stringhe di separazione nel vettore separatori. Il primo pezzo è memorizzato in vettore[1], il secondo pezzo in vettore[2], e così via. Il valore della stringa specificata nel terzo argomento, separacampo, è una regexp che indica come dividere stringa (analogamente a come FS può essere un regexp che indica dove dividere i record in input). Se separacampo è omesso, si usa il valore di FS. split() restituisce il numero di elementi creati. separatori è un’estensione gawk, in cui separatori[i] è la stringa che separa vettore[i] e vettore[i+1]. Se separacampo è uno spazio bianco, ogni eventuale spazio bianco a inizio stringa viene messo in separatori[0] e ogni eventuale spazio bianco a fine stringa viene messo in separatori[n], dove n è il valore restituito da split() (cioè il numero di elementi in vettore).

La funzione split() divide le stringhe in pezzi nello stesso modo in cui le righe in input sono divise in campi. Per esempio:

split("cul-de-sac", a, "-", separatori)

divide la stringa "cul-de-sac" in tre campi usando ‘-’ come separatore. Il vettore a ha i seguenti contenuti:

a[1] = "cul"
a[2] = "de"
a[3] = "sac"

e imposta il contenuto del vettore separatori come segue:

seps[1] = "-"
seps[2] = "-"

Il valore restituito da questa chiamata a split() è tre.

Come nella divisione in campi dei record in input, quando il valore di separacampo è " ", gli spazi bianchi a inizio e fine stringa vengono ignorati nell’assegnare valori agli elementi di vettore ma non nel vettore separatori, e gli elementi sono separati da uno o più spazi bianchi. Inoltre, come nel caso della divisione dei record in input, se separacampo è la stringa nulla, ogni singolo carattere nella stringa costituisce un elemento del vettore. (e.c.) Inoltre, se separacampo è una stringa costituita da un unico carattere, quella stringa fa da separatore, anche se il carattere in questione è un metacarattere usato nella espressioni regolari.

Si noti, tuttavia, che RS non influisce sul comportamento di split(). Anche se ‘RS = ""’ fa sì che il carattere di ritorno a capo sia un separatore di campo, questo non influenza il modo in cui split() divide le stringhe.

Recenti implementazioni di awk, incluso gawk, consentono che il terzo argomento sia una costante regexp (/…/) o anche una stringa. (a.b.) Anche lo standard POSIX permette questo. Vedi la sezione Usare regexp dinamiche per la spiegazione della differenza tra l’uso di una costante stringa e l’uso di una costante regexp, sulle loro implicazioni riguardo a come scrivere correttamente un programma.

Prima di dividere la stringa, split() cancella ogni elemento eventualmente già presente nei vettori vettore e separatori.

Se stringa è la stringa nulla, il vettore non ha elementi. (Quindi, in questo modo si può cancellare un intero vettore con una sola istruzione). Vedi la sezione L’istruzione delete.)

Se in stringa non viene trovato separacampo (ma la stringa non è la stringa nulla), vettore ha solo un elemento. Il valore di quell’elemento è la stringa originale.

In modalità POSIX (vedi la sezione Opzioni sulla riga di comando), il quarto argomento non è consentito.

sprintf(formato, espressione1, …)

Restituisce (senza stamparla) la stringa che printf avrebbe stampato con gli stessi argomenti (vedi la sezione Usare l’istruzione printf per stampe sofisticate). Per esempio:

pival = sprintf("pi = %.2f (approx.)", 22/7)

assegna la stringa ‘pi = 3.14 (approx.)’ alla variabile pival.

strtonum(stringa) #

Esamina stringa e restituisce il suo valore numerico. Se stringa inizia con la cifra ‘0’, strtonum() presuppone che stringa sia un numero ottale. Se stringa inizia con ‘0x’ o ‘0X’, strtonum() presuppone che stringa sia un numero esadecimale. Per esempio:

$ echo 0x11 |
> gawk '{ printf "%d\n", strtonum($1) }'
-| 17

Usare la funzione strtonum() non è lo stesso che aggiungere zero al valore di una stringa; la conversione automatica di stringhe in numeri si applica solo a dati decimali, non a quelli ottali o esadecimali.⁴⁸

Si noti anche che strtonum() usa il separatore decimale della localizzazione corrente per riconoscere i numeri (vedi la sezione Il luogo fa la differenza).

sub(regexp, rimpiazzo [, obiettivo])

Ricerca in obiettivo, che è visto come una stringa, la prima sottostringa più lunga possibile, a partire da sinistra, che corrisponde all’espressione regolare regexp. Modifica l’intera stringa sostituendo il testo individuato con rimpiazzo. La stringa così modificata diventa il nuovo valore di obiettivo. Restituisce il numero di sostituzioni fatte (zero o uno).

L’argomento regexp può essere o una costante regexp (/…/) o una constante stringa ("…"). In quest’ultimo caso, la stringa è trattata come una regexp da individuare. Vedi la sezione Usare regexp dinamiche per la spiegazione della differenza tra le due forme, delle loro implicazioni riguardo al modo di scrivere correttamente un programma.

Questa funzione è particolare perché obiettivo non è semplicemente usato per calcolare un valore, e non basta che sia un’espressione qualsiasi: dev’essere una variabile, un campo, o un elemento di vettore in cui sub() possa memorizzare un valore modificato. Se questo argomento è omesso, il comportamento di default è quello di usare e modificare $0.⁴⁹ Per esempio:

str = "acqua, acqua dappertutto"
sub(/cqu/, "vari", str)

modifica stringa facendola divenire ‘avaria, acqua dappertutto’, rimpiazzando l’occorrenza più lunga, a partire da sinistra, di ‘cqu’ con ‘vari’.

Se il carattere speciale ‘&’ compare in rimpiazzo, designa l’esatta sottostringa individuata da regexp. (Se regexp può individuare più di una stringa, questa sottostringa può assumere valori diversi.) Per esempio:

{ sub(/candidato/, "& e sua moglie"); print }

cambia la prima occorrenza di ‘candidato’ a ‘candidato e sua moglie’ in ogni riga in input. Ecco un altro esempio:

$ awk 'BEGIN {
>         str = "daabaaa"
>         sub(/a+/, "C&C", str)
>         print str
> }'
-| dCaaCbaaa

questo mostra come ‘&’ possa rappresentare una stringa variabile e illustra anche la regola “a partire da sinistra, la più lunga” nell’individuazione di regexp (vedi la sezione Quanto è lungo il testo individuato?).

L’effetto di questo carattere speciale (‘&’) può essere neutralizzato anteponendogli una barra inversa nella stringa. Come al solito, per inserire una barra inversa nella stringa, occorre scrivere due barre inverse. Quindi, occorre scrivere ‘\\&’ in una costante stringa per includere un carattere ‘&’ nel rimpiazzo. Per esempio, quanto segue mostra come rimpiazzare il primo ‘|’ su ogni riga con un ‘&’:

{ sub(/\|/, "\\&"); print }

Come già accennato, il terzo argomento di sub() dev’essere una variabile, un campo, o un elemento di vettore. Alcune versioni di awk accettano come terzo argomento un’espressione che non è un lvalue. In tal caso, sub() cerca ugualmente l’espressione e restituisce zero o uno, ma il risultato della sostituzione (se ce n’è uno) viene scartato perché non c’è un posto dove memorizzarlo. Tali versioni di awk accettano espressioni come le seguente:

sub(/USA/, "Stati Uniti", "gli USA e il Canada")

Per compatibilità storica, gawk accetta un tale codice erroneo. Tuttavia, l’uso di qualsiasi altra espressione non modificabile come terzo parametro causa un errore fatale, e il programma non viene portato a termine.

Infine, se la regexp non è una costante regexp, è convertita in una stringa, e quindi il valore di quella stringa è trattato come la regexp da individuare.

substr(stringa, inizio [, lunghezza ])

Restituisce una sottostringa di stringa lunga lunghezza caratteri, iniziando dal carattere numero inizio. Il primo carattere di una stringa è il carattere numero uno.⁵⁰ Per esempio, substr("Washington", 5, 3) restituisce "ing".

Se lunghezza non è presente, substr() restituisce l’intero suffisso di stringa a partire dal carattere numero inizio. Per esempio, substr("Washington", 5) restituisce "ington". L’intero suffisso è restituito anche se lunghezza è maggiore del numero di caratteri disponibili nella stringa, a partire dal carattere inizio.

Se inizio è minore di uno, substr() lo tratta come se fosse uno. (POSIX non specifica cosa fare in questo caso: BWK awk si comporta così, e quindi gawk fa lo stesso.) Se inizio è maggiore del numero di caratteri nella stringa, substr() restituisce la stringa nulla. Analogamente, se lunghezza è presente ma minore o uguale a zero, viene restituita la stringa nulla.

La stringa restituita da substr() non può essere assegnata. Quindi, è un errore tentare di modificare una porzione di una stringa, come si vede nel seguente esempio:

stringa = "abcdef"
# tentare di ottenere "abCDEf", non è possibile
substr(stringa, 3, 3) = "CDE"

È anche un errore usare substr() come terzo argomento di sub() o gsub():

gsub(/xyz/, "pdq", substr($0, 5, 20))  # SBAGLIATO

(Alcune versioni commerciali di awk consentono un tale uso di substr(), ma un tale codice non è portabile.)

Se si devono sostituire pezzi di una stringa, si combini substr() con una concatenazione di stringa, nel modo seguente:

stringa = "abcdef"
…
stringa = substr(stringa, 1, 2) "CDE" substr(stringa, 6)

tolower(stringa)

Restituisce una copia di stringa, con ogni carattere maiuscolo nella stringa rimpiazzato dal suo corrispondente carattere minuscolo. I caratteri non alfabetici non vengono modificati. Per esempio, tolower("MaIuScOlO MiNuScOlO 123") restituisce "maiuscolo minuscolo 123".

toupper(stringa)

Restituisce una copia di stringa, con ogni carattere minuscolo nella stringa rimpiazzato dal suo corrispondente carattere maiuscolo. I caratteri non alfabetici non vengono modificati. Per esempio, tolower("MaIuScOlO MiNuScOlO 123") restituisce "MAIUSCOLO MINUSCOLO 123".

$ echo abc | awk '{ gsub(/m*/, "X"); print }'
-| XaXbXcX