Lua Academy · Lezione

Ricerca ed estrazione di sottostringhe

Applichi string.find e string.sub per individuare ed estrarre testo.

Ricerca ed estrazione di sottostringhe è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Nozioni di base su string.find

string.find(s, pattern, init, plain) cerca un pattern in s a partire da init (il valore predefinito è 1). Restituisce le posizioni iniziale e finale della corrispondenza, oppure nil se non viene trovata. Con plain=true, tratta il pattern come una stringa letterale, senza caratteri speciali.

local s = "hello world"
local i, j = string.find(s, "world")
print(i, j)    -- 7  11

-- Plain search (literal string)
local i2, j2 = string.find("a+b=5", "+", 1, true)
print(i2, j2)  -- 2  2

-- Not found
print(string.find(s, "xyz"))  -- nil

string.sub per l'estrazione

string.sub(s, i, j) estrae la sottostringa dalla posizione i alla posizione j, estremi inclusi. Gli indici negativi si contano dalla fine: -1 è l'ultimo carattere. Se j viene omesso, il valore predefinito è la fine della stringa.

local s = "hello world"
print(string.sub(s, 1, 5))    -- hello
print(string.sub(s, 7))       -- world
print(string.sub(s, -5))      -- world
print(string.sub(s, 1, -7))   -- hello
print(s:sub(7, 11))           -- world (method syntax)

Combinare find e sub

Combini string.find e string.sub per individuare ed estrarre sottostringhe. Individui prima il delimitatore, quindi estrai le parti che lo precedono e lo seguono. Questo è l'approccio di base per dividere una stringa.

local s = "key=value"
local i = string.find(s, "=")
if i then
  local key = string.sub(s, 1, i - 1)
  local val = string.sub(s, i + 1)
  print(key, val)   -- key  value
end

string.match per acquisire pattern

string.match(s, pattern, init) restituisce le sottostringhe acquisite che corrispondono al pattern. Se il pattern non contiene acquisizioni, restituisce l'intera corrispondenza. Se non viene trovata alcuna corrispondenza, restituisce nil. Le acquisizioni sono definite tramite parentesi nel pattern.

local date = "2024-03-15"
local y, m, d = string.match(date, "(%d+)-(%d+)-(%d+)")
print(y, m, d)   -- 2024  03  15

-- No capture: returns the whole match
local num = string.match("price: 42.5 USD", "%d+%.%d+")
print(num)       -- 42.5

Trovare l'ultima occorrenza

Per trovare l'ultima occorrenza di una sottostringa, esegua una ricerca in un ciclo, facendo avanzare la posizione iniziale, oppure cerchi dalla fine. L'approccio standard consiste nel chiamare ripetutamente string.find con la posizione immediatamente successiva alla corrispondenza precedente, finché non restituisce nil.

local function findLast(s, sub)
  local last_i, last_j
  local i, j = string.find(s, sub, 1, true)
  while i do
    last_i, last_j = i, j
    i, j = string.find(s, sub, j + 1, true)
  end
  return last_i, last_j
end

local i, j = findLast("a/b/c/d", "/")
print(i, j)   -- 6  6

Estrarre le estensioni dei file

Un uso pratico di string.match consiste nell'estrarre l'estensione da un nome di file. Il pattern "([^%.]+)$" acquisisce l'ultima sequenza di caratteri diversi dal punto alla fine della stringa, mentre "%.([^%.]+)$" acquisisce solo la sequenza successiva all'ultimo punto.

local function getExt(filename)
  return string.match(filename, "%.([^%.]+)$")
end

print(getExt("photo.jpg"))        -- jpg
print(getExt("archive.tar.gz"))   -- gz
print(getExt("README"))           -- nil
print(getExt("config.lua.bak"))   -- bak

Dividere le stringhe

Lua non dispone di una funzione integrata per dividere le stringhe, ma può implementarne una con string.gmatch. Iteri su tutte le sequenze che non contengono il delimitatore oppure utilizzi un pattern che acquisisca il testo compreso tra i delimitatori.

local function split(s, sep)
  local result = {}
  local pattern = "([^" .. sep .. "]+)"
  for part in string.gmatch(s, pattern) do
    result[#result+1] = part
  end
  return result
end

local parts = split("one,two,three,four", ",")
for i, p in ipairs(parts) do
  print(i, p)
end
-- 1 one  2 two  3 three  4 four

Rimuovere gli spazi bianchi

Rimuova gli spazi bianchi iniziali e finali individuandoli e scartandoli. Il pattern "^%s*(.-)%s*$" utilizza il quantificatore non avido .- per acquisire il contenuto minimo tra gli eventuali spazi iniziali e finali.

local function trim(s)
  return string.match(s, "^%s*(.-)%s*$")
end

print("|" .. trim("  hello  ") .. "|")  -- |hello|
print("|" .. trim("  \t\n") .. "|")    -- ||
print("|" .. trim("no spaces") .. "|")  -- |no spaces|

Estrarre numeri dal testo

Utilizzi string.gmatch con un pattern per numeri per estrarre tutti i numeri da una stringa. Il pattern %-?%d+%.?%d* corrisponde a un segno negativo facoltativo, alle cifre, a un punto decimale facoltativo e ad altre cifre.

local text = "Revenue: $1,234.56 Expenses: $567.89 Net: $666.67"
local numbers = {}
for n in string.gmatch(text, "%d+%.?%d*") do
  numbers[#numbers+1] = tonumber(n)
end
for _, v in ipairs(numbers) do
  io.write(v .. " ")
end
print()  -- 1 234.0 56.0 567.89 666.67

Normalizzazione delle posizioni nelle stringhe

Gli indici negativi di Lua consentono di lavorare a partire dalla fine di una stringa. string.sub(s, -n) restituisce gli ultimi n caratteri. Combini questa funzione con #s per calcolare le posizioni. Comprendere il rapporto tra indici positivi e negativi aiuta a prevenire gli errori di tipo off-by-one.

local s = "abcdefgh"

-- Last 3 characters
print(s:sub(-3))     -- fgh

-- All but last 2
print(s:sub(1, -3))  -- abcdef

-- Character at position from end
print(s:sub(-1, -1)) -- h
print(s:sub(-4, -2)) -- efg

Verifica rapida

Che cosa restituisce string.sub("hello", 2, -2)?

Riepilogo: ricerca ed estrazione

Riepilogo:

string.find(s, pat, init, plain) — restituisce inizio, fine oppure nil
string.sub(s, i, j) — estrae in base alla posizione; gli indici negativi partono dalla fine
string.match(s, pat) — restituisce le acquisizioni oppure l'intera corrispondenza
Utilizzi plain=true per una ricerca letterale, senza caratteri speciali
Implementi la divisione con string.gmatch
Per rimuovere gli spazi, utilizzi il pattern "^%s*(.-)%s*$"

Domande Frequenti

La lezione «Ricerca ed estrazione di sottostringhe» è gratuita?

Sì — il testo completo di «Ricerca ed estrazione di sottostringhe» è 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 «Ricerca ed estrazione di sottostringhe»?

Applichi string.find e string.sub per individuare ed estrarre testo. 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 2 di 4.

Quanto tempo richiede la lezione «Ricerca ed estrazione di sottostringhe»?

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