0Pricing
Lua Academy · Leçon

Écrire dans des fichiers et y ajouter du contenu

Écrivez des chaînes dans des fichiers et ajoutez des données sans écraser le contenu existant.

Écrire dans des fichiers et y ajouter du contenu est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Bases de f:write()

f:write(...) écrit une ou plusieurs chaînes (ou nombres) dans le fichier. Les sauts de ligne ne sont pas ajoutés automatiquement. Renvoie la référence du fichier en cas de succès (ce qui permet l’enchaînement), ou nil, errMessage, errCode en cas d’échec.

local f = io.open("output.txt", "w")
if f then
  f:write("Hello, ")
  f:write("World")
  f:write("!\n")
  f:write("Line 2\n")
  f:close()
end

Écrire plusieurs valeurs

f:write() accepte plusieurs arguments et les écrit tous séquentiellement. Les valeurs doivent être des chaînes ou des nombres ; transmettre d’autres types provoque une erreur. Utilisez tostring() pour convertir des booléens, des tables, etc.

local f = io.open("log.txt", "w")
f:write("Name: ", "Alice", "\n")
f:write("Age: ", 30, "\n")
f:write("Score: ", string.format("%.1f", 95.5), "\n")
f:close()

Écriture formatée

Combinez string.format avec f:write pour produire une sortie précise. Ce modèle est courant pour générer des rapports, des fichiers de journalisation et des exportations de données avec des exigences de formatage spécifiques.

local data = {
  {name="Alice", score=95, grade="A"},
  {name="Bob",   score=87, grade="B"},
}

local f = io.open("report.txt", "w")
f:write(string.format("%-12s  %5s  %s\n","Name","Score","Grade"))
f:write(string.rep("-",25) .. "\n")
for _, r in ipairs(data) do
  f:write(string.format("%-12s  %5d  %s\n",r.name,r.score,r.grade))
end
f:close()

Mode ajout

Le mode "a" écrit toujours à la fin du fichier. La position de lecture se trouve au début, mais les écritures sont toujours effectuées à la fin. Utilisez ce mode pour les journaux, les pistes d’audit et tout fichier auquel vous souhaitez ajouter du contenu sans l’effacer.

local function appendLog(msg)
  local f = io.open("app.log", "a")
  if f then
    local ts = os.date("%Y-%m-%d %H:%M:%S")
    f:write(string.format("[%s] %s\n", ts, msg))
    f:close()
  end
end

appendLog("Server started")
appendLog("User logged in: Alice")
appendLog("Request processed")

f:flush() et la mise en mémoire tampon

Les entrées-sorties de fichiers en Lua utilisent une mémoire tampon. Les données écrites avec f:write() peuvent rester dans cette mémoire avant d’être écrites sur le disque. f:flush() force l’écriture de la mémoire tampon sur le disque sans fermer le fichier. Effectuez toujours cette opération avant qu’un autre processus ne doive voir les données.

local f = io.open("stream.txt", "w")
for i = 1, 5 do
  f:write("Line " .. i .. "\n")
  f:flush()   -- ensure each line is on disk
  -- simulate work
end
f:close()

Écrire des données binaires

En mode d’écriture binaire ("wb"), écrivez les octets bruts avec string.char(). C’est ainsi que vous créez des formats de fichiers binaires, des images ou des messages de protocole. Utilisez string.pack (Lua 5.3 ou version ultérieure) pour les données binaires structurées.

local f = io.open("bytes.bin", "wb")
if f then
  -- Write raw bytes
  f:write(string.char(0xFF, 0x00, 0xAB, 0xCD))
  -- Write a 4-byte little-endian integer (Lua 5.3+)
  f:write(string.pack("<I4", 12345))
  f:close()
  print("Written binary file")
end

io.write et f:write

io.write() écrit vers la sortie par défaut actuelle (initialement stdout). f:write() écrit vers une référence de fichier spécifique. Contrairement à print(), aucune de ces fonctions n’ajoute de saut de ligne ni de séparateurs de tabulation, ce qui vous donne un contrôle total sur le format de la sortie.

-- io.write to stdout
io.write("Enter name: ")
-- (would read input here)

-- f:write to file
local f = io.open("out.txt", "w")
f:write("No auto newline")
f:write(" appended directly")
f:write("\n")  -- explicit newline
f:close()

-- print adds tabs and newline automatically
print("a", "b", "c")   -- a  b  c (tab-separated)

Modèle d’écriture atomique

Pour garantir la sécurité, écrivez dans un fichier temporaire, puis renommez-le. Cela évite que le fichier de sortie reste partiellement écrit. Si le processus s’arrête au milieu de l’écriture, le fichier d’origine reste intact.

local function atomicWrite(path, content)
  local tmp = path .. ".tmp"
  local f, err = io.open(tmp, "w")
  if not f then return nil, err end
  f:write(content)
  f:close()
  -- os.rename is atomic on most filesystems
  local ok, err2 = os.rename(tmp, path)
  if not ok then
    os.remove(tmp)
    return nil, err2
  end
  return true
end

Écrire des tables au format CSV

Sérialisez une table d’enregistrements au format CSV : écrivez une ligne d’en-tête, puis une ligne par enregistrement, en convertissant toutes les valeurs en chaînes et en les joignant par des virgules.

local function writeCSV(path, headers, rows)
  local f = io.open(path, "w")
  if not f then return end
  f:write(table.concat(headers, ",") .. "\n")
  for _, row in ipairs(rows) do
    local fields = {}
    for _, h in ipairs(headers) do
      fields[#fields+1] = tostring(row[h] or "")
    end
    f:write(table.concat(fields, ",") .. "\n")
  end
  f:close()
end

writeCSV("data.csv",
  {"name","age","score"},
  {{name="Alice",age=30,score=95},{name="Bob",age=25,score=87}}
)

Valeur renvoyée par f:write()

f:write() renvoie la référence du fichier en cas de succès, ce qui permet l’enchaînement de méthodes. En cas d’échec, elle renvoie nil, un message d’erreur et un code d’erreur. Vérifiez toujours les erreurs dans le code de production, en particulier pour les écritures sur des systèmes dont l’espace de stockage est limité.

local f = io.open("out.txt", "w")

-- Chaining writes
local ok, err = f:write("line1\n"):write("line2\n"):write("line3\n")
if not ok then
  print("Write failed:", err)
else
  print("All writes succeeded")
end
f:close()

Vérification rapide

Quelle est la différence entre les modes "w" et "a" de io.open ?

Récapitulatif : écrire des fichiers

Résumé :

  • f:write(...) — écrit des chaînes ou des nombres ; aucun saut de ligne automatique
  • "w" tronque le fichier, "a" ajoute du contenu
  • f:flush() force l’écriture de la mémoire tampon sur le disque
  • io.write() écrit vers la sortie par défaut (stdout)
  • Écriture atomique : écrire dans un fichier temporaire, puis le renommer
  • Vérifiez les valeurs renvoyées par les écritures en production

Questions Fréquemment Posées

La leçon « Écrire dans des fichiers et y ajouter du contenu » est-elle gratuite ?

Oui — le texte complet de « Écrire dans des fichiers et y ajouter du contenu » 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 « Écrire dans des fichiers et y ajouter du contenu » ?

Écrivez des chaînes dans des fichiers et ajoutez des données sans écraser le contenu existant. 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 3 sur 4.

Combien de temps prend la leçon « Écrire dans des fichiers et y ajouter du contenu » ?

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