Stringhe Letterali in Lua

Le stringhe in Lua vengono adoperate per rappresentare sequenze di testo o caratteri.

Internamente, una stringa è una sequenza di byte. Lua è agnostico rispetto alla rappresentazione dei caratteri, per cui non fa distinzione tra stringhe di testo e stringhe binarie.

Possiamo, infatti, memorizzare anche stringhe in Unicode (UTF-8 o UTF-16) o in qualsiasi altra codifica di caratteri.

In questa lezione preliminare sulle stringhe, vedremo come definire stringhe letterali all'interno del codice sorgente Lua e come utilizzare le sequenze di escape per inserire caratteri speciali.

Definizione di una stringa letterale

In Lua, una stringa letterale può essere inserita nel codice sorgente racchiudendola tra doppi apici (") oppure tra apici singoli (').

L'importante è che il delimitatore di apertura e chiusura sia lo stesso. Ad esempio, le seguenti stringhe sono valide:

print("Hello, World!")
print('Hello, World!')

Le due stringhe dell'esempio sono equivalenti e stampano entrambe il messaggio Hello, World! sulla console.

Il vantaggio di avere due modi diversi per definire le stringhe è che possiamo utilizzare un delimitatore all'interno dell'altro. Ad esempio, se vogliamo definire una stringa che contiene un apice singolo, possiamo farlo racchiudendo la stringa tra doppi apici:

print("L'apice singolo è un carattere speciale")

In questo caso, la stringa L'apice singolo è un carattere speciale verrà stampata correttamente sulla console.

In generale, l'utilizzo dei singoli apici o dei doppi apici per definire le stringhe è una questione di preferenza personale. Tuttavia, è importante essere coerenti nell'utilizzo di uno stile di scrittura per garantire la leggibilità del codice.

In altri casi, invece, l'utilizzo di un delimitatore rispetto ad un altro potrebbe dipendere dal campo di applicazione. Ad esempio, se stiamo realizzando un programma che manipola file in formato XML, potrebbe essere più comodo utilizzare gli apici singoli per definire le stringhe XML.

"Hello, World!"
'Hello, World!'

Escape di caratteri speciali

Così come in linguaggio C, anche in Lua è possibile inserire caratteri speciali all'interno di una stringa utilizzando le sequenze di escape.

Non solo, Lua utilizza la stessa sintassi del linguaggio C in tal senso.

In generale, una sequenza di escape è composta dal carattere di escape, ossia il backslash \, seguito da un carattere speciale che rappresenta il carattere da inserire nella stringa.

Nella tabella che segue sono riportati i principali caratteri speciali che possono essere utilizzati all'interno di una stringa in Lua:

Ecco un esempio di utilizzo delle sequenze di escape in Lua:

print("Hello, \nWorld!")

In questo caso, la sequenza di escape \n viene interpretata come un carattere di nuova riga, quindi il messaggio Hello, verrà stampato su una riga e World! su quella successiva:

Hello,
World!

print("Hello, \nWorld!")

In lua è anche possibile specificare il valore numerico di un carattere attraverso le sequenze di escape. Per far questo esistono due modi:

1. Utilizzare la sequenza \ddd, dove ddd è una sequenza di tre cifre decimali che rappresentano il valore numerico del carattere.
2. Utilizzare la sequenza \xhh, dove hh è una sequenza di due cifre esadecimali che rappresentano il valore numerico del carattere.

Ad esempio, il carattere A può essere rappresentato come \065 o \x41.

print("\065") -- Stampa A
print("\x41") -- Stampa A

In questo modo, possiamo rappresentare qualunque sequenza di byte all'interno di una stringa.

Per esempio, volendo rappresentare la sequenza di byte 0x48 0x65 0x6C 0x6C 0x6F possiamo scrivere:

print("\x48\x65\x6C\x6C\x6F") -- Stampa Hello

"\065" -- Rappresenta il carattere A (valore numerico 65)
"\x41" -- Rappresenta il carattere A (valore numerico 65)

Infine, a partire dalla versione 5.3 di Lua, è possibile utilizzare le sequenze di escape anche per rappresentare caratteri Unicode. Per farlo è sufficiente utilizzare la sequenza \u{hhhh}, dove hhhh è il codice esadecimale del carattere Unicode.

Ad esempio, il carattere € può essere rappresentato come \u20AC.

print("\u{20AC}") -- Stampa €

Ovviamente, l'esempio di prima funziona nel caso in cui il terminale su cui si sta eseguendo il codice supporti la codifica UTF-8.

-- Stampa di ★
print("\u{2605}")

Stringhe multi-linea

Abbiamo visto sopra che per definire una stringa in Lua è possibile utilizzare i doppi apici o gli apici singoli.

Tuttavia, il limite che abbiamo con questo metodo è che possiamo definire solo stringhe su una singola riga.

Per definire stringhe su più righe, possiamo racchiudere il testo tra due delimitatori di apertura e chiusura di due parentesi quadre [[ e ]].

Ad esempio, la seguente stringa definisce un testo su più righe:

print([[Questa è una stringa
su più righe]])

L'output del codice sarà:

Questa è una stringa
su più righe

[[Questa è una stringa
su più righe]]

Potrebbe verificarsi il caso in cui si voglia definire una stringa multi-linea che contenga al suo interno una sequenza di parentesi quadre:

-- ERRORE
[[
Questa è una stringa
che contiene [[parentesi quadre]]
]]

In tal caso si verifica un errore, poiché Lua interpreta la sequenza [[ come delimitatore di apertura di una stringa multi-linea e ]] come delimitatore di chiusura.

Per questi casi possiamo adoperare una sintassi leggermente diversa, inserendo un numero qualsiasi di segni di uguale = tra i delimitatori di apertura e chiusura:

[==[
Questa è una stringa
che contiene [[parentesi quadre]]
]==]

In questo modo, possiamo definire una stringa multi-linea che contiene sequenze di parentesi quadre senza generare errori.

La cosa importante da ricordare è che il numero di segni di uguale = tra i delimitatori di apertura e chiusura deve essere lo stesso.

Possiamo, infatti, riscrivere l'esempio di sopra come:

[===[
Questa è una stringa
che contiene [[parentesi quadre]]
]===]

In questo caso abbiamo usato tre segni di uguale sia per il delimitatore di apertura che per quello di chiusura, anziché due.

[==[
Esempio con [[parentesi quadre]]
]==]

La sintassi vista sopra per la definizione di stringhe multi-linea è molto utile quando si tratta di definire stringhe di testo che contengono spazi e caratteri di controllo.

Andrebbe, però, evitata quando dobbiamo definire stringhe che contengono dati binari o sequenze di byte, in quanto potrebbero verificarsi problemi di interpretazione.

In tali casi, è preferibile utilizzare un'altra sintassi per definire stringhe multi-linea: utilizzare la sequenza di escape \z.

Quando l'interprete Lua incontra la sequenza di escape \z all'interno di una stringa, ignora tutti i caratteri di spazio, tabulazione e ritorno a capo che seguono la sequenza fino al primo carattere non di spazio.

Pertanto, possiamo definire una stringa multi-linea che contiene sequenze di byte in questo modo:

-- Il seguente codice stampa "Hello World"
print("\x48\x65\x6C\x6C\x6F\z
       \x57\x6F\x72\x6C\x64")

La stringa risultante sarà, quindi, \x48\x65\x6C\x6C\x6F\x57\x6F\x72\x6C\x64.

Con questa semplice tecnica possiamo definire stringhe multi-linea che contengono sequenze di byte senza incorrere in problemi di interpretazione.

print("\x48\x65\x6C\x6C\x6F\z
       \x57\x6F\x72\x6C\x64")

In Sintesi

In questa lezione abbiamo visto come definire stringhe letterali in Lua e come utilizzare le sequenze di escape per inserire caratteri speciali.

Abbiamo imparato che una stringa letterale può essere racchiusa tra doppi apici o apici singoli e che la scelta del delimitatore è una questione di preferenza personale.

Abbiamo anche visto come utilizzare le sequenze di escape per inserire caratteri speciali all'interno di una stringa e come rappresentare sequenze di byte e caratteri Unicode.

Infine, abbiamo esplorato le stringhe multi-linea in Lua e come definirle in modo corretto, evitando problemi di interpretazione.

A partire dalla prossima lezione vedremo come definire variabili stringa e come manipolare le stringhe in Lua.