Lua Academy · Lezione

La funzione require

Carichi moduli esterni con require e comprenda la memorizzazione nella cache dei moduli.

La funzione require è 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.

Come funziona require

require(modname) carica e restituisce un modulo. Cerca un file .lua in package.path e una libreria C in package.cpath. Il risultato viene memorizzato nella cache in package.loaded[modname]: le chiamate successive restituiscono il valore memorizzato senza eseguire nuovamente il file.

-- First require: loads and executes math_utils.lua
local math_utils = require("math_utils")

-- Second require: returns cached value (file not re-run)
local math_utils2 = require("math_utils")

print(math_utils == math_utils2)   -- true (same object)
print(package.loaded["math_utils"] == math_utils)  -- true

Valore restituito dal modulo

Un file di modulo dovrebbe restituire un valore, in genere una tabella di funzioni. Questo valore restituito è ciò che require restituisce al chiamante. Se il file non restituisce nulla (oppure restituisce true), è questo il valore restituito da require.

-- mymodule.lua:
-- local M = {}
-- function M.hello() print("Hello from module!") end
-- return M

-- In main script:
local m = require("mymodule")
m.hello()   -- Hello from module!

-- The module table is the interface

Memorizzazione nella cache con package.loaded

package.loaded è una tabella che associa i nomi dei moduli ai relativi valori caricati. Può impostare manualmente una voce per precaricare un mock oppure impostarla su nil per forzare un nuovo caricamento (il file del modulo verrà eseguito nuovamente alla chiamata successiva a require).

-- Force reload by clearing cache
package.loaded["mymodule"] = nil
local fresh = require("mymodule")  -- re-executes the file

-- Preload a mock for testing
package.loaded["db"] = {
  query = function() return {} end,
  close = function() end,
}
local db = require("db")  -- gets the mock

Formato di package.path

package.path è un elenco di schemi separati da punti e virgola. Il segnaposto ? viene sostituito dal nome del modulo (con i punti sostituiti dai separatori di percorso). Può aggiungere directory di ricerca anteponendole a package.path.

print(package.path)
-- typically: ./?.lua;./?.luac;/usr/share/lua/5.4/?.lua;...

-- Add local lib directory
package.path = "./lib/?.lua;" .. package.path

-- Now require("utils") will look in ./lib/utils.lua

require, dofile e loadfile a confronto

require: usa la cache e cerca in package.path. dofile(path): esegue immediatamente un file, senza usare la cache, e accetta un percorso diretto. loadfile(path): compila il file senza eseguirlo e restituisce una funzione. Usi require per i moduli e dofile per gli script eseguiti una sola volta.

-- dofile: no caching, direct path
dofile("./scripts/setup.lua")

-- loadfile: compile only, returns function
local fn, err = loadfile("./config.lua")
if fn then
  local result = fn()   -- execute when ready
end

-- require: best for modules
local json = require("json")

require con i punti per le directory

Usi i punti nei nomi dei moduli per fare riferimento ai file nelle sottodirectory. require("utils.string") corrisponde a utils/string.lua (con ? nello schema del percorso). È così che vengono organizzate le librerie composte da più file.

-- Directory structure:
-- lib/
--   utils/
--     string.lua
--     table.lua
--   init.lua

package.path = "./lib/?.lua;" .. package.path

local strUtils = require("utils.string")   -- loads lib/utils/string.lua
local tblUtils = require("utils.table")    -- loads lib/utils/table.lua

Effetti collaterali dell'inizializzazione dei moduli

I file dei moduli vengono eseguiti una sola volta, quando vengono richiesti per la prima volta. Qualsiasi codice al livello superiore (fuori dalle funzioni) viene eseguito al momento di require. È utile per l'inizializzazione una tantum, ma presti attenzione: gli effetti collaterali, come le connessioni di rete o le operazioni sui file, vengono eseguiti al momento dell'importazione.

-- counter.lua:
-- local count = 0   -- initialized once on first require
-- local M = {}
-- function M.increment() count = count + 1 end
-- function M.get() return count end
-- return M

local c = require("counter")
c.increment()
c.increment()
print(c.get())   -- 2

local c2 = require("counter")
print(c2.get())  -- 2 (same instance, cached)

Gestione degli errori in require

Se un file di modulo contiene un errore di sintassi o genera un errore durante il caricamento, require genera un errore. Il messaggio include il nome del modulo e l'errore verificatosi all'interno del file. Usi pcall per gestire correttamente gli errori di caricamento dei moduli.

local ok, mod = pcall(require, "possibly_missing")
if not ok then
  print("Module not available:", mod)
  -- fall back to alternative or default implementation
  mod = {feature = function() return "fallback" end}
end

print(mod.feature())

package.preload

package.preload è una tabella in cui è possibile registrare funzioni di caricamento associate al nome del modulo. Quando viene chiamato require("name"), Lua controlla prima la tabella di preload. In questo modo è possibile registrare moduli senza file: è utile per Lua incorporato o per i test.

package.preload["mymath"] = function()
  return {
    double = function(n) return n * 2 end,
    triple = function(n) return n * 3 end,
  }
end

local m = require("mymath")
print(m.double(5))   -- 10
print(m.triple(5))   -- 15

Require circolare

Le dipendenze circolari (A richiede B, B richiede A) vengono gestite solo parzialmente: prima di eseguire il modulo, Lua memorizza un segnaposto true in package.loaded. Se B prova a usare la tabella non ancora completata di A, potrebbe ottenere risultati incompleti. Eviti le dipendenze circolari nella progettazione dei moduli.

-- a.lua: local b = require("b"); local M = {}; M.name = "A"; return M
-- b.lua: local a = require("a"); print("a.name:", a.name); return {}

-- When a.lua is loaded:
-- 1. a starts executing
-- 2. requires b -> b starts executing
-- 3. b requires a -> gets partial a (still loading!)
-- 4. a.name may be nil at step 3

print("Avoid circular requires in module design")

Verifica rapida

Che cosa succede quando si chiama require("mod") una seconda volta?

Riepilogo: require

Riepilogo:

require(name) carica il modulo una sola volta e lo memorizza nella cache in package.loaded
Il file del modulo restituisce la propria interfaccia pubblica (di solito una tabella)
Si cancelli package.loaded[name] per forzare un nuovo caricamento
Aggiunga percorsi di ricerca personalizzati a package.path
Usi package.preload per i moduli in memoria
Eviti le dipendenze circolari

Domande Frequenti

La lezione «La funzione require» è gratuita?

Sì — il testo completo di «La funzione require» è 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 «La funzione require»?

Carichi moduli esterni con require e comprenda la memorizzazione nella cache dei moduli. 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 «La funzione require»?

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

← Torna a Lua Academy