Lua Academy · Leçon

La fonction error()

Déclenchez des erreurs avec error() et comprenez les niveaux et les messages d’erreur.

La fonction error() 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.

Lever des erreurs

error(message, level) lève une erreur Lua. L’exécution s’arrête et l’erreur remonte la pile d’appels jusqu’à ce qu’elle soit interceptée par pcall ou xpcall, ou jusqu’à l’arrêt du programme. Le message peut être n’importe quelle valeur : chaîne, table ou nombre.

local function divide(a, b)
  if b == 0 then
    error("division by zero")
  end
  return a / b
end

print(divide(10, 2))    -- 5.0
-- divide(10, 0)        -- ERROR: division by zero

Niveaux d’erreur

Le deuxième argument de error() détermine l’emplacement signalé pour l’erreur. Le niveau 1 (par défaut) pointe vers l’appel à error(). Le niveau 2 pointe vers l’appelant. Le niveau 0 n’ajoute aucune information de position. Utilisez le niveau 2 dans les bibliothèques pour que l’erreur soit attribuée au code de l’utilisateur.

local function assertPositive(n, name)
  if n <= 0 then
    error((name or "value") .. " must be positive, got " .. n, 2)
    -- level 2: blame the caller, not this function
  end
  return n
end

local function compute(x)
  assertPositive(x, "x")   -- error points here if x <= 0
  return math.sqrt(x)
end

compute(-5)  -- error: "x must be positive, got -5" at compute() call

Erreur avec des objets table

Transmettre une table comme valeur d’erreur permet aux appelants d’examiner des informations structurées : code d’erreur, message et contexte. Cette solution est plus informative qu’une simple chaîne et permet une gestion programmatique des erreurs.

local function openDB(host, port)
  if port < 1 or port > 65535 then
    error({code="INVALID_PORT", port=port,
           msg="port out of range: " .. port})
  end
  -- ... connect
  return {host=host, port=port}
end

local ok, err = pcall(openDB, "localhost", -1)
if not ok and type(err) == "table" then
  print("Code:", err.code)    -- INVALID_PORT
  print("Port:", err.port)    -- -1
  print("Msg:", err.msg)
end

assert() comme forme abrégée

assert(v, msg) équivaut à if not v then error(msg, 2) end; return v, .... Cette fonction est idiomatique pour vérifier les préconditions. Si v est évalué comme vrai, assert renvoie tous ses arguments (ce qui est utile pour les enchaîner).

local function sqrt(n)
  assert(type(n) == "number", "expected number, got " .. type(n))
  assert(n >= 0, "sqrt of negative: " .. n)
  return math.sqrt(n)
end

print(sqrt(16))    -- 4.0
print(sqrt(2))     -- 1.4142...
-- sqrt("hi")      -- ERROR: expected number, got string

error() contre return nil,err

Deux conventions permettent de signaler un échec : error() (style exception) ou return nil, msg (style fonctionnel). Utilisez error() pour les situations réellement inattendues (erreurs de programmation, violations de contrat). Utilisez nil, msg pour les échecs attendus (fichier introuvable, délai d’attente du réseau).

-- Exception style (programming error)
local function mustExist(t, key)
  local v = t[key]
  if v == nil then error("required key missing: " .. key, 2) end
  return v
end

-- Functional style (expected failure)
local function findUser(id)
  -- ... database query
  return nil, "user not found"  -- expected: user may not exist
end

Erreur dans les métaméthodes

Des erreurs peuvent être levées à l’intérieur des métaméthodes. Si une métaméthode provoque une erreur, celle-ci se propage jusqu’au code qui a déclenché l’opération (par exemple une expression arithmétique). Protégez toujours les métaméthodes contre les entrées non valides.

local SafeDiv = {}
SafeDiv.__index = SafeDiv

SafeDiv.__div = function(a, b)
  if b.value == 0 then
    error("SafeDiv: division by zero", 2)
  end
  return SafeDiv.new(a.value / b.value)
end

function SafeDiv.new(v)
  return setmetatable({value=v}, SafeDiv)
end

local a = SafeDiv.new(10)
local b = SafeDiv.new(0)
local ok, err = pcall(function() return a / b end)
print(ok, err)

Types d’erreurs personnalisés

Créez un utilitaire pour construire des objets d’erreur typés. Incluez une balise de type afin que les appelants puissent distinguer les différents types d’erreurs et traiter chacune de manière appropriée.

local function newError(kind, msg, extra)
  return setmetatable(
    {kind=kind, message=msg, extra=extra},
    {__tostring = function(e)
      return "[" .. e.kind .. "] " .. e.message
    end}
  )
end

local E = {
  notFound = function(name) return newError("NOT_FOUND","not found: "..name) end,
  badInput = function(msg)  return newError("BAD_INPUT", msg) end,
}

local ok, err = pcall(error, E.notFound("config.json"))
if not ok then print(err.kind, err.message) end

Propagation des erreurs

Lorsqu’une fonction en appelle une autre qui génère une erreur, celle-ci se propage automatiquement dans la pile d’appels. Vous n’avez pas besoin de la relancer : ne l’interceptez simplement pas. Interceptez les erreurs uniquement au niveau où vous pouvez réellement les traiter ou les signaler.

local function step3() error("step3 failed") end
local function step2() step3() end
local function step1() step2() end

local ok, err = pcall(step1)
if not ok then
  -- err includes the source location
  print("Caught at top level:", err)
end
-- Error: input:1: step3 failed

Trace de pile avec debug.traceback

Un simple error() fournit une seule ligne de contexte. Pour obtenir une trace de pile complète, utilisez debug.traceback(msg) comme valeur d’erreur. Cela se fait généralement dans un gestionnaire xpcall.

local function buggy()
  local t = nil
  return t.field   -- nil indexing: error
end

local ok, err = xpcall(buggy, function(e)
  return debug.traceback(e, 2)  -- full stack trace
end)

if not ok then
  print(err)  -- full traceback
end

Relancer des erreurs

Il vous arrive de capturer une erreur pour y ajouter du contexte, puis de la relancer. Utilisez error(err, 0) (niveau 0) lors de la relance d’une erreur sous forme de chaîne, afin d’éviter d’ajouter un autre préfixe d’emplacement à un message déjà formaté.

local function loadAndParse(path)
  local ok, err = pcall(function()
    local f = io.open(path, "r")
    if not f then error("cannot open: " .. path) end
    local content = f:read("a")
    f:close()
    return content
  end)
  if not ok then
    error("loadAndParse failed: " .. err, 0)  -- re-raise with context
  end
end

local ok2, msg = pcall(loadAndParse, "missing.txt")
print(ok2, msg)

Vérification rapide

Que signifie le niveau 2 dans error("msg", 2) ?

Récapitulatif : error()

Résumé :

error(msg, level) — déclenche une erreur ; le niveau 2 désigne l’appelant comme responsable
Utilisez des tables pour les erreurs structurées avec un type et du contexte
assert(v, msg) — vérification idiomatique d’une précondition
Utilisez error() pour les bogues ; renvoyez nil+err pour les échecs attendus
Relancez avec error(err, 0) pour préserver le format du message

Questions Fréquemment Posées

La leçon « La fonction error() » est-elle gratuite ?

Oui — le texte complet de « La fonction error() » 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 error() » ?

Déclenchez des erreurs avec error() et comprenez les niveaux et les messages d’erreur. 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 error() » ?

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