Référence de l'API node:fs

Elide expose node:fs, node:fs/promises, fs.promises et l’alias elide:fs. Les exemples ci-dessous couvrent les opérations synchrones, à base de Promise, avec FileHandle et par flux.

Utilisation de base

import fs from "node:fs";
import os from "node:os";
import path from "node:path";

const dir = fs.mkdtempSync(path.join(os.tmpdir(), "elide-fs-"));
const file = path.join(dir, "hello.txt");

try {
  fs.writeFileSync(file, "hello\n");
  console.log(fs.readFileSync(file, "utf8"));
  console.log(fs.statSync(file).isFile());
} finally {
  fs.rmSync(dir, { recursive: true, force: true });
}

Cet exemple vérifie mkdtempSync, writeFileSync, readFileSync, statSync et rmSync. Les échecs du système de fichiers peuvent porter les champs code, errno, syscall, path et dest.

Promesses et handles de fichiers

import os from "node:os";
import path from "node:path";
import { mkdtemp, open, rm, writeFile } from "node:fs/promises";

const dir = await mkdtemp(path.join(os.tmpdir(), "elide-fs-"));
try {
  const file = path.join(dir, "data.txt");
  await writeFile(file, "hello\n");

  const handle = await open(file, "r");
  try {
    const buffer = Buffer.alloc(64);
    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
    console.log(buffer.subarray(0, bytesRead).toString());
  } finally {
    await handle.close();
  }
} finally {
  await rm(dir, { recursive: true, force: true });
}

Cet exemple vérifie mkdtemp, writeFile, open et rm à base de Promise, ainsi que FileHandle.read() et FileHandle.close(). Les échecs représentatifs des Promise exposent les mêmes champs de style Node que ceux décrits ci-dessus.

writeFile (et FileHandle.writeFile) acceptent aussi un itérable synchrone ou asynchrone de chaînes et de buffers, y compris un flux Readable :

import { writeFile } from "node:fs/promises";
import { Readable } from "node:stream";

await writeFile("out.txt", Readable.from(["a", "b", "c"]));

Flux

createReadStream et createWriteStream renvoient des flux Readable et Writable. L’exemple vérifié suivant copie un fichier temporaire :

import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { pipeline } from "node:stream/promises";

const dir = fs.mkdtempSync(path.join(os.tmpdir(), "elide-fs-"));
try {
  const input = path.join(dir, "input.log");
  const output = path.join(dir, "copy.log");
  fs.writeFileSync(input, "first\nsecond\n");

  await pipeline(fs.createReadStream(input), fs.createWriteStream(output));
  console.log(fs.readFileSync(output, "utf8"));
} finally {
  fs.rmSync(dir, { recursive: true, force: true });
}

Surveillance

watch, watchFile, unwatchFile et la surface de surveillance à base de Promise sont présents. Un observateur ouvert maintient le script en vie jusqu’à sa fermeture :

import fs from "node:fs";

const watcher = fs.watch(".", (event, name) => {
  console.log(event, name); // rename new.txt
  watcher.close();
});
setTimeout(() => fs.writeFileSync("new.txt", "hello"), 100);

fs.openAsBlob n’est pas disponible.

Bac à sable

L’accès au système de fichiers n’est pas restreint tant qu’aucune option de bac à sable n’est fournie :

• --sandbox
• --allow-read[=PATHS]
• --allow-write[=PATHS]
• --fs-audit

Lorsqu’un bac à sable est actif, les opérations refusées échouent au lieu d’accéder au chemin. Consultez elide help sandbox pour la priorité des options et la syntaxe des listes de chemins.

Consultez la documentation fs de Node.js pour les formes d’arguments standard.

Reference

Status: Partial · 246 of 264 suite tests pass (93.2%) · since 1.1.0

Exports

fs/promises

Not implemented

FileReadStream, FileWriteStream, Utf8Stream, lchmod, lchmodSync, openAsBlob.

Tests: node-api node:fs: 246 pass, 18 fail, 0 error, 30 skipped. Failing: test-fs-promises-file-handle-pull.js, test-fs-promises-file-handle-pullsync.js, test-fs-promises-file-handle-read-worker.js, test-fs-promises-file-handle-writer.js, test-fs-promises-watch.js, test-fs-promises.js, test-fs-read-stream-file-handle.js, test-fs-stat.js, and 10 more.