Lua Academy · Leçon

La fonction require

Chargez des modules externes avec require et comprenez la mise en cache des modules.

La fonction require est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Fonctionnement de require

require(modname) charge et renvoie un module. Il recherche un fichier .lua dans package.path et une bibliothèque C dans package.cpath. Le résultat est mis en cache dans package.loaded[modname] : les appels suivants renvoient la valeur mise en cache sans réexécuter le fichier.

-- 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

Valeur renvoyée par un module

Un fichier de module doit renvoyer une valeur, généralement une table de fonctions. Cette valeur renvoyée est celle que require transmet à l’appelant. Si le fichier ne renvoie rien (ou true), c’est ce que require renvoie.

-- 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

Mise en cache dans package.loaded

package.loaded est une table qui associe les noms de modules à leurs valeurs chargées. Vous pouvez définir manuellement une entrée pour précharger un simulacre, ou lui attribuer nil pour forcer un rechargement (le fichier du module sera réexécuté au prochain 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

Format de package.path

package.path est une liste de motifs séparés par des points-virgules. L’espace réservé ? est remplacé par le nom du module (les points étant remplacés par des séparateurs de chemin). Vous pouvez ajouter des répertoires de recherche en les ajoutant au début de 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 et loadfile

require : met en cache et recherche dans package.path. dofile(path) : exécute immédiatement un fichier, sans mise en cache, en utilisant un chemin direct. loadfile(path) : compile sans exécuter et renvoie une fonction. Utilisez require pour les modules et dofile pour les scripts ponctuels.

-- 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 avec des points pour les répertoires

Utilisez des points dans les noms de modules pour référencer des fichiers situés dans des sous-répertoires. require("utils.string") correspond à utils/string.lua (avec ? dans le motif de chemin). C’est ainsi que sont organisées les bibliothèques composées de plusieurs fichiers.

-- 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

Effets secondaires de l’initialisation des modules

Les fichiers de module s’exécutent une fois, lors du premier require. Tout code placé au niveau supérieur (en dehors des fonctions) s’exécute au moment du require. Cela est utile pour l’initialisation unique, mais soyez prudent : les effets secondaires tels que les connexions réseau ou les opérations sur des fichiers s’exécutent au moment de l’importation.

-- 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)

Gestion des erreurs dans require

Si un fichier de module contient une erreur de syntaxe ou déclenche une erreur lors de son chargement, require déclenche une erreur. Le message d’erreur inclut le nom du module et l’erreur survenue à l’intérieur du fichier. Utilisez pcall pour gérer correctement les échecs de chargement des modules.

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 est une table dans laquelle vous pouvez enregistrer des fonctions de chargement par nom de module. Lorsque require("name") est appelé, Lua vérifie d'abord le préchargement. Cela vous permet d'enregistrer des modules sans fichiers — ce qui est utile pour Lua intégré ou les tests.

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

Dépendance circulaire

Les dépendances circulaires (A requiert B, B requiert A) sont partiellement gérées : Lua stocke un emplacement réservé true dans package.loaded avant d'exécuter le module. Si B tente d'utiliser la table inachevée de A, il peut obtenir des résultats incomplets. Évitez les dépendances circulaires lors de la conception des modules.

-- 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")

Vérification rapide

Que se passe-t-il lorsque vous appelez require("mod") une deuxième fois ?

Récapitulatif : require

Résumé :

require(name) charge une seule fois et met en cache dans package.loaded
Le fichier du module renvoie son interface publique (généralement une table)
Effacez package.loaded[name] pour forcer le rechargement
Ajoutez des chemins à package.path pour définir des répertoires de recherche personnalisés
Utilisez package.preload pour les modules en mémoire
Évitez les dépendances circulaires

Questions Fréquemment Posées

La leçon « La fonction require » est-elle gratuite ?

Oui — le texte complet de « La fonction require » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « La fonction require » ?

Chargez des modules externes avec require et comprenez la mise en cache des modules. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « La fonction require » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Lua Academy