Stringhe

Il tipo di dati stringa è una sequenza di caratteri, come lettere, numeri e simboli. È il tipo di dati per memorizzare la maggior parte delle informazioni basate su testo.

Dichiarare le stringhe

Per dichiarare una variabile stringa, racchiudi i caratteri tra virgolette. È più comune usare virgolette doppie ("), ma funzionano anche le virgolette singole ('). Se desideri includere una virgoletta singola o doppia nella tua stringa, racchiudi la tua stringa nell'altro tipo di virgoletta, oppure usa una virgoletta scappata.

local string1 = "Ciao mondo!"
print(string1)  --> Ciao mondo!

local string2 = 'Ciao "mondo"!'
print(string2)  --> Ciao "mondo"!

Per includere sia virgolette singole che doppie in una stringa, o per creare stringhe su più righe, dichiarale usando doppie parentesi quadre:

local string1 = [[Ciao
mondo!
Ciao "mondo"!
Ciao 'mondo'!]]

print(string1)
--> Ciao
--> mondo!
--> Ciao "mondo"!
--> Ciao 'mondo'!

Se necessario, puoi annidare più parentesi quadre all'interno di una stringa utilizzando lo stesso numero di segni uguale sia all'inizio che alla fine della parentesi:

local string1 = [=[Ciao
[[mondo!]]
]=]

print(string1)
--> Ciao
--> [[mondo!]]

Combinare le stringhe

Per combinare le stringhe, concatenale con due punti (..). Concatenare stringhe non inserisce uno spazio tra di esse, quindi dovrai includere spazio(i) alla fine/inizio di una stringa precedente/successiva, o concatenare uno spazio tra le due stringhe.

local hello = "Ciao"
local helloWithSpace = "Ciao "
local world = "mondo!"

local string1 = hello .. world
local string2 = helloWithSpace .. world
local string3 = hello .. " " .. world

print(string1)  --> Ciaomondo!
print(string2)  --> Ciao mondo!
print(string3)  --> Ciao mondo!

Nota che il comando print() accetta più argomenti e li combina con spazi, quindi puoi usare , invece di .. per ottenere spazi nelle uscite di print().

local hello = "Ciao"
local world = "mondo"
local exclamationMark = "!"

print(hello .. world .. exclamationMark)  --> Ciaomondo!
print(hello, world .. exclamationMark)  --> Ciao mondo!
print(hello, world, exclamationMark)  --> Ciao mondo!

Convertire le stringhe

Per convertire una stringa in un numero, usa la funzione tonumber(). Se la stringa non ha una rappresentazione numerica, tonumber() restituisce nil.

local numericString = "123"
print(tonumber(numericString))  --> 123

local alphanumericString = "Ciao123"
print(tonumber(alphanumericString))  --> nil

Scappare le stringhe

Per scappare una dichiarazione di stringa con virgolette doppie o singole ed incorporare quasi qualsiasi carattere, metti un backslash (\) davanti al carattere. Ad esempio:

• Per incorporare una virgoletta singola in una stringa con virgoletta singola, usa \'.
• Per incorporare una virgoletta doppia in una stringa con virgoletta doppia, usa \".

local string1 = 'Ciao \'mondo\'!'
print(string1)  --> Ciao 'mondo'!

local string2 = "Ciao \"mondo\"!"
print(string2)  --> Ciao "mondo"!

Alcaruni caratteri dopo i backslash producono caratteri speciali anziché caratteri scappati:

• Per incorporare una nuova riga, usa \n.
• Per incorporare un tab orizzontale, usa \t.

local string1 = "Ciao\nmondo!"
print(string1)
--> Ciao
--> mondo!

local string2 = "Ciao\tmondo!"
print(string2)  --> Ciao	mondo!

Interpolazione delle stringhe

Luau supporta l'interpolazione delle stringhe, una funzionalità che ti consente di inserire espressioni nelle stringhe. Usa i backtick (`) per dichiarare una stringa interpolata, poi aggiungi espressioni all'interno delle parentesi graffe:

local world = "mondo"

local string1 = `Ciao {world}!`
print(string1)  --> Ciao mondo!

Sebbene le variabili siano l'uso più comune, puoi usare qualsiasi espressione, inclusa la matematica:

local world = "mondo"
local number = 1
local letters = {"m", "o", "n", "d", "o"}

local string1 = `Ciao {world}, {number} volta!`
local string2 = `Ciao {world}, {number + 1} volte!`
local string3 = `Ciao {table.concat(letters)} una terza volta!`

print(string1)  --> Ciao mondo, 1 volta!
print(string2)  --> Ciao mondo, 2 volte!
print(string3)  --> Ciao mondo una terza volta!

Le regole standard di escape si applicano per i backtick, le parentesi graffe e i backslash:

local string1 = `Ciao \`\{world\}\`!`
print(string1)  --> Ciao `{world}`!

Conversione matematica

Se esegui operazioni matematiche su una stringa, Luau converte automaticamente la stringa in un numero. Se la stringa non ha una rappresentazione numerica, solleva un errore.

print("55" + 10)  --> 65
print("55" - 10)  --> 45
print("55" * 10)  --> 550
print("55" / 10)  --> 5.5
print("55" % 10)  --> 5
print("Ciao" + 10)	 --> print("Ciao" + 10):1: tentativo di eseguire aritmetica (addizione) su stringa e numero

Confronti

Le stringhe possono essere confrontate utilizzando gli operatori <, <=, > e >= che confrontano usando l'ordine lessicografico basato sui codici ASCII di ciascun carattere in una stringa. Questo porterà a numeri nelle stringhe che non vengono confrontati correttamente, per esempio, "100" sarà minore di "20", poiché i byte "0" e "1" hanno codici ASCII inferiori rispetto al byte "2".

print("Mela" < "mela") --> true
print("Banana" < "mela") --> true (B è prima di a in ASCII)
print("numero100" < "numero20") --> true

Riferimento ai pattern delle stringhe

Un pattern delle stringhe è una combinazione di caratteri che puoi usare con string.match(), string.gmatch(), e altre funzioni per trovare un pezzo, o sottostringa, di una stringa più lunga.

Corrispondenze dirette

Puoi usare corrispondenze dirette in una funzione Luau come string.match(), eccetto per i caratteri magici. Ad esempio, questi comandi cercano la parola Roblox all'interno di una stringa:

local match1 = string.match("Benvenuto su Roblox!", "Roblox")
local match2 = string.match("Benvenuto nel mio fantastico gioco!", "Roblox")
print(match1)  --> Roblox
print(match2)  --> nil

Classi di caratteri

Le classi di caratteri sono essenziali per ricerche di stringhe più avanzate. Puoi usarle per cercare qualcosa che non è necessariamente specifico di caratteri ma rientra in una categoria (classe) conosciuta, inclusi lettere, cifre, spazi, punctuazione, e altro.

La tabella seguente mostra le classi di caratteri ufficiali per i pattern delle stringhe di Luau:

Per le classi di caratteri a singolo carattere come %a e %s, la lettera maiuscola corrispondente rappresenta l'"opposto" della classe. Ad esempio, %p rappresenta un carattere di punteggiatura mentre %P rappresenta tutti i caratteri tranne quelli di punteggiatura.

Caratteri magici

Ci sono 12 "caratteri magici" riservati per scopi speciali nei pattern:

Puoi scappare e cercare caratteri magici usando il simbolo %. Ad esempio, per cercare roblox.com, scappa il simbolo . (punto) precedendolo con un % come in %..

-- "roblox.com" corrisponde a "roblox#com" perché il punto è interpretato come "qualunque carattere"
local match1 = string.match("Che cos'è roblox#com?", "roblox.com")
print(match1)  --> roblox#com

-- Scappa il punto con % in modo che venga interpretato come carattere punto letterale
local match2 = string.match("Amo roblox.com!", "roblox%.com")
print(match2)  --> roblox.com

Ancore

Puoi cercare un pattern all'inizio o alla fine di una stringa usando i simboli ^ e $.

local start1 = string.match("primo secondo terzo", "^primo")  -- Corrisponde perché "primo" è all'inizio
print(start1)  --> primo

local start2 = string.match("terzo secondo primo", "^primo")  -- Non corrisponde perché "primo" non è all'inizio
print(start2)  --> nil

local end1 = string.match("primo secondo terzo", "terzo$")  -- Corrisponde perché "terzo" è alla fine
print(end1)  --> terzo

local end2 = string.match("terzo secondo primo", "terzo$")  -- Non corrisponde perché "terzo" non è alla fine
print(end2)  --> nil

Puoi anche usare sia ^ che $ insieme per garantire che un pattern corrisponda solo all'intera stringa e non solo a una sua porzione.

-- Usando sia ^ che $ per corrispondere su un'intera stringa
local match1 = string.match("Roblox", "^Roblox$")  -- Corrisponde perché "Roblox" è l'intera stringa (uguaglianza)
print(match1)  --> Roblox

local match2 = string.match("Gioco Roblox", "^Roblox$")  -- Non corrisponde perché "Roblox" non è all'inizio E alla fine
print(match2)  --> nil

local match3 = string.match("Gioco Roblox", "Roblox")  -- Corrisponde perché "Roblox" è contenuto in "Gioco Roblox"
print(match3)  --> Roblox

Modificatori di classe

Di per sé, una classe di caratteri corrisponde solo a un carattere in una stringa. Ad esempio, il seguente pattern ("%d") inizia a leggere la stringa da sinistra a destra, trova la prima cifra (2), e si ferma.

local match = string.match("Il Regno delle Nuvole ha 25 gemme di potere", "%d")
print(match)  --> 2

Puoi usare modificatori con qualsiasi classe di caratteri per controllare il risultato:

Aggiungere un modificatore allo stesso pattern ("%d+" invece di "%d"), restituisce 25 invece di 2:

local match1 = string.match("Il Regno delle Nuvole ha 25 gemme di potere", "%d")
print(match1)  --> 2

local match2 = string.match("Il Regno delle Nuvole ha 25 gemme di potere", "%d+")
print(match2)  --> 25

Insiemi di classi

Gli insiemi dovrebbero essere utilizzati quando una singola classe di caratteri non può svolgere l'intero lavoro. Ad esempio, potresti voler corrispondere sia a lettere minuscole (%l) che a caratteri di punteggiatura (%p) utilizzando un singolo pattern.

Gli insiemi sono definiti da parentesi quadre [] attorno ad essi. Nell'esempio seguente, nota la differenza tra l'utilizzo di un insieme ("[%l%p]+") e non l'utilizzo di un insieme ("%l%p+").

local match1 = string.match("Ciao!!! Sono un'altra stringa.", "[%l%p]+")  -- Insieme
print(match1)  --> ia!!!

local match2 = string.match("Ciao!!! Sono un'altra stringa.", "%l%p+")  -- Non-insieme
print(match2)  --> o!!!

Il primo comando (insieme) dice a Luau di trovare sia caratteri minuscoli che punteggiatura. Con il quantificatore + aggiunto dopo l'intero insieme, trova tutti quei caratteri (ia!!!), fermandosi quando raggiunge lo spazio.

Nel secondo comando (non-insieme), il quantificatore + si applica solo alla classe %p prima di esso, quindi Luau prende solo il primo carattere minuscolo (o) prima della serie di punteggiatura (!!!).

Come le classi di caratteri, anche gli insiemi possono essere "opposti" di se stessi. Ciò si ottiene aggiungendo un carattere ^ all'inizio dell'insieme, direttamente dopo la parentesi quadra di apertura [. Ad esempio, "[%p%s]+" rappresenta sia la punteggiatura che gli spazi, mentre "[^%p%s]+" rappresenta tutti i caratteri eccetto la punteggiatura e gli spazi.

Gli insiemi supportano anche intervalli, che consentono di trovare un'intera gamma di corrispondenze tra un carattere di inizio e uno di fine. Questa è una funzionalità avanzata che è dettagliata nel Manuale Lua 5.1.

Catture delle stringhe

Le catture delle stringhe sono sottopattern all'interno di un pattern. Questi sono racchiusi tra parentesi () e vengono utilizzati per ottenere (catturare) sottostringhe corrispondenti e salvarle in variabili. Ad esempio, il seguente pattern contiene due catture, (%a+) e (%d+), che restituiscono due sottostringhe al momento di una corrispondenza riuscita.

local pattern = "(%a+)%s?=%s?(%d+)"

local key1, val1 = string.match("Ventuno = 21", pattern)
print(key1, val1)  --> Ventuno 21

local key2, val2 = string.match("Duemila= 2000", pattern)
print(key2, val2)  --> Duemila 2000

local key3, val3 = string.match("UnMilione=1000000", pattern)
print(key3, val3)  --> UnMilione 1000000

Il quantificatore ? che segue entrambe le classi di %s è un'aggiunta sicura perché rende lo spazio su entrambi i lati del segno = opzionale. Ciò significa che la corrispondenza ha successo se uno (o entrambi) gli spazi sono mancanti attorno al segno di uguale.

Nella funzione string.gsub(), puoi includere gruppi di cattura nella stringa di sostituzione utilizzando %1, %2, %3, ecc., fino a %9. Anche se Luau supporta fino a 32 gruppi di cattura prima di sollevare un errore, puoi solo fare riferimento ai primi nove con questa sintassi:

local str = "amare2giocare Roblox"
local pattern = "(%w+)(%d+)(%w+)%s+(%w+)"
local replacement = "Io %1 %2 %3 %4!"

local result = string.gsub(str, pattern, replacement)
print(result) --> Io amare 2 giocare Roblox!

Puoi anche annidare le catture delle stringhe:

local places = "Il Regno delle Nuvole è celestiale, Il Regno della Foresta è pacifico"
local pattern = "(Il%s(%a+%sRegno)[%w%s]+)"

for description, kingdom in string.gmatch(places, pattern) do
	print(description)
	print(kingdom)
end
--> Il Regno delle Nuvole è celestiale
--> Regno delle Nuvole
--> Il Regno della Foresta è pacifico
--> Regno della Foresta

Questa ricerca del pattern funziona come segue:

L'iteratore string.gmatch() cerca una corrispondenza sul pattern "descrizione" definito dalla coppia esterna di parentesi. Questo si interrompe alla prima virgola e cattura il seguente:

Usando la sua prima cattura riuscita, l'iteratore cerca quindi una corrispondenza sul pattern "regno" definito dalla coppia interna di parentesi. Questo sotto-pattern cattura semplicemente il seguente:

L'iteratore quindi si tira indietro e continua a cercare nella stringa completa, catturando il seguente:

Oltre a tutto quanto sopra, c'è un caso speciale con una cattura vuota (()). Se una cattura è vuota, allora la posizione nella stringa sarà catturata:

local match1 = "Dove avviene la cattura? Chi lo sa!"
local match2 = "Questa stringa è più lunga della prima. Dove avviene la cattura? Chi lo sa?!"

local pattern = "()Dove avviene la cattura%? Chi lo sa!()"

local start1, finish1 = string.match(match1, pattern)
print(start1, finish1)  --> 1 42

local start2, finish2 = string.match(match2, pattern)
print(start2, finish2)  --> 43 84

Queste catture speciali possono essere annidate come le normali:

local places = "Il Regno delle Nuvole è celestiale, Il Regno della Foresta è pacifico."
local pattern = "Il (%a+()) Regno è %a+"

for kingdom, position in string.gmatch(places, pattern) do
	print(kingdom, position)
end
--> Nuvole 10
--> Foresta 42

I valori restituiti sono insoliti in quanto sono numeri piuttosto che stringhe:

local match = "Questo è un esempio"
local pattern = "Questo è un ()esempio"

local position = string.match(match, pattern)
print(typeof(position))  --> number