0Pricing
Lua Academy · Leçon

Fermer des fichiers et gérer les erreurs

Fermez correctement les descripteurs de fichiers et gérez les erreurs d’E/S avec pcall.

Fermer des fichiers et gérer les erreurs est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Toujours fermer les fichiers

Tout fichier ouvert avec io.open doit être fermé avec f:close(). Les fichiers non fermés entraînent une fuite de descripteurs de fichiers. Le ramasse-miettes de Lua finira par les fermer, mais vous pouvez atteindre les limites de fichiers du système d’exploitation avant son exécution. Fermez toujours le fichier dans la fonction qui l’a ouvert.

local function readFile(path)
  local f, err = io.open(path, "r")
  if not f then return nil, err end
  local content = f:read("a")
  f:close()   -- always close
  return content
end

local data, err = readFile("config.txt")
if not data then print("Error:", err) end

pcall pour sécuriser les entrées-sorties

Entourez les opérations sur les fichiers de pcall pour intercepter les erreurs inattendues (disque plein, refus d’autorisation pendant l’écriture). Vous pourrez ainsi gérer les erreurs correctement au lieu de faire planter le programme.

local function safeCopy(src, dst)
  local ok, err = pcall(function()
    local f = io.open(src, "rb")
    if not f then error("Cannot open source: " .. src) end
    local content = f:read("a")
    f:close()
    local g = io.open(dst, "wb")
    if not g then error("Cannot open dest: " .. dst) end
    g:write(content)
    g:close()
  end)
  return ok, err
end

local ok, msg = safeCopy("input.txt", "output.txt")
if not ok then print("Failed:", msg) end

Vérifier la réussite de l’écriture

Sur les systèmes dont le disque est plein ou qui rencontrent des problèmes d’autorisation, f:write() peut échouer même si io.open a réussi. Vérifiez la valeur renvoyée par les opérations d’écriture dans les chemins d’exécution critiques.

local f = io.open("important.txt", "w")
if not f then
  print("Cannot create file")
  return
end

local ok, err = f:write("critical data\n")
if not ok then
  print("Write failed:", err)
  f:close()
  return
end

f:close()
print("Saved successfully")

Modèle finally avec pcall

Lua ne possède pas de bloc finally, mais vous pouvez le simuler avec pcall. Entourez le code risqué de pcall ; après le retour de pcall (en cas de succès ou d’échec), exécutez systématiquement le code de nettoyage avant de relancer ou de gérer l’erreur.

local function withFile(path, mode, fn)
  local f, err = io.open(path, mode)
  if not f then return nil, err end
  local ok, result = pcall(fn, f)
  f:close()   -- always close, even on error
  if not ok then
    return nil, result
  end
  return result
end

local content, err = withFile("data.txt", "r", function(f)
  return f:read("a")
end)
print(content or err)

Messages d’erreur de io.open

io.open renvoie nil accompagné d’un message d’erreur système et d’un code d’erreur. Le message contient le chemin et la raison de l’erreur du système d’exploitation (« fichier introuvable », « autorisation refusée », etc.). Incluez toujours le message d’erreur dans le rapport présenté à l’utilisateur.

local paths = {"config.txt", "missing.txt", "/root/secret.txt"}

for _, path in ipairs(paths) do
  local f, err, code = io.open(path, "r")
  if f then
    print(path, "-> ok, size:", f:seek("end"))
    f:close()
  else
    print(path, "-> ERROR:", err, "(code "..tostring(code)..")")
  end
end

La référence de fichier comme objet

Une référence de fichier Lua est une donnée utilisateur dotée de méthodes. Lorsque la référence est récupérée par le ramasse-miettes, le fichier est automatiquement fermé. Toutefois, ne comptez pas sur le ramasse-miettes pour fermer rapidement le fichier : fermez-le toujours explicitement. Vous pouvez vérifier si un fichier est fermé avec f:read() ; cette opération provoque une erreur sur une référence fermée.

local f = io.open("test.txt", "w")
f:write("test\n")

-- Explicit close
f:close()

-- After close, operations fail
local ok, err = pcall(function()
  f:read()   -- attempt to use closed file
end)
print(ok, err)   -- false  [closed file]

Modèle de traitement sécurisé des fichiers

Voici un modèle réutilisable pour traiter les fichiers en toute sécurité : ouvrir avec vérification de l’erreur, traiter avec pcall, puis fermer dans tous les cas. Renvoyez les résultats et les erreurs de manière cohérente en utilisant la convention nil+message.

local function processFile(path, processor)
  local f, err = io.open(path, "r")
  if not f then return nil, "open failed: " .. err end
  
  local ok, result = pcall(processor, f)
  f:close()
  
  if not ok then
    return nil, "processing failed: " .. result
  end
  return result
end

local lineCount, err = processFile("data.txt", function(f)
  local n = 0
  for _ in f:lines() do n = n + 1 end
  return n
end)
print(lineCount or err)

os.remove et os.rename

os.remove(path) supprime un fichier. os.rename(old, new) renomme ou déplace un fichier. Les deux fonctions renvoient true en cas de succès ou nil, errMessage en cas d’échec. Ce sont les principales fonctions de manipulation du système de fichiers dans Lua standard.

-- Delete a file
local ok, err = os.remove("temp.txt")
if not ok then print("Remove failed:", err) end

-- Rename / move
ok, err = os.rename("old_name.txt", "new_name.txt")
if not ok then print("Rename failed:", err) end

-- Atomic update pattern
os.rename("config.new", "config.txt")

io.close et f:close

io.close(f) est équivalent à f:close(). io.close() sans argument ferme le fichier de sortie par défaut. Dans la plupart des codes, utilisez f:close() pour plus de clarté.

local f = io.open("test.txt", "w")
f:write("hello\n")

-- Both are equivalent:
-- f:close()
io.close(f)

-- io.close() with no arg closes default output
io.output("out.txt")
io.write("to file\n")
io.close()   -- closes out.txt, restores stdout

Copie de fichiers robuste

Une copie de fichier de qualité production avec gestion des erreurs à chaque étape : ouvrir la source, ouvrir la destination, copier par blocs, gérer les erreurs d’écriture et fermer les deux fichiers.

local function copyFile(src, dst, chunkSize)
  chunkSize = chunkSize or 65536
  local fsrc, err1 = io.open(src, "rb")
  if not fsrc then return nil, err1 end
  local fdst, err2 = io.open(dst, "wb")
  if not fdst then fsrc:close(); return nil, err2 end
  
  local ok = true
  local chunk = fsrc:read(chunkSize)
  while chunk and ok do
    local w, werr = fdst:write(chunk)
    if not w then ok = false; err2 = werr end
    chunk = fsrc:read(chunkSize)
  end
  fsrc:close(); fdst:close()
  if not ok then os.remove(dst); return nil, err2 end
  return true
end

Vérification rapide

Quelle est la meilleure manière de garantir qu’un fichier est toujours fermé en Lua, même si une erreur se produit ?

Récapitulatif : fermeture et gestion des erreurs

Résumé :

  • Appelez toujours explicitement f:close() ; ne comptez pas sur le ramasse-miettes
  • Entourez les entrées-sorties de pcall pour une gestion robuste des erreurs
  • Utilisez le modèle « ouvrir → pcall → fermer »
  • os.remove / os.rename pour les opérations sur le système de fichiers
  • Vérifiez les valeurs renvoyées par les écritures dans le code critique

Questions Fréquemment Posées

La leçon « Fermer des fichiers et gérer les erreurs » est-elle gratuite ?

Oui — le texte complet de « Fermer des fichiers et gérer les erreurs » 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 « Fermer des fichiers et gérer les erreurs » ?

Fermez correctement les descripteurs de fichiers et gérez les erreurs d’E/S avec pcall. 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 4 sur 4.

Combien de temps prend la leçon « Fermer des fichiers et gérer les erreurs » ?

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

  1. Ouvrir des fichiers avec io.open
  2. Lire le contenu de fichiers
  3. Écrire dans des fichiers et y ajouter du contenu
  4. Fermer des fichiers et gérer les erreurs
← Retour à Lua Academy