fs

Lit un fichier entier et renvoie son texte.

Quand le fichier n'existe pas, ou quand le chemin est un dossier, le résultat est nil : pas d'erreur. « Lire, ou prendre une valeur par défaut » tient donc en une ligne :

local texte = fs.read("fichier_absent")
print(texte)
local record = tonumber(fs.read("meilleur_score") or "0") or 0
print("meilleur score : " .. record)

nil
meilleur score : 0

Le texte revient exactement tel qu'il a été écrit, retours à la ligne compris ; string.split(texte, "\n") le découpe en lignes. Lire coûte une instruction de plus par tranche de 16 caractères.

Voir aussi fs.write() fs.exists()

Remplace le contenu d'un fichier par text, ou le crée.

L'ancien contenu est perdu. Les dossiers du chemin sont créés au besoin : fs.write("sauve/snake/record", "120") marche sur un support vide.

fs.write("sauve/snake/record", 120)
print(fs.read("sauve/snake/record"))
print(fs.is_dir("sauve/snake"))

120
true

Les nombres sont acceptés et changés en texte ; toute autre valeur arrête le programme avec bad argument #2 to 'write' (string expected, got boolean) : utilisez tostring(valeur). L'écriture échoue quand un dossier porte le nom du fichier ('sauve' is a folder), quand le support est plein (not enough space) ou contient déjà 1024 entrées.

Le fichier est écrit tout de suite : un autre programme de l'ordinateur, ou le shell, le voit aussitôt. Le monde l'enregistre sur le disque avec tout le reste. Écrire coûte une instruction de plus par tranche de 16 caractères.

Voir aussi fs.append() fs.read()

Ajoute du texte à la fin d'un fichier, après ce qu'il contient déjà. Le fichier (et ses dossiers) est créé au besoin.

C'est l'outil des journaux : chaque évènement ajoute une ligne, les anciennes restent. Rien n'est ajouté entre deux appels : terminez chaque ligne par "\n" vous-même.

fs.append("journaux/gare", "train venant du nord\n")
fs.append("journaux/gare", "train venant de l'est\n")
write(fs.read("journaux/gare"))

train venant du nord
train venant de l'est

Un journal qui ne fait que grandir finira par remplir le support : voyez le journal tournant dans les Motifs courants. Ajouter coûte une instruction de plus par tranche de 16 caractères ajoutés.

Voir aussi fs.write()

Dit si un fichier ou un dossier a ce chemin.

fs.write("reglages", "vitesse=64")
print(fs.exists("reglages"))
print(fs.exists("records"))
print(fs.exists("/"))

true
false
true

La racine (/) existe toujours. Pour distinguer un fichier d'un dossier, utilisez fs.is_dir. Pour lire un fichier qui peut manquer, fs.read suffit : il renvoie nil.

Voir aussi fs.is_dir() fs.read()

Dit si le chemin est un dossier.

fs.write("jeux/snake/main", "-- le jeu")
print(fs.is_dir("jeux"))
print(fs.is_dir("jeux/snake/main"))
print(fs.is_dir("rien_ici"))

true
false
false

Voir aussi fs.exists() fs.list()

Les noms des fichiers et dossiers qui se trouvent directement dans un dossier.

Les noms viennent sans leur dossier (porte, pas journaux/porte), triés : les chiffres d'abord, puis les majuscules, puis les minuscules. Dossiers et fichiers sont mélangés : demandez à fs.is_dir de les distinguer.

fs.write("journaux/porte", "")
fs.write("journaux/Presse", "")
fs.write("journaux/2024/mars", "")
for _, nom in ipairs(fs.list("journaux")) do
  if fs.is_dir("journaux/" .. nom) then
    print(nom .. "/")
  else
    print(nom)
  end
end

2024/
Presse
porte

Un dossier vide donne une table vide. Un chemin qui n'est pas un dossier arrête le programme avec no folder 'journaux' (ou 'journaux' is a file). Pour parcourir aussi les dossiers des dossiers, voyez l'arborescence dans les Motifs courants.

Voir aussi fs.is_dir() fs.cwd()

Crée un dossier, et les dossiers qui y mènent.

Rien ne se passe quand le dossier existe déjà. Quand un fichier porte ce nom, le programme s'arrête avec 'journaux' is a file.

fs.make_dir("archives/2024")
print(fs.is_dir("archives"), fs.is_dir("archives/2024"))

true    true

Vous en aurez rarement besoin avant d'écrire, puisque fs.write crée lui-même les dossiers du chemin. Elle sert à préparer un dossier vide qu'un programme ou un joueur remplira plus tard. Un dossier vide ne prend pas de place, mais compte dans les 1024 entrées du support.

Voir aussi fs.write() fs.list()

Supprime un fichier, ou un dossier avec tout ce qu'il contient.

Pas de confirmation, pas de corbeille : ce qui est supprimé est perdu. Un chemin absent n'est pas une erreur, le résultat est simplement false.

fs.write("tmp/rapport", "brouillon")
print(fs.delete("tmp"))
print(fs.delete("tmp"))
print(fs.exists("tmp/rapport"))

true
false
false

La racine elle-même ne peut pas être supprimée (the root cannot be deleted), et un dossier vidé reste en place (supprimez-le aussi si vous voulez qu'il disparaisse).

Voir aussi fs.exists()

Déplace ou renomme un fichier ou un dossier (avec tout son contenu).

to est le nouveau chemin complet, pas un dossier où ranger : pour mettre rapport dans le dossier archives, écrivez fs.move("rapport", "archives/rapport"). (La commande mv du shell est plus souple et range dans un dossier ; fs.move est stricte.)

fs.write("rapport", "64 lingots de fer")
fs.move("rapport", "archives/rapport")
print(fs.exists("rapport"), fs.read("archives/rapport"))

false   64 lingots de fer

• Les dossiers du chemin to sont créés.
• Quand un fichier a déjà le chemin to, il est remplacé.
• Quand to est un dossier existant, le programme s'arrête avec 'archives' is a folder.
• Déplacer quelque chose qui n'existe pas s'arrête avec no file 'rapport' ; déplacer un dossier dans lui-même, avec a folder cannot go inside itself.

Voir aussi fs.copy() fs.delete()

Copie un fichier, ou un dossier avec tout ce qu'il contient.

Les règles pour to sont celles de fs.move : un chemin complet, des dossiers créés en route, un fichier remplacé, un dossier refusé. La copie demande de la place sur le support (not enough space), et compte dans les 1024 entrées.

fs.write("startup", 'print("Fonderie prête")')
fs.copy("startup", "secours/startup")
print(fs.read("secours/startup"))

print("Fonderie prête")

Copier un fichier sur lui-même s'arrête avec a file cannot be copied onto itself. Une copie coûte une instruction de plus par tranche de 16 octets copiés.

Voir aussi fs.move()

Le dossier courant : celui d'où partent les chemins relatifs.

C'est le dossier où se trouvait le shell (cd jeux) quand le programme a été lancé, écrit depuis la racine avec un / au début. Un programme ne peut pas le changer. Elle marche même sans support.

print(fs.cwd())

/

local morceaux = string.split(arg[0], "/")  -- "jeux/snake/main" donne jeux, snake, main
table.remove(morceaux)                      -- retire le nom du fichier
local ici = "/" .. table.concat(morceaux, "/")
fs.write(ici .. "/record", "120")           -- toujours /jeux/snake/record

Voir aussi fs.list()

La taille d'un fichier en octets, ou de tout ce que contient un dossier.

fs.write("journaux/porte", "ouverte\nfermée\n")
fs.write("journaux/presse", "bloquée\n")
print(fs.size("journaux/porte"))
print(fs.size("journaux"))
print(fs.size("rien"))

16
25
nil

Un octet, c'est une lettre sans accent, un chiffre, une espace ou un retour à la ligne. Une lettre accentuée en prend 2 : fs.size peut donc dépasser #texte.

Voir aussi fs.free()

Les octets encore libres sur le support.

Vérifiez-la avant d'écrire quelque chose de gros, ou pour prévenir avant que le support soit plein :

if fs.free() < 1000 then
  print("Disquette presque pleine : archivez les vieux journaux")
end

Voir aussi fs.capacity() fs.size()

La taille totale du support en octets : 4096 pour un Paquet de cartes perforées, 16384 pour une Bobine de bande magnétique ou la mémoire du Microcontrôleur, 65536 pour une Disquette, 1048576 pour un SSD.

fs.write("recettes", string.rep("plaque de fer = 1 lingot de fer\n", 40))
local pris = fs.capacity() - fs.free()
print(pris .. " octets pris sur " .. fs.capacity())
print(math.floor(pris * 100 / fs.capacity()) .. " % plein")

1280 octets pris sur 65536
1 % plein

(Sur une Disquette.)

Voir aussi fs.free()