Lua Academy · Lezione

Nozioni di base sulle stringhe: concatenazione e lunghezza

Q: La lezione «Nozioni di base sulle stringhe: concatenazione e lunghezza» è gratuita?

Sì — il testo completo di «Nozioni di base sulle stringhe: concatenazione e lunghezza» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Q: Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Q: Quanto tempo richiede la lezione «Nozioni di base sulle stringhe: concatenazione e lunghezza»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Q: Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Utilizzi .. per la concatenazione, # per la lunghezza e string.rep/reverse.

Nozioni di base sulle stringhe: concatenazione e lunghezza è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Concatenazione di stringhe con ..

Lua usa .. (due punti) per la concatenazione di stringhe. Funziona con stringhe e numeri (i numeri vengono convertiti automaticamente). A differenza di + in molti linguaggi, in Lua + è esclusivamente aritmetico: usare + sulle stringhe causa un errore.

local first = "Hello"
local second = "World"
print(first .. ", " .. second .. "!")  -- Hello, World!

-- Numbers auto-converted
local age = 30
print("Age: " .. age)   -- Age: 30

-- Bad: print("x" + "y")  ERROR: arithmetic on string

Operatore di lunghezza #

L'operatore # restituisce la lunghezza in byte di una stringa. Per le stringhe ASCII, coincide con il numero di caratteri. Per le stringhe UTF-8 multibyte, # conta i byte, non i caratteri: un'emoji UTF-8 conta come 4. Usi una libreria UTF-8 per ottenere lunghezze accurate in caratteri.

print(#"hello")        -- 5
print(#"")             -- 0
print(#"café")         -- 5 (c,a,f,é=2bytes)

local s = "Lua"
for i = 1, #s do
  io.write(string.byte(s, i) .. " ")
end
print()  -- 76 117 97

string.rep e string.reverse

string.rep(s, n, sep) ripete la stringa s esattamente n volte, usando un separatore facoltativo. string.reverse(s) inverte l'ordine dei byte della stringa. Entrambe restituiscono nuove stringhe: le stringhe Lua sono immutabili.

print(string.rep("ab", 3))       -- ababab
print(string.rep("ha", 3, "-"))  -- ha-ha-ha
print(string.rep("x", 0))        -- (empty)
print(string.reverse("hello"))   -- olleh
print(string.reverse("12345"))   -- 54321

string.upper e string.lower

string.upper(s) e string.lower(s) convertono i caratteri ASCII. Non gestiscono Unicode: i caratteri non ASCII restano invariati. Per un confronto senza distinzione tra maiuscole e minuscole, converta entrambe le stringhe in minuscolo prima del confronto.

print(string.upper("hello"))     -- HELLO
print(string.lower("WORLD"))     -- world
print(string.upper("Lua 5.4!"))  -- LUA 5.4!

-- Case-insensitive comparison
local a = "Hello"
local b = "hello"
print(a:lower() == b:lower())    -- true

Sintassi dei metodi con i due punti

Le funzioni per le stringhe possono essere chiamate usando la sintassi con i due punti sui valori stringa: s:upper() invece di string.upper(s). Questo funziona perché le stringhe hanno una metatabella con __index = string, quindi tutte le funzioni della libreria per le stringhe sono accessibili come metodi su qualsiasi stringa.

local s = "  hello world  "
print(s:upper())         -- HELLO WORLD
print(s:len())           -- 15
print(s:rep(2, "|"))     -- same as string.rep(s,2,"|")

-- Chain calls
print(("lua"):upper():reverse())  -- AUL

Immutabilità delle stringhe

Le stringhe Lua sono immutabili. Non è possibile modificare i caratteri direttamente. Ogni operazione su una stringa crea una nuova stringa. Per concatenazioni intensive all'interno di cicli, usi una tabella per accumulare le parti e table.concat alla fine: è molto più efficiente delle concatenazioni ripetute con ...

-- Efficient string building
local parts = {}
for i = 1, 5 do
  parts[i] = "item" .. i
end
local result = table.concat(parts, ", ")
print(result)  -- item1, item2, item3, item4, item5

-- Slow! Creates 5 intermediate strings:
-- local s = ""
-- for i = 1, 5 do s = s .. "item" .. i end

table.concat per unire stringhe

table.concat(t, sep, i, j) unisce gli elementi di un array in una stringa usando un separatore. Funziona solo con valori stringa e numerici: tabelle o booleani causano un errore. È il modo più veloce per creare stringhe a partire da molte parti.

local parts = {"one", "two", "three", "four"}
print(table.concat(parts, ", "))          -- one, two, three, four
print(table.concat(parts, " | ", 2, 3))  -- two | three

-- Building CSV
local row = {1, "Alice", 95, true}
-- Need tostring for non-string values:
for i, v in ipairs(row) do row[i] = tostring(v) end
print(table.concat(row, ","))

Confronto tra stringhe

Le stringhe vengono confrontate lessicograficamente in base al valore dei byte. Le lettere maiuscole vengono prima delle minuscole in ASCII (A=65, a=97), quindi "Z" < "a" è vero. Usi string.lower su entrambi gli operandi per un ordinamento senza distinzione tra maiuscole e minuscole.

print("abc" < "abd")    -- true
print("abc" < "abcd")   -- true (shorter)
print("Z" < "a")        -- true (Z=90, a=97)
print("10" < "9")       -- true (lexicographic!)
print(10 < 9)           -- false (numeric)

-- Sort strings case-insensitively
local words = {"Banana","apple","Cherry"}
table.sort(words, function(a,b) return a:lower()<b:lower() end)
print(table.concat(words,", "))

tostring e tonumber

tostring(v) converte qualsiasi valore nella relativa rappresentazione in stringa. tonumber(s, base) analizza una stringa e la converte in un numero. tonumber restituisce nil se l'analisi non riesce, a differenza di molti linguaggi che generano un'eccezione. Per l'analisi di interi, la base può essere compresa tra 2 e 36.

print(tostring(42))        -- 42
print(tostring(true))      -- true
print(tostring(nil))       -- nil
print(tostring({1,2}))     -- table: 0x...

print(tonumber("3.14"))    -- 3.14
print(tonumber("0xff"))    -- 255 (hex)
print(tonumber("11",2))    -- 3 (binary)
print(tonumber("abc"))     -- nil (invalid)

Internamento delle stringhe

Lua sottopone a internamento le stringhe brevi: le stringhe con contenuto identico condividono lo stesso oggetto in memoria. Di conseguenza, dopo un controllo dell'hash, l'operatore == sulle stringhe equivale di fatto a un confronto di puntatori, quindi è molto veloce. L'internamento comporta anche un piccolo costo quando si crea una stringa, dovuto al calcolo dell'hash, ma le stringhe ripetute non comportano costi aggiuntivi.

local s1 = "hello"
local s2 = "hel" .. "lo"

-- Same content, interned to same object
print(s1 == s2)   -- true
print(#s1)        -- 5

-- Long strings may not be interned
-- They are still compared correctly by value
local long1 = string.rep("x", 1000)
local long2 = string.rep("x", 1000)
print(long1 == long2)  -- true

Verifica rapida

Qual è il modo più efficiente per creare una stringa lunga a partire da molte parti piccole in Lua?

Riepilogo: nozioni di base sulle stringhe

Punti chiave:

.. concatena le stringhe; non utilizzi mai + con le stringhe
#s conta i byte, non i caratteri Unicode
s:upper(), s:lower(), s:rep(n, sep), s:reverse()
Le stringhe sono immutabili: ogni operazione restituisce una nuova stringa
Crei le stringhe grandi con una tabella e table.concat
tostring/tonumber per la conversione dei tipi

Domande Frequenti

La lezione «Nozioni di base sulle stringhe: concatenazione e lunghezza» è gratuita?

Sì — il testo completo di «Nozioni di base sulle stringhe: concatenazione e lunghezza» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Nozioni di base sulle stringhe: concatenazione e lunghezza»?

Utilizzi .. per la concatenazione, # per la lunghezza e string.rep/reverse. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Nozioni di base sulle stringhe: concatenazione e lunghezza»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Nozioni di base sulle stringhe: concatenazione e lunghezza
Ricerca ed estrazione di sottostringhe
string.format per l'output
string.gsub e string.gmatch

← Torna a Lua Academy