Node.js v26.0.0 Dokumentation

Dateisystem#

Das node:fs-Modul ermöglicht die Interaktion mit dem Dateisystem, orientiert an standardmäßigen POSIX-Funktionen.

Zur Verwendung der Promise-basierten APIs

import * as fs from 'node:fs/promises';
const fs = require('node:fs/promises');
copy

Zur Verwendung der Callback- und Sync-APIs

import * as fs from 'node:fs';
const fs = require('node:fs');
copy

Alle Dateisystemoperationen haben synchrone, Callback- und Promise-basierte Formen und sind sowohl mit CommonJS-Syntax als auch mit ES6-Modulen (ESM) zugänglich.

Promise-Beispiel#

Promise-basierte Operationen geben ein Promise zurück, das erfüllt wird, wenn die asynchrone Operation abgeschlossen ist.

import { unlink } from 'node:fs/promises';

try {
  await unlink('/tmp/hello');
  console.log('successfully deleted /tmp/hello');
} catch (error) {
  console.error('there was an error:', error.message);
}
const { unlink } = require('node:fs/promises');

(async function(path) {
  try {
    await unlink(path);
    console.log(`successfully deleted ${path}`);
  } catch (error) {
    console.error('there was an error:', error.message);
  }
})('/tmp/hello');
copy

Callback-Beispiel#

Die Callback-Form nimmt als letztes Argument eine Abschluss-Callback-Funktion entgegen und führt die Operation asynchron aus. Die an den Abschluss-Callback übergebenen Argumente hängen von der Methode ab, aber das erste Argument ist immer für eine Ausnahme reserviert. Wenn die Operation erfolgreich abgeschlossen wurde, ist das erste Argument null oder undefined.

import { unlink } from 'node:fs';

unlink('/tmp/hello', (err) => {
  if (err) throw err;
  console.log('successfully deleted /tmp/hello');
});
const { unlink } = require('node:fs');

unlink('/tmp/hello', (err) => {
  if (err) throw err;
  console.log('successfully deleted /tmp/hello');
});
copy

Die Callback-basierten Versionen der node:fs-Modul-APIs sind den Promise-APIs vorzuziehen, wenn maximale Leistung (sowohl in Bezug auf Ausführungszeit als auch Speicherzuweisung) erforderlich ist.

Synchrones Beispiel#

Die synchronen APIs blockieren den Node.js-Event-Loop und die weitere JavaScript-Ausführung, bis die Operation abgeschlossen ist. Ausnahmen werden sofort geworfen und können mit try…catch behandelt oder nach oben weitergereicht werden.

import { unlinkSync } from 'node:fs';

try {
  unlinkSync('/tmp/hello');
  console.log('successfully deleted /tmp/hello');
} catch (err) {
  // handle the error
}
const { unlinkSync } = require('node:fs');

try {
  unlinkSync('/tmp/hello');
  console.log('successfully deleted /tmp/hello');
} catch (err) {
  // handle the error
}
copy

Promises-API#

Die fs/promises-API stellt asynchrone Dateisystemmethoden bereit, die Promises zurückgeben.

Die Promise-APIs verwenden den zugrunde liegenden Node.js-Threadpool, um Dateisystemoperationen außerhalb des Event-Loop-Threads auszuführen. Diese Operationen sind nicht synchronisiert oder threadsicher. Vorsicht ist geboten, wenn mehrere gleichzeitige Änderungen an derselben Datei vorgenommen werden, da es sonst zu Datenbeschädigungen kommen kann.

Klasse: FileHandle#

Ein <FileHandle>-Objekt ist ein Objekt-Wrapper für einen numerischen Dateideskriptor.

Instanzen des <FileHandle>-Objekts werden durch die Methode fsPromises.open() erstellt.

Alle <FileHandle>-Objekte sind <EventEmitter>.

Wenn ein <FileHandle> nicht mit der Methode filehandle.close() geschlossen wird, versucht es, den Dateideskriptor automatisch zu schließen und eine Prozesswarnung auszugeben, um Speicherlecks zu verhindern. Bitte verlassen Sie sich nicht auf dieses Verhalten, da es unzuverlässig sein kann und die Datei möglicherweise nicht geschlossen wird. Schließen Sie <FileHandle>-Instanzen stattdessen immer explizit. Node.js kann dieses Verhalten in Zukunft ändern.

Ereignis: 'close'#

Das 'close'-Ereignis wird ausgelöst, wenn der <FileHandle> geschlossen wurde und nicht mehr verwendet werden kann.

filehandle.appendFile(data[, options])#

• data <string> | <Buffer> | <TypedArray> | <DataView> | <AsyncIterable> | <Iterable> | <Stream>
• options <Object> | <string>
  • encoding <string> | <null> Standard: 'utf8'
  • signal <AbortSignal> | <undefined> erlaubt das Abbrechen eines laufenden writeFile-Vorgangs. Standard: undefined
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Alias von filehandle.writeFile().

Bei der Arbeit mit Dateihandles kann der Modus nicht von dem Wert geändert werden, der mit fsPromises.open() festgelegt wurde. Daher entspricht dies filehandle.writeFile().

filehandle.chmod(mode)#

• mode <integer> die Bitmaske für den Dateimodus.
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert die Berechtigungen für die Datei. Siehe chmod(2).

filehandle.chown(uid, gid)#

• uid <integer> Die Benutzer-ID des neuen Dateibesitzers.
• gid <integer> die Gruppen-ID der neuen Dateigruppe.
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert den Besitz der Datei. Ein Wrapper für chown(2).

filehandle.close()#

• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Schließt das Dateihandle, nachdem auf den Abschluss aller ausstehenden Vorgänge für das Handle gewartet wurde.

import { open } from 'node:fs/promises';

let filehandle;
try {
  filehandle = await open('thefile.txt', 'r');
} finally {
  await filehandle?.close();
}
copy

filehandle.createReadStream([options])#

• options <Object>
  • encoding <string> Standard: null
  • autoClose <boolean> Standard: true
  • emitClose <boolean> Standard: true
  • start <integer>
  • end <integer> Standard: Infinity
  • highWaterMark <integer> Standard: 64 * 1024
  • signal <AbortSignal> | <undefined> Standard: undefined
• Rückgabe: <fs.ReadStream>

options kann start- und end-Werte enthalten, um einen Bereich von Bytes aus der Datei anstelle der gesamten Datei zu lesen. Sowohl start als auch end sind inklusiv und beginnen bei 0 zu zählen; zulässige Werte liegen im Bereich [0, Number.MAX_SAFE_INTEGER]. Wenn start weggelassen oder undefined ist, liest filehandle.createReadStream() sequenziell ab der aktuellen Dateiposition. Die encoding kann jeder der von <Buffer> akzeptierten Werte sein.

Wenn der FileHandle auf ein zeichenorientiertes Gerät verweist, das nur blockierende Lesevorgänge unterstützt (wie eine Tastatur oder Soundkarte), werden Lesevorgänge erst abgeschlossen, wenn Daten verfügbar sind. Dies kann verhindern, dass der Prozess beendet wird und der Stream sich auf natürliche Weise schließt.

Standardmäßig sendet der Stream ein 'close'-Ereignis, nachdem er zerstört wurde. Setzen Sie die emitClose-Option auf false, um dieses Verhalten zu ändern.

import { open } from 'node:fs/promises';

const fd = await open('/dev/input/event0');
// Create a stream from some character device.
const stream = fd.createReadStream();
setTimeout(() => {
  stream.close(); // This may not close the stream.
  // Artificially marking end-of-stream, as if the underlying resource had
  // indicated end-of-file by itself, allows the stream to close.
  // This does not cancel pending read operations, and if there is such an
  // operation, the process may still not be able to exit successfully
  // until it finishes.
  stream.push(null);
  stream.read(0);
}, 100);
copy

Wenn autoClose auf false gesetzt ist, wird der Dateideskriptor auch bei einem Fehler nicht geschlossen. Es liegt in der Verantwortung der Anwendung, ihn zu schließen und sicherzustellen, dass kein Dateideskriptor verloren geht (Leck). Wenn autoClose auf true gesetzt ist (Standardverhalten), wird der Dateideskriptor bei 'error' oder 'end' automatisch geschlossen.

Ein Beispiel zum Lesen der letzten 10 Bytes einer 100 Bytes langen Datei

import { open } from 'node:fs/promises';

const fd = await open('sample.txt');
fd.createReadStream({ start: 90, end: 99 });
copy

filehandle.createWriteStream([options])#

• options <Object>
  • encoding <string> Standard: 'utf8'
  • autoClose <boolean> Standard: true
  • emitClose <boolean> Standard: true
  • start <integer>
  • highWaterMark <number> Standard: 16384
  • flush <boolean> Wenn true, wird der zugrunde liegende Dateideskriptor geleert, bevor er geschlossen wird. Standard: false.
• Rückgabe: <fs.WriteStream>

options kann auch eine start-Option enthalten, um das Schreiben von Daten an einer Position nach dem Dateianfang zu ermöglichen; zulässige Werte liegen im Bereich [0, Number.MAX_SAFE_INTEGER]. Das Ändern einer Datei anstelle des Ersetzens erfordert möglicherweise, dass die flags-Option open auf r+ anstelle des Standardwerts r gesetzt wird. Die encoding kann jeder der von <Buffer> akzeptierten Werte sein.

Wenn autoClose auf true gesetzt ist (Standardverhalten), wird der Dateideskriptor bei 'error' oder 'finish' automatisch geschlossen. Wenn autoClose auf false gesetzt ist, wird der Dateideskriptor auch bei einem Fehler nicht geschlossen. Es liegt in der Verantwortung der Anwendung, ihn zu schließen und sicherzustellen, dass kein Dateideskriptor verloren geht.

Standardmäßig sendet der Stream ein 'close'-Ereignis, nachdem er zerstört wurde. Setzen Sie die emitClose-Option auf false, um dieses Verhalten zu ändern.

filehandle.datasync()#

• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Erzwingt, dass alle derzeit in der Warteschlange befindlichen E/A-Operationen, die mit der Datei verknüpft sind, den synchronisierten E/A-Abschlusszustand des Betriebssystems erreichen. Einzelheiten finden Sie in der POSIX-Dokumentation für fdatasync(2).

Im Gegensatz zu filehandle.sync leert diese Methode keine geänderten Metadaten.

filehandle.fd#

• Typ: <number> Der numerische Dateideskriptor, der vom <FileHandle>-Objekt verwaltet wird.

filehandle.pull([...transforms][, options])#

• ...transforms <Function> | <Object> Optionale Transformationen, die über stream/iter pull() angewendet werden.
• options <Object>
  • signal <AbortSignal>
  • autoClose <boolean> Schließt das Dateihandle, wenn der Stream endet. Standard: false.
  • start <number> Byte-Offset für den Lesebeginn. Wenn angegeben, verwenden Lesevorgänge eine explizite Positionierung (pread-Semantik). Standard: aktuelle Dateiposition.
  • limit <number> Maximale Anzahl der zu lesenden Bytes vor Beendigung des Iterators. Lesevorgänge stoppen, wenn limit Bytes geliefert wurden oder EOF erreicht ist, je nachdem, was zuerst eintritt. Standard: lesen bis EOF.
  • chunkSize <number> Größe in Bytes des für jeden Lesevorgang zugewiesenen Buffers. Standard: 131072 (128 KB).
• Gibt zurück: {AsyncIterable<Uint8Array[]>}

Gibt den Dateiinhalt als asynchrones Iterierbares unter Verwendung des node:stream/iter-Pull-Modells zurück. Lesevorgänge werden in chunkSize-Byte-Blöcken durchgeführt (Standard 128 KB). Wenn Transformationen bereitgestellt werden, werden diese über stream/iter pull() angewendet.

Das Dateihandle ist gesperrt, während das Iterierbare verbraucht wird, und wird entsperrt, wenn die Iteration abgeschlossen ist, ein Fehler auftritt oder der Consumer abbricht.

Diese Funktion ist nur verfügbar, wenn das Flag --experimental-stream-iter aktiviert ist.

import { open } from 'node:fs/promises';
import { text } from 'node:stream/iter';
import { compressGzip } from 'node:zlib/iter';

const fh = await open('input.txt', 'r');

// Read as text
console.log(await text(fh.pull({ autoClose: true })));

// Read 1 KB starting at byte 100
const fh2 = await open('input.txt', 'r');
console.log(await text(fh2.pull({ start: 100, limit: 1024, autoClose: true })));

// Read with compression
const fh3 = await open('input.txt', 'r');
const compressed = fh3.pull(compressGzip(), { autoClose: true });
const { open } = require('node:fs/promises');
const { text } = require('node:stream/iter');
const { compressGzip } = require('node:zlib/iter');

async function run() {
  const fh = await open('input.txt', 'r');

  // Read as text
  console.log(await text(fh.pull({ autoClose: true })));

  // Read 1 KB starting at byte 100
  const fh2 = await open('input.txt', 'r');
  console.log(await text(fh2.pull({ start: 100, limit: 1024, autoClose: true })));

  // Read with compression
  const fh3 = await open('input.txt', 'r');
  const compressed = fh3.pull(compressGzip(), { autoClose: true });
}

run().catch(console.error);
copy

filehandle.pullSync([...transforms][, options])#

• ...transforms <Function> | <Object> Optionale Transformationen, die über stream/iter pullSync() angewendet werden.
• options <Object>
  • autoClose <boolean> Schließt das Dateihandle, wenn der Stream endet. Standard: false.
  • start <number> Byte-Offset für den Lesebeginn. Wenn angegeben, verwenden Lesevorgänge explizite Positionierung. Standard: aktuelle Dateiposition.
  • limit <number> Maximale Anzahl der zu lesenden Bytes vor Beendigung des Iterators. Standard: lesen bis EOF.
  • chunkSize <number> Größe in Bytes des für jeden Lesevorgang zugewiesenen Buffers. Standard: 131072 (128 KB).
• Gibt zurück: {Iterable<Uint8Array[]>}

Synchrones Gegenstück zu filehandle.pull(). Gibt ein synchrones Iterierbares zurück, das die Datei unter Verwendung von synchroner E/A im Hauptthread liest. Lesevorgänge werden in chunkSize-Byte-Blöcken durchgeführt (Standard 128 KB).

Das Dateihandle ist gesperrt, während das Iterierbare verbraucht wird. Im Gegensatz zum asynchronen pull() unterstützt diese Methode kein AbortSignal, da alle Operationen synchron sind.

Diese Funktion ist nur verfügbar, wenn das Flag --experimental-stream-iter aktiviert ist.

import { open } from 'node:fs/promises';
import { textSync, pipeToSync } from 'node:stream/iter';
import { compressGzipSync, decompressGzipSync } from 'node:zlib/iter';

const fh = await open('input.txt', 'r');

// Read as text (sync)
console.log(textSync(fh.pullSync({ autoClose: true })));

// Sync compress pipeline: file -> gzip -> file
const src = await open('input.txt', 'r');
const dst = await open('output.gz', 'w');
pipeToSync(src.pullSync(compressGzipSync(), { autoClose: true }), dst.writer({ autoClose: true }));
const { open } = require('node:fs/promises');
const { textSync, pipeToSync } = require('node:stream/iter');
const { compressGzipSync, decompressGzipSync } = require('node:zlib/iter');

async function run() {
  const fh = await open('input.txt', 'r');

  // Read as text (sync)
  console.log(textSync(fh.pullSync({ autoClose: true })));

  // Sync compress pipeline: file -> gzip -> file
  const src = await open('input.txt', 'r');
  const dst = await open('output.gz', 'w');
  pipeToSync(
    src.pullSync(compressGzipSync(), { autoClose: true }),
    dst.writer({ autoClose: true }),
  );
}

run().catch(console.error);
copy

filehandle.read(buffer, offset, length, position)#

• buffer <Buffer> | <TypedArray> | <DataView> Ein Puffer, der mit den gelesenen Dateidaten gefüllt wird.
• offset <integer> Die Position im Puffer, an der mit dem Füllen begonnen werden soll. Standard: 0
• length <integer> Die Anzahl der zu lesenden Bytes. Standard: buffer.byteLength - offset
• position <integer> | <bigint> | <null> Die Stelle, an der mit dem Lesen der Daten aus der Datei begonnen werden soll. Wenn null oder -1, werden die Daten ab der aktuellen Dateiposition gelesen und die Position wird aktualisiert. Wenn position eine nicht-negative Ganzzahl ist, bleibt die aktuelle Dateiposition unverändert. Standard: null
• Rückgabe: <Promise> Erfüllt bei Erfolg ein Objekt mit zwei Eigenschaften
  • bytesRead <integer> Die Anzahl der gelesenen Bytes
  • buffer <Buffer> | <TypedArray> | <DataView> Eine Referenz auf das übergebene buffer-Argument.

Liest Daten aus der Datei und speichert diese im angegebenen Puffer.

Wenn die Datei nicht gleichzeitig geändert wird, ist das Dateiende erreicht, wenn die Anzahl der gelesenen Bytes Null ist.

filehandle.read([options])#

• options <Object>
  • buffer <Buffer> | <TypedArray> | <DataView> Ein Puffer, der mit den gelesenen Dateidaten gefüllt wird. Standard: Buffer.alloc(16384)
  • offset <integer> Die Position im Puffer, an der mit dem Füllen begonnen werden soll. Standard: 0
  • length <integer> Die Anzahl der zu lesenden Bytes. Standard: buffer.byteLength - offset
  • position <integer> | <bigint> | <null> Die Stelle, an der mit dem Lesen aus der Datei begonnen werden soll. Wenn null oder -1, werden die Daten ab der aktuellen Position gelesen und die Position wird aktualisiert. Wenn position eine nicht-negative Ganzzahl ist, bleibt die aktuelle Position unverändert. Standard: null
• Rückgabe: <Promise> Erfüllt bei Erfolg ein Objekt mit zwei Eigenschaften
  • bytesRead <integer> Die Anzahl der gelesenen Bytes
  • buffer <Buffer> | <TypedArray> | <DataView> Eine Referenz auf das übergebene buffer-Argument.

Liest Daten aus der Datei und speichert diese im angegebenen Puffer.

Wenn die Datei nicht gleichzeitig geändert wird, ist das Dateiende erreicht, wenn die Anzahl der gelesenen Bytes Null ist.

filehandle.read(buffer[, options])#

• buffer <Buffer> | <TypedArray> | <DataView> Ein Puffer, der mit den gelesenen Dateidaten gefüllt wird.
• options <Object>
  • offset <integer> Die Position im Puffer, an der mit dem Füllen begonnen werden soll. Standard: 0
  • length <integer> Die Anzahl der zu lesenden Bytes. Standard: buffer.byteLength - offset
  • position <integer> | <bigint> | <null> Die Stelle, an der mit dem Lesen aus der Datei begonnen werden soll. Wenn null oder -1, werden die Daten ab der aktuellen Position gelesen und die Position wird aktualisiert. Wenn position eine nicht-negative Ganzzahl ist, bleibt die aktuelle Position unverändert. Standard: null
• Rückgabe: <Promise> Erfüllt bei Erfolg ein Objekt mit zwei Eigenschaften
  • bytesRead <integer> Die Anzahl der gelesenen Bytes
  • buffer <Buffer> | <TypedArray> | <DataView> Eine Referenz auf das übergebene buffer-Argument.

Liest Daten aus der Datei und speichert diese im angegebenen Puffer.

Wenn die Datei nicht gleichzeitig geändert wird, ist das Dateiende erreicht, wenn die Anzahl der gelesenen Bytes Null ist.

filehandle.readableWebStream([options])#

• options <Object>
  • autoClose <boolean> Wenn true, bewirkt es, dass der <FileHandle> geschlossen wird, wenn der Stream geschlossen wird. Standard: false
• Gibt zurück: <ReadableStream>

Gibt einen byte-orientierten ReadableStream zurück, der zum Lesen des Dateiinhaltes verwendet werden kann.

Ein Fehler wird ausgelöst, wenn diese Methode mehr als einmal aufgerufen wird oder nachdem der FileHandle geschlossen wurde oder sich im Schließvorgang befindet.

import {
  open,
} from 'node:fs/promises';

const file = await open('./some/file/to/read');

for await (const chunk of file.readableWebStream())
  console.log(chunk);

await file.close();
const {
  open,
} = require('node:fs/promises');

(async () => {
  const file = await open('./some/file/to/read');

  for await (const chunk of file.readableWebStream())
    console.log(chunk);

  await file.close();
})();
copy

Während der ReadableStream die Datei vollständig liest, schließt er den FileHandle nicht automatisch. Der Benutzercode muss weiterhin die fileHandle.close()-Methode aufrufen, es sei denn, die autoClose-Option ist auf true gesetzt.

filehandle.readFile(options)#

• options <Object> | <string>
  • encoding <string> | <null> Standard: null
  • signal <AbortSignal> erlaubt das Abbrechen eines laufenden readFile-Vorgangs
• Rückgabe: <Promise> Erfüllt bei erfolgreichem Lesen mit dem Inhalt der Datei. Wenn keine Kodierung angegeben ist (unter Verwendung von options.encoding), werden die Daten als <Buffer>-Objekt zurückgegeben. Andernfalls sind die Daten ein String.

Liest den gesamten Inhalt einer Datei asynchron.

Wenn options ein String ist, dann spezifiziert er die encoding.

Der <FileHandle> muss das Lesen unterstützen.

Wenn ein oder mehrere filehandle.read()-Aufrufe auf einem Dateihandle getätigt werden und anschließend ein filehandle.readFile()-Aufruf erfolgt, werden die Daten ab der aktuellen Position bis zum Ende der Datei gelesen. Es wird nicht immer vom Anfang der Datei gelesen.

filehandle.readLines([options])#

• options <Object>
  • encoding <string> Standard: null
  • autoClose <boolean> Standard: true
  • emitClose <boolean> Standard: true
  • start <integer>
  • end <integer> Standard: Infinity
  • highWaterMark <integer> Standard: 64 * 1024
• Rückgabe: <readline.InterfaceConstructor>

Komfortmethode zum Erstellen eines readline-Interfaces und zum Streamen über die Datei. Siehe filehandle.createReadStream() für die Optionen.

import { open } from 'node:fs/promises';

const file = await open('./some/file/to/read');

for await (const line of file.readLines()) {
  console.log(line);
}
const { open } = require('node:fs/promises');

(async () => {
  const file = await open('./some/file/to/read');

  for await (const line of file.readLines()) {
    console.log(line);
  }
})();
copy

filehandle.readv(buffers[, position])#

• buffers <Buffer[]> | <TypedArray[]> | <DataView[]>
• position <integer> | <null> Der Offset vom Dateianfang, ab dem die Daten gelesen werden sollen. Wenn position keine Zahl ist, werden die Daten ab der aktuellen Position gelesen. Standard: null
• Rückgabe: <Promise> Erfüllt bei Erfolg ein Objekt mit zwei Eigenschaften
  • bytesRead <integer> die Anzahl der gelesenen Bytes
  • buffers <Buffer[]> | <TypedArray[]> | <DataView[]> Eigenschaft mit einer Referenz auf die buffers-Eingabe.

Liest aus einer Datei und schreibt in ein Array von <ArrayBufferView>-Instanzen

filehandle.stat([options])#

• options <Object>
  • bigint <boolean> Ob die numerischen Werte im zurückgegebenen <fs.Stats>-Objekt BigInt sein sollen. Standard: false.
• Rückgabe: <Promise> Erfüllt mit einem <fs.Stats>-Objekt für die Datei.

filehandle.sync()#

• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Fordert an, dass alle Daten für den geöffneten Dateideskriptor auf das Speichergerät geleert werden. Die spezifische Implementierung ist betriebssystem- und geräteabhängig. Weitere Informationen finden Sie in der POSIX-Dokumentation für fsync(2).

filehandle.truncate(len)#

• len <integer> Standard: 0
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Kürzt die Datei.

Wenn die Datei größer als len Bytes war, werden nur die ersten len Bytes in der Datei beibehalten.

Das folgende Beispiel behält nur die ersten vier Bytes der Datei bei

import { open } from 'node:fs/promises';

let filehandle = null;
try {
  filehandle = await open('temp.txt', 'r+');
  await filehandle.truncate(4);
} finally {
  await filehandle?.close();
}
copy

Wenn die Datei zuvor kürzer als len Bytes war, wird sie erweitert, und der erweiterte Teil wird mit Null-Bytes ('\0') gefüllt

Wenn len negativ ist, wird 0 verwendet.

filehandle.utimes(atime, mtime)#

• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• Rückgabewert: <Promise>

Ändert die Dateisystem-Zeitstempel des Objekts, auf das der <FileHandle> verweist, und erfüllt dann das Promise ohne Argumente bei Erfolg.

filehandle.write(buffer, offset[, length[, position]])#

• buffer <Buffer> | <TypedArray> | <DataView>
• offset <integer> Die Startposition innerhalb von buffer, an der die zu schreibenden Daten beginnen.
• length <integer> Die Anzahl der Bytes aus buffer, die geschrieben werden sollen. Standard: buffer.byteLength - offset
• position <integer> | <null> Der Offset vom Dateianfang, an dem die Daten aus buffer geschrieben werden sollen. Wenn position keine Zahl ist, werden die Daten an der aktuellen Position geschrieben. Weitere Details finden Sie in der POSIX-Dokumentation für pwrite(2). Standard: null
• Rückgabewert: <Promise>

Schreibt buffer in die Datei.

Das Promise wird mit einem Objekt erfüllt, das zwei Eigenschaften enthält

• bytesWritten <integer> die Anzahl der geschriebenen Bytes
• buffer <Buffer> | <TypedArray> | <DataView> eine Referenz auf den geschriebenen buffer.

Es ist unsicher, filehandle.write() mehrmals auf derselben Datei zu verwenden, ohne auf die Erfüllung (oder Ablehnung) des Promises zu warten. Verwenden Sie für dieses Szenario filehandle.createWriteStream().

Unter Linux funktionieren positionelle Schreibvorgänge nicht, wenn die Datei im Anfügemodus (append mode) geöffnet wurde. Der Kernel ignoriert das Positionsargument und fügt die Daten immer an das Ende der Datei an.

filehandle.write(buffer[, options])#

• buffer <Buffer> | <TypedArray> | <DataView>
• options <Object>
  • offset <integer> Standard: 0
  • length <integer> Standard: buffer.byteLength - offset
  • position <integer> | <null> Standard: null
• Rückgabewert: <Promise>

Schreibt buffer in die Datei.

Ähnlich wie die obige filehandle.write-Funktion akzeptiert diese Version ein optionales options-Objekt. Wenn kein options-Objekt angegeben ist, werden die obigen Standardwerte verwendet.

filehandle.write(string[, position[, encoding]])#

• string <string>
• position <integer> | <null> Der Offset vom Dateianfang, an dem die Daten aus string geschrieben werden sollen. Wenn position keine Zahl ist, werden die Daten an der aktuellen Position geschrieben. Weitere Details finden Sie in der POSIX-Dokumentation für pwrite(2). Standard: null
• encoding <string> Die erwartete String-Kodierung. Standard: 'utf8'
• Rückgabewert: <Promise>

Schreibt string in die Datei. Wenn string kein String ist, wird das Promise mit einem Fehler abgelehnt.

Das Promise wird mit einem Objekt erfüllt, das zwei Eigenschaften enthält

• bytesWritten <integer> die Anzahl der geschriebenen Bytes
• buffer <string> eine Referenz auf den geschriebenen string.

Es ist unsicher, filehandle.write() mehrmals auf derselben Datei zu verwenden, ohne auf die Erfüllung (oder Ablehnung) des Promises zu warten. Verwenden Sie für dieses Szenario filehandle.createWriteStream().

Unter Linux funktionieren positionelle Schreibvorgänge nicht, wenn die Datei im Anfügemodus (append mode) geöffnet wurde. Der Kernel ignoriert das Positionsargument und fügt die Daten immer an das Ende der Datei an.

filehandle.writeFile(data, options)#

• data <string> | <Buffer> | <TypedArray> | <DataView> | <AsyncIterable> | <Iterable> | <Stream>
• options <Object> | <string>
  • encoding <string> | <null> Die erwartete Zeichenkodierung, wenn data ein String ist. Standard: 'utf8'
  • signal <AbortSignal> | <undefined> erlaubt das Abbrechen eines laufenden writeFile-Vorgangs. Standard: undefined
• Rückgabewert: <Promise>

Schreibt Daten asynchron in eine Datei und ersetzt die Datei, falls sie bereits existiert. data kann ein String, ein Puffer, ein <AsyncIterable> oder ein <Iterable>-Objekt sein. Das Promise wird bei Erfolg ohne Argumente erfüllt.

Wenn options ein String ist, dann spezifiziert er die encoding.

Der <FileHandle> muss das Schreiben unterstützen.

Es ist unsicher, filehandle.writeFile() mehrmals auf derselben Datei zu verwenden, ohne auf die Erfüllung (oder Ablehnung) des Promises zu warten.

Wenn ein oder mehrere filehandle.write()-Aufrufe auf einem Dateihandle getätigt werden und anschließend ein filehandle.writeFile()-Aufruf erfolgt, werden die Daten ab der aktuellen Position bis zum Ende der Datei geschrieben. Es wird nicht immer vom Anfang der Datei geschrieben.

filehandle.writev(buffers[, position])#

• buffers <Buffer[]> | <TypedArray[]> | <DataView[]>
• position <integer> | <null> Der Offset vom Dateianfang, an dem die Daten aus buffers geschrieben werden sollen. Wenn position keine Zahl ist, werden die Daten an der aktuellen Position geschrieben. Standard: null
• Rückgabewert: <Promise>

Schreibt ein Array von <ArrayBufferView>-Instanzen in die Datei.

Das Promise wird mit einem Objekt erfüllt, das zwei Eigenschaften enthält

• bytesWritten <integer> die Anzahl der geschriebenen Bytes
• buffers <Buffer[]> | <TypedArray[]> | <DataView[]> eine Referenz auf die buffers-Eingabe.

Es ist unsicher, writev() mehrmals auf derselben Datei aufzurufen, ohne auf die Erfüllung (oder Ablehnung) des Promises zu warten.

Unter Linux funktionieren positionelle Schreibvorgänge nicht, wenn die Datei im Anfügemodus geöffnet wurde. Der Kernel ignoriert das Positionsargument und fügt die Daten immer an das Ende der Datei an.

filehandle.writer([options])#

• options <Object>
  • autoClose <boolean> Schließt das Dateihandle, wenn der Writer endet oder fehlschlägt. Standard: false.
  • start <number> Byte-Offset für den Schreibbeginn. Wenn angegeben, verwenden Schreibvorgänge explizite Positionierung. Standard: aktuelle Dateiposition.
  • limit <number> Maximale Anzahl von Bytes, die der Writer akzeptiert. Asynchrone Schreibvorgänge (write(), writev()), die das Limit überschreiten würden, werden mit ERR_OUT_OF_RANGE abgelehnt. Synchrone Schreibvorgänge (writeSync(), writevSync()) geben false zurück. Standard: kein Limit.
  • chunkSize <number> Maximale Chunk-Größe in Bytes für synchrone Schreibvorgänge. Schreibvorgänge, die größer als dieser Schwellenwert sind, greifen auf asynchrone E/A zurück. Setzen Sie dies passend zur chunkSize des Readers für optimale pipeTo()-Leistung. Standard: 131072 (128 KB).
• Rückgabewert: <Object>
  • write(chunk[, options]) <Function> Gibt {Promise zurück}. Akzeptiert Uint8Array, Buffer oder String (UTF-8 kodiert).
    • chunk <Buffer> | <TypedArray> | <DataView> | <string>
    • options <Object>
      • signal <AbortSignal> Wenn das Signal bereits abgebrochen wurde, wird der Schreibvorgang mit AbortError abgelehnt, ohne E/A durchzuführen.
  • writev(chunks[, options]) <Function> Gibt {Promise zurück}. Verwendet Scatter/Gather-E/A über einen einzelnen writev()-Systemaufruf. Akzeptiert gemischte Uint8Array/String-Arrays.
    • chunks {Array<Buffer|TypedArray|DataView|string>}
    • options <Object>
      • signal <AbortSignal> Wenn das Signal bereits abgebrochen wurde, wird der Schreibvorgang mit AbortError abgelehnt, ohne E/A durchzuführen.
  • writeSync(chunk) <Function> Gibt <boolean> zurück. Versucht einen synchronen Schreibvorgang. Gibt true zurück, wenn das Schreiben erfolgreich war, false, wenn der Aufrufer auf asynchrones write() zurückgreifen sollte. Gibt false zurück, wenn: der Writer geschlossen ist/fehlerhaft ist, eine asynchrone Operation im Gange ist, der Chunk chunkSize überschreitet oder das Schreiben das limit überschreiten würde.
    • chunk <Buffer> | <TypedArray> | <DataView> | <string>
  • writevSync(chunks) <Function> Gibt <boolean> zurück. Synchroner Batch-Schreibvorgang. Gleiche Fallback-Semantik wie writeSync().
    • chunks {Array<Buffer|TypedArray|DataView|string>}
  • end([options]) <Function> Gibt {Promise zurück} Gesamtzahl der geschriebenen Bytes. Idempotent: gibt totalBytesWritten zurück, falls bereits geschlossen, gibt das ausstehende Promise zurück, falls bereits geschlossen wird. Lehnt ab, wenn sich der Writer in einem fehlerhaften Zustand befindet.
    • options <Object>
      • signal <AbortSignal> Wenn das Signal bereits abgebrochen wurde, wird end() mit AbortError abgelehnt und der Writer bleibt geöffnet.
  • endSync() <Function> Gibt <number> | <number> Gesamtzahl der geschriebenen Bytes bei Erfolg zurück, -1, wenn der Writer fehlerhaft ist oder eine asynchrone Operation im Gange ist. Idempotent, wenn bereits geschlossen.
  • fail(reason) <Function> Versetzt den Writer in einen terminalen Fehlerzustand. Synchron. Wenn der Writer bereits geschlossen oder fehlerhaft ist, ist dies ein No-Op. Wenn autoClose wahr ist, schließt es das Dateihandle synchron.

Gibt einen node:stream/iter-Writer zurück, der von diesem Dateihandle unterstützt wird.

Der Writer unterstützt sowohl Symbol.asyncDispose als auch Symbol.dispose

• await using w = fh.writer() — wenn der Writer noch geöffnet ist (kein end() aufgerufen), ruft asyncDispose fail() auf. Wenn end() aussteht, wartet es auf den Abschluss.
• using w = fh.writer() — ruft fail() bedingungslos auf.

Die writeSync()- und writevSync()-Methoden ermöglichen den try-sync-Fast-Path, der von stream/iter pipeTo() verwendet wird. Wenn die Chunk-Größe des Readers mit der chunkSize des Writers übereinstimmt, werden alle Schreibvorgänge in einer pipeTo()-Pipeline synchron ohne Promise-Overhead abgeschlossen.

Diese Funktion ist nur verfügbar, wenn das Flag --experimental-stream-iter aktiviert ist.

import { open } from 'node:fs/promises';
import { from, pipeTo } from 'node:stream/iter';
import { compressGzip } from 'node:zlib/iter';

// Async pipeline
const fh = await open('output.gz', 'w');
await pipeTo(from('Hello!'), compressGzip(), fh.writer({ autoClose: true }));

// Sync pipeline with limit
const src = await open('input.txt', 'r');
const dst = await open('output.txt', 'w');
const w = dst.writer({ limit: 1024 * 1024 }); // Max 1 MB
await pipeTo(src.pull({ autoClose: true }), w);
await w.end();
await dst.close();
const { open } = require('node:fs/promises');
const { from, pipeTo } = require('node:stream/iter');
const { compressGzip } = require('node:zlib/iter');

async function run() {
  // Async pipeline
  const fh = await open('output.gz', 'w');
  await pipeTo(from('Hello!'), compressGzip(), fh.writer({ autoClose: true }));

  // Sync pipeline with limit
  const src = await open('input.txt', 'r');
  const dst = await open('output.txt', 'w');
  const w = dst.writer({ limit: 1024 * 1024 }); // Max 1 MB
  await pipeTo(src.pull({ autoClose: true }), w);
  await w.end();
  await dst.close();
}

run().catch(console.error);
copy

filehandle[Symbol.asyncDispose]()#

Ruft filehandle.close() auf und gibt ein Promise zurück, das erfüllt wird, wenn das Dateihandle geschlossen ist.

fsPromises.access(path[, mode])#

• path <string> | <Buffer> | <URL>
• mode <integer> Standard: fs.constants.F_OK
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Testet die Berechtigungen eines Benutzers für die durch path angegebene Datei oder das Verzeichnis. Das mode-Argument ist eine optionale Ganzzahl, die die durchzuführenden Zugriffsprüfungen angibt. mode sollte entweder der Wert fs.constants.F_OK sein oder eine Maske, die aus der bitweisen ODER-Verknüpfung von fs.constants.R_OK, fs.constants.W_OK und fs.constants.X_OK besteht (z. B. fs.constants.W_OK | fs.constants.R_OK). Prüfen Sie Dateizugriffskonstanten für mögliche mode-Werte.

Wenn die Zugriffsprüfung erfolgreich ist, wird das Promise ohne Wert erfüllt. Wenn eine der Zugriffsprüfungen fehlschlägt, wird das Promise mit einem <Error>-Objekt abgelehnt. Das folgende Beispiel prüft, ob die Datei /etc/passwd vom aktuellen Prozess gelesen und geschrieben werden kann.

import { access, constants } from 'node:fs/promises';

try {
  await access('/etc/passwd', constants.R_OK | constants.W_OK);
  console.log('can access');
} catch {
  console.error('cannot access');
}
copy

Die Verwendung von fsPromises.access() zur Prüfung der Erreichbarkeit einer Datei vor dem Aufruf von fsPromises.open() wird nicht empfohlen. Dies führt zu einer Race-Condition, da andere Prozesse den Dateizustand zwischen den beiden Aufrufen ändern könnten. Stattdessen sollte der Benutzercode die Datei direkt öffnen/lesen/schreiben und den Fehler behandeln, falls die Datei nicht zugänglich ist.

fsPromises.appendFile(path, data[, options])#

• path <string> | <Buffer> | <URL> | <FileHandle> Dateiname oder <FileHandle>
• data <string> | <Buffer>
• options <Object> | <string>
  • encoding <string> | <null> Standard: 'utf8'
  • mode <integer> Standard: 0o666
  • flag <string> Siehe Unterstützung von Dateisystem-flags. Standard: 'a'.
  • flush <boolean> Wenn true, wird der zugrunde liegende Dateideskriptor geleert, bevor er geschlossen wird. Standard: false.
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Hängt Daten asynchron an eine Datei an und erstellt die Datei, falls sie noch nicht existiert. data kann ein String oder ein <Buffer> sein.

Wenn options ein String ist, dann spezifiziert er die encoding.

Die mode-Option betrifft nur die neu erstellte Datei. Siehe fs.open() für weitere Details.

Der path kann als <FileHandle> angegeben werden, der zum Anfügen geöffnet wurde (unter Verwendung von fsPromises.open()).

fsPromises.chmod(path, mode)#

• path <string> | <Buffer> | <URL>
• mode <string> | <integer>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert die Berechtigungen einer Datei.

fsPromises.chown(path, uid, gid)#

• path <string> | <Buffer> | <URL>
• uid <integer>
• gid <integer>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert den Besitz einer Datei.

fsPromises.copyFile(src, dest[, mode])#

• src <string> | <Buffer> | <URL> Quell-Dateiname zum Kopieren
• dest <string> | <Buffer> | <URL> Ziel-Dateiname der Kopieroperation
• mode <integer> Optionale Modifikatoren, die das Verhalten der Kopieroperation festlegen. Es ist möglich, eine Maske zu erstellen, die aus der bitweisen ODER-Verknüpfung von zwei oder mehr Werten besteht (z. B. fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE) Standard: 0.
  • fs.constants.COPYFILE_EXCL: Die Kopieroperation schlägt fehl, wenn dest bereits existiert.
  • fs.constants.COPYFILE_FICLONE: Die Kopieroperation versucht, einen Copy-on-Write-Reflink zu erstellen. Wenn die Plattform Copy-on-Write nicht unterstützt, wird ein Fallback-Kopiermechanismus verwendet.
  • fs.constants.COPYFILE_FICLONE_FORCE: Die Kopieroperation versucht, einen Copy-on-Write-Reflink zu erstellen. Wenn die Plattform Copy-on-Write nicht unterstützt, schlägt die Operation fehl.
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Kopiert src asynchron nach dest. Standardmäßig wird dest überschrieben, wenn es bereits existiert.

Es gibt keine Garantien für die Atomarität der Kopieroperation. Wenn nach dem Öffnen der Zieldatei zum Schreiben ein Fehler auftritt, wird versucht, das Ziel zu entfernen.

import { copyFile, constants } from 'node:fs/promises';

try {
  await copyFile('source.txt', 'destination.txt');
  console.log('source.txt was copied to destination.txt');
} catch {
  console.error('The file could not be copied');
}

// By using COPYFILE_EXCL, the operation will fail if destination.txt exists.
try {
  await copyFile('source.txt', 'destination.txt', constants.COPYFILE_EXCL);
  console.log('source.txt was copied to destination.txt');
} catch {
  console.error('The file could not be copied');
}
copy

fsPromises.cp(src, dest[, options])#

• src <string> | <URL> Quellpfad zum Kopieren.
• dest <string> | <URL> Zielpfad zum Kopieren.
• options <Object>
  • dereference <boolean> Dereferenzierung von symbolischen Links. Standard: false.
  • errorOnExist <boolean> wenn force false ist und das Ziel existiert, einen Fehler werfen. Standard: false.
  • filter <Function> Funktion zum Filtern kopierter Dateien/Verzeichnisse. Geben Sie true zurück, um das Element zu kopieren, false, um es zu ignorieren. Beim Ignorieren eines Verzeichnisses wird auch dessen gesamter Inhalt übersprungen. Kann auch ein Promise zurückgeben, das zu true oder false aufgelöst wird. Standard: undefined.
    • src <string> Quellpfad zum Kopieren.
    • dest <string> Zielpfad zum Kopieren.
    • Rückgabe: <boolean> | <Promise> Ein Wert, der in boolean konvertierbar ist, oder ein Promise, das zu einem solchen Wert aufgelöst wird.
  • force <boolean> Bestehende Datei oder bestehendes Verzeichnis überschreiben. Die Kopieroperation ignoriert Fehler, wenn Sie dies auf false setzen und das Ziel existiert. Verwenden Sie die errorOnExist-Option, um dieses Verhalten zu ändern. Standard: true.
  • mode <integer> Modifikatoren für die Kopieroperation. Standard: 0. Siehe mode-Flag von fsPromises.copyFile().
  • preserveTimestamps <boolean> Wenn true, werden Zeitstempel von src beibehalten. Standard: false.
  • recursive <boolean> Verzeichnisse rekursiv kopieren Standard: false
  • verbatimSymlinks <boolean> Wenn true, wird die Pfadauflösung für symbolische Links übersprungen. Standard: false
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Kopiert die gesamte Verzeichnisstruktur asynchron von src nach dest, einschließlich Unterverzeichnisse und Dateien.

Beim Kopieren eines Verzeichnisses in ein anderes Verzeichnis werden keine Globs unterstützt und das Verhalten entspricht cp dir1/ dir2/.

fsPromises.glob(pattern[, options])#

• pattern <string> | <string[]>
• options <Object>
  • cwd <string> | <URL> Aktuelles Arbeitsverzeichnis. Standard: process.cwd()
  • exclude <Function> | <string[]> Funktion zum Ausschließen von Dateien/Verzeichnissen oder eine Liste von Glob-Mustern, die ausgeschlossen werden sollen. Wenn eine Funktion bereitgestellt wird, geben Sie true zurück, um das Element auszuschließen, false, um es einzuschließen. Standard: undefined. Wenn ein String-Array bereitgestellt wird, sollte jeder String ein Glob-Muster sein, das die auszuschließenden Pfade angibt. Hinweis: Verneinungsmuster (z. B. '!foo.js') werden nicht unterstützt.
  • withFileTypes <boolean> true, wenn die Glob-Funktion Pfade als Dirents zurückgeben soll, sonst false. Standard: false.
• Rückgabe: <AsyncIterator> Ein AsyncIterator, der die Pfade von Dateien liefert, die dem Muster entsprechen.

import { glob } from 'node:fs/promises';

for await (const entry of glob('**/*.js'))
  console.log(entry);
const { glob } = require('node:fs/promises');

(async () => {
  for await (const entry of glob('**/*.js'))
    console.log(entry);
})();
copy

fsPromises.lchmod(path, mode)#

• path <string> | <Buffer> | <URL>
• mode <integer>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert die Berechtigungen für einen symbolischen Link.

Diese Methode ist nur unter macOS implementiert.

fsPromises.lchown(path, uid, gid)#

• path <string> | <Buffer> | <URL>
• uid <integer>
• gid <integer>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert den Besitz eines symbolischen Links.

fsPromises.lutimes(path, atime, mtime)#

• path <string> | <Buffer> | <URL>
• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert die Zugriffs- und Änderungszeiten einer Datei auf dieselbe Weise wie fsPromises.utimes(), mit dem Unterschied, dass, wenn der Pfad auf einen symbolischen Link verweist, der Link nicht dereferenziert wird: Stattdessen werden die Zeitstempel des symbolischen Links selbst geändert.

fsPromises.link(existingPath, newPath)#

• existingPath <string> | <Buffer> | <URL>
• newPath <string> | <Buffer> | <URL>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Erstellt eine neue Verknüpfung von existingPath zu newPath. Weitere Details finden Sie in der POSIX-Dokumentation für link(2).

fsPromises.lstat(path[, options])#

• path <string> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> Ob die numerischen Werte im zurückgegebenen <fs.Stats>-Objekt BigInt sein sollen. Standard: false.
• Rückgabe: <Promise> Erfüllt mit dem <fs.Stats>-Objekt für den angegebenen symbolischen Link path.

Entspricht fsPromises.stat(), es sei denn, path verweist auf einen symbolischen Link. In diesem Fall wird der Status des Links selbst abgefragt, nicht der der Datei, auf die er verweist. Weitere Details finden Sie im POSIX-Dokument für lstat(2).

fsPromises.mkdir(path[, options])#

• path <string> | <Buffer> | <URL>
• options <Object> | <integer>
  • recursive <boolean> Standard: false
  • mode <string> | <integer> Wird unter Windows nicht unterstützt. Siehe Dateimodus für weitere Details. Standard: 0o777.
• Rückgabe: <Promise> Bei Erfolg wird undefined zurückgegeben, wenn recursive false ist, oder der erste erstellte Verzeichnispfad, wenn recursive true ist.

Erstellt ein Verzeichnis asynchron.

Das optionale options-Argument kann eine Ganzzahl sein, die den mode (Berechtigungs- und Sticky-Bits) angibt, oder ein Objekt mit einer mode-Eigenschaft und einer recursive-Eigenschaft, die angibt, ob übergeordnete Verzeichnisse erstellt werden sollen. Der Aufruf von fsPromises.mkdir(), wenn path ein existierendes Verzeichnis ist, führt nur dann zu einer Ablehnung, wenn recursive false ist.

import { mkdir } from 'node:fs/promises';

try {
  const projectFolder = new URL('./test/project/', import.meta.url);
  const createDir = await mkdir(projectFolder, { recursive: true });

  console.log(`created ${createDir}`);
} catch (err) {
  console.error(err.message);
}
const { mkdir } = require('node:fs/promises');
const { join } = require('node:path');

async function makeDirectory() {
  const projectFolder = join(__dirname, 'test', 'project');
  const dirCreation = await mkdir(projectFolder, { recursive: true });

  console.log(dirCreation);
  return dirCreation;
}

makeDirectory().catch(console.error);
copy

fsPromises.mkdtemp(prefix[, options])#

• prefix <string> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> Standard: 'utf8'
• Rückgabe: <Promise> Erfüllt mit einem String, der den Dateisystempfad des neu erstellten temporären Verzeichnisses enthält.

Erstellt ein eindeutiges temporäres Verzeichnis. Ein eindeutiger Verzeichnisname wird durch Anhängen von sechs Zufallszeichen an das Ende des bereitgestellten prefix generiert. Aufgrund von Plattforminkonsistenzen sollten Sie nachgestellte X-Zeichen im prefix vermeiden. Einige Plattformen, insbesondere die BSDs, können mehr als sechs Zufallszeichen zurückgeben und ersetzen nachgestellte X-Zeichen im prefix durch Zufallszeichen.

Das optionale options-Argument kann ein String sein, der eine Kodierung angibt, oder ein Objekt mit einer encoding-Eigenschaft, die die zu verwendende Zeichenkodierung festlegt.

import { mkdtemp } from 'node:fs/promises';
import { join } from 'node:path';
import { tmpdir } from 'node:os';

try {
  await mkdtemp(join(tmpdir(), 'foo-'));
} catch (err) {
  console.error(err);
}
copy

Die fsPromises.mkdtemp()-Methode hängt die sechs zufällig ausgewählten Zeichen direkt an den prefix-String an. Wenn beispielsweise ein Verzeichnis /tmp gegeben ist und die Absicht besteht, ein temporäres Verzeichnis innerhalb von /tmp zu erstellen, muss das prefix mit einem nachgestellten plattformspezifischen Pfadtrenner enden (require('node:path').sep).

fsPromises.mkdtempDisposable(prefix[, options])#

• prefix <string> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> Standard: 'utf8'
• Rückgabe: <Promise> Erfüllt mit einem Promise für ein Async-disposable Objekt
  • path <string> Der Pfad des erstellten Verzeichnisses.
  • remove <AsyncFunction> Eine Funktion, die das erstellte Verzeichnis entfernt.
  • [Symbol.asyncDispose] <AsyncFunction> Das Gleiche wie remove.

Das resultierende Promise enthält ein async-disposable Objekt, dessen path-Eigenschaft den erstellten Verzeichnispfad enthält. Wenn das Objekt bereinigt (disposed) wird, werden das Verzeichnis und dessen Inhalt asynchron entfernt, falls es noch existiert. Wenn das Verzeichnis nicht gelöscht werden kann, wirft der Bereinigungsvorgang einen Fehler. Das Objekt verfügt über eine asynchrone remove()-Methode, die dieselbe Aufgabe erfüllt.

Sowohl diese Funktion als auch die Bereinigungsfunktion auf dem resultierenden Objekt sind asynchron, daher sollte sie mit await + await using verwendet werden, wie z. B. await using dir = await fsPromises.mkdtempDisposable('prefix').

Detaillierte Informationen finden Sie in der Dokumentation zu fsPromises.mkdtemp().

Das optionale options-Argument kann ein String sein, der eine Kodierung angibt, oder ein Objekt mit einer encoding-Eigenschaft, die die zu verwendende Zeichenkodierung festlegt.

fsPromises.open(path, flags[, mode])#

• path <string> | <Buffer> | <URL>
• flags <string> | <number> Siehe Unterstützung von Dateisystem-flags. Standard: 'r'.
• mode <string> | <integer> Legt den Dateimodus (Berechtigungs- und Sticky-Bits) fest, wenn die Datei erstellt wird. Siehe Dateimodus für weitere Details. Standard: 0o666 (lesbar und beschreibbar)
• Rückgabe: <Promise> Erfüllt mit einem <FileHandle>-Objekt.

Öffnet einen <FileHandle>.

Weitere Details finden Sie in der POSIX-Dokumentation für open(2).

Einige Zeichen (< > : " / \ | ? *) sind unter Windows reserviert, wie in Benennung von Dateien, Pfaden und Namespaces dokumentiert. Wenn unter NTFS der Dateiname einen Doppelpunkt enthält, öffnet Node.js einen Dateisystem-Stream, wie auf dieser MSDN-Seite beschrieben.

fsPromises.opendir(path[, options])#

• path <string> | <Buffer> | <URL>
• options <Object>
  • encoding <string> | <null> Standard: 'utf8'
  • bufferSize <number> Anzahl der Verzeichniseinträge, die beim Lesen aus dem Verzeichnis intern gepuffert werden. Höhere Werte führen zu besserer Leistung, aber höherem Speicherverbrauch. Standard: 32
  • recursive <boolean> Das aufgelöste Dir ist ein <AsyncIterable>, das alle Unterdateien und -verzeichnisse enthält. Standard: false
• Rückgabe: <Promise> Erfüllt mit einem <fs.Dir>-Objekt.

Öffnet ein Verzeichnis asynchron für das iterative Scannen. Weitere Details finden Sie in der POSIX-Dokumentation für opendir(3).

Erstellt ein <fs.Dir>-Objekt, das alle weiteren Funktionen zum Lesen und Bereinigen des Verzeichnisses enthält.

Die encoding-Option legt die Kodierung für den path beim Öffnen des Verzeichnisses und für nachfolgende Lesevorgänge fest.

Beispiel mit asynchroner Iteration

import { opendir } from 'node:fs/promises';

try {
  const dir = await opendir('./');
  for await (const dirent of dir)
    console.log(dirent.name);
} catch (err) {
  console.error(err);
}
copy

Bei Verwendung des asynchronen Iterators wird das <fs.Dir>-Objekt nach dem Beenden des Iterators automatisch geschlossen.

fsPromises.readdir(path[, options])#

• path <string> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> Standard: 'utf8'
  • withFileTypes <boolean> Standard: false
  • recursive <boolean> Wenn true, wird der Inhalt eines Verzeichnisses rekursiv gelesen. Im rekursiven Modus werden alle Dateien, Unterdateien und Verzeichnisse aufgelistet. Standard: false.
• Rückgabe: <Promise> Erfüllt mit einem Array der Namen der Dateien im Verzeichnis, ohne '.' und '..'.

Liest den Inhalt eines Verzeichnisses.

Das optionale options-Argument kann ein String sein, der eine Kodierung angibt, oder ein Objekt mit einer encoding-Eigenschaft, die die für die Dateinamen zu verwendende Zeichenkodierung festlegt. Wenn encoding auf 'buffer' gesetzt ist, werden die zurückgegebenen Dateinamen als <Buffer>-Objekte übergeben.

Wenn options.withFileTypes auf true gesetzt ist, enthält das zurückgegebene Array <fs.Dirent>-Objekte.

import { readdir } from 'node:fs/promises';

try {
  const files = await readdir(path);
  for (const file of files)
    console.log(file);
} catch (err) {
  console.error(err);
}
copy

fsPromises.readFile(path[, options])#

• path <string> | <Buffer> | <URL> | <FileHandle> Dateiname oder FileHandle
• options <Object> | <string>
  • encoding <string> | <null> Standard: null
  • flag <string> Siehe Unterstützung von Dateisystem-flags. Standard: 'r'.
  • signal <AbortSignal> erlaubt das Abbrechen eines laufenden readFile-Vorgangs
• Rückgabe: <Promise> Erfüllt mit dem Inhalt der Datei.

Liest den gesamten Inhalt einer Datei asynchron.

Wenn keine Kodierung angegeben ist (unter Verwendung von options.encoding), werden die Daten als <Buffer>-Objekt zurückgegeben. Andernfalls sind die Daten ein String.

Wenn options ein String ist, dann spezifiziert er die Kodierung.

Wenn der path ein Verzeichnis ist, ist das Verhalten von fsPromises.readFile() plattformspezifisch. Unter macOS, Linux und Windows wird das Promise mit einem Fehler abgelehnt. Unter FreeBSD wird eine Darstellung des Inhalts des Verzeichnisses zurückgegeben.

Ein Beispiel zum Lesen einer package.json-Datei, die sich im selben Verzeichnis wie der ausgeführte Code befindet

import { readFile } from 'node:fs/promises';
try {
  const filePath = new URL('./package.json', import.meta.url);
  const contents = await readFile(filePath, { encoding: 'utf8' });
  console.log(contents);
} catch (err) {
  console.error(err.message);
}
const { readFile } = require('node:fs/promises');
const { resolve } = require('node:path');
async function logFile() {
  try {
    const filePath = resolve('./package.json');
    const contents = await readFile(filePath, { encoding: 'utf8' });
    console.log(contents);
  } catch (err) {
    console.error(err.message);
  }
}
logFile();
copy

Es ist möglich, ein laufendes readFile mit einem <AbortSignal> abzubrechen. Wenn eine Anfrage abgebrochen wird, wird das zurückgegebene Promise mit einem AbortError abgelehnt

import { readFile } from 'node:fs/promises';

try {
  const controller = new AbortController();
  const { signal } = controller;
  const promise = readFile(fileName, { signal });

  // Abort the request before the promise settles.
  controller.abort();

  await promise;
} catch (err) {
  // When a request is aborted - err is an AbortError
  console.error(err);
}
copy

Das Abbrechen einer laufenden Anfrage bricht nicht die einzelnen Betriebssystemanfragen ab, sondern das interne Puffern, das fs.readFile durchführt.

Jedes angegebene <FileHandle> muss das Lesen unterstützen.

fsPromises.readlink(path[, options])#

• path <string> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> Standard: 'utf8'
• Rückgabe: <Promise> Wird bei Erfolg mit dem linkString erfüllt.

Liest den Inhalt des symbolischen Links, auf den path verweist. Siehe die POSIX readlink(2)-Dokumentation für weitere Details. Das Promise wird bei Erfolg mit dem linkString erfüllt.

Das optionale options-Argument kann ein String sein, der eine Codierung angibt, oder ein Objekt mit einer encoding-Eigenschaft, die die für den zurückgegebenen Link-Pfad zu verwendende Zeichencodierung festlegt. Wenn die encoding auf 'buffer' gesetzt ist, wird der zurückgegebene Link-Pfad als <Buffer>-Objekt übergeben.

fsPromises.realpath(path[, options])#

• path <string> | <Buffer> | <URL>
• options <string> | <Object>
  • encoding <string> Standard: 'utf8'
• Rückgabe: <Promise> Wird bei Erfolg mit dem aufgelösten Pfad erfüllt.

Bestimmt den tatsächlichen Speicherort von path unter Verwendung derselben Semantik wie die Funktion fs.realpath.native().

Es werden nur Pfade unterstützt, die in UTF-8-Strings konvertiert werden können.

Das optionale options-Argument kann ein String sein, der eine Codierung angibt, oder ein Objekt mit einer encoding-Eigenschaft, die die für den Pfad zu verwendende Zeichencodierung festlegt. Wenn die encoding auf 'buffer' gesetzt ist, wird der zurückgegebene Pfad als <Buffer>-Objekt übergeben.

Wenn Node.js unter Linux mit der musl-libc verknüpft ist, muss das procfs-Dateisystem unter /proc eingehängt sein, damit diese Funktion funktioniert. Glibc hat diese Einschränkung nicht.

fsPromises.rename(oldPath, newPath)#

• oldPath <string> | <Buffer> | <URL>
• newPath <string> | <Buffer> | <URL>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Benennt oldPath in newPath um.

fsPromises.rmdir(path[, options])#

• path <string> | <Buffer> | <URL>
• options <Object> Es sind derzeit keine Optionen verfügbar. Es gab früher Optionen für recursive, maxBusyTries und emfileWait, diese wurden jedoch als veraltet markiert und entfernt. Das options-Argument wird aus Gründen der Abwärtskompatibilität weiterhin akzeptiert, aber nicht verwendet.
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Entfernt das durch path identifizierte Verzeichnis.

Die Verwendung von fsPromises.rmdir() auf eine Datei (kein Verzeichnis) führt dazu, dass das Promise mit einem ENOENT-Fehler unter Windows und einem ENOTDIR-Fehler unter POSIX abgelehnt wird.

Um ein Verhalten ähnlich dem Unix-Befehl rm -rf zu erhalten, verwenden Sie fsPromises.rm() mit den Optionen { recursive: true, force: true }.

fsPromises.rm(path[, options])#

• path <string> | <Buffer> | <URL>
• options <Object>
  • force <boolean> Wenn true, werden Ausnahmen ignoriert, wenn path nicht existiert. Standard: false.
  • maxRetries <integer> Wenn ein EBUSY-, EMFILE-, ENFILE-, ENOTEMPTY- oder EPERM-Fehler auftritt, wiederholt Node.js den Vorgang mit einem linearen Backoff-Warten von retryDelay Millisekunden länger bei jedem Versuch. Diese Option repräsentiert die Anzahl der Wiederholungen. Diese Option wird ignoriert, wenn die Option recursive nicht true ist. Standard: 0.
  • recursive <boolean> Wenn true, wird ein rekursives Verzeichnis-Entfernen durchgeführt. Im rekursiven Modus werden Vorgänge bei Fehlern wiederholt. Standard: false.
  • retryDelay <integer> Die Zeitspanne in Millisekunden, die zwischen Wiederholungsversuchen gewartet werden soll. Diese Option wird ignoriert, wenn die Option recursive nicht true ist. Standard: 100.
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Entfernt Dateien und Verzeichnisse (modelliert nach dem Standard-POSIX-Dienstprogramm rm).

fsPromises.stat(path[, options])#

• path <string> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> Ob die numerischen Werte im zurückgegebenen <fs.Stats>-Objekt BigInt sein sollen. Standard: false.
  • throwIfNoEntry <boolean> Gibt an, ob eine Ausnahme ausgelöst wird, wenn kein Dateisystemeintrag existiert, anstatt undefined zurückzugeben. Standard: true.
• Rückgabe: <Promise> Wird bei Erfolg mit dem <fs.Stats>-Objekt für den angegebenen path erfüllt.

fsPromises.statfs(path[, options])#

• path <string> | <Buffer> | <URL>
• options <Object>
  • bigint <boolean> Gibt an, ob die numerischen Werte im zurückgegebenen <fs.StatFs>-Objekt bigint sein sollen. Standard: false.
• Rückgabe: <Promise> Wird bei Erfolg mit dem <fs.StatFs>-Objekt für den angegebenen path erfüllt.

fsPromises.symlink(target, path[, type])#

• target <string> | <Buffer> | <URL>
• path <string> | <Buffer> | <URL>
• type <string> | <null> Standard: null
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Erstellt einen symbolischen Link.

Das type-Argument wird nur auf Windows-Plattformen verwendet und kann 'dir', 'file' oder 'junction' sein. Wenn das type-Argument null ist, erkennt Node.js den Typ von target automatisch und verwendet 'file' oder 'dir'. Wenn das target nicht existiert, wird 'file' verwendet. Windows-Verknüpfungspunkte (Junctions) erfordern, dass der Zielpfad absolut ist. Bei Verwendung von 'junction' wird das target-Argument automatisch zu einem absoluten Pfad normalisiert. Verknüpfungspunkte auf NTFS-Volumes können nur auf Verzeichnisse zeigen.

fsPromises.truncate(path[, len])#

• path <string> | <Buffer> | <URL>
• len <integer> Standard: 0
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Kürzt den Inhalt bei path auf len Bytes (verkürzt oder erweitert die Länge).

fsPromises.unlink(path)#

• path <string> | <Buffer> | <URL>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Wenn path auf einen symbolischen Link verweist, wird der Link entfernt, ohne die Datei oder das Verzeichnis zu beeinflussen, auf das dieser Link verweist. Wenn path auf einen Dateipfad verweist, der kein symbolischer Link ist, wird die Datei gelöscht. Siehe die POSIX unlink(2)-Dokumentation für weitere Details.

fsPromises.utimes(path, atime, mtime)#

• path <string> | <Buffer> | <URL>
• atime <number> | <string> | <Date>
• mtime <number> | <string> | <Date>
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Ändert die Dateisystem-Zeitstempel des Objekts, auf das path verweist.

Die Argumente atime und mtime folgen diesen Regeln:

• Werte können entweder Zahlen sein, die die Unix-Epochenzeit darstellen, Date-Objekte oder ein numerischer String wie '123456789.0'.
• Wenn der Wert nicht in eine Zahl konvertiert werden kann oder NaN, Infinity oder -Infinity ist, wird ein Error ausgelöst.

fsPromises.watch(filename[, options])#

• filename <string> | <Buffer> | <URL>
• options <string> | <Object>
  • persistent <boolean> Gibt an, ob der Prozess weiterlaufen soll, solange Dateien beobachtet werden. Standard: true.
  • recursive <boolean> Gibt an, ob alle Unterverzeichnisse beobachtet werden sollen oder nur das aktuelle Verzeichnis. Dies gilt, wenn ein Verzeichnis angegeben ist, und nur auf unterstützten Plattformen (siehe Caveats). Standard: false.
  • encoding <string> Gibt die Zeichencodierung an, die für den an den Listener übergebenen Dateinamen verwendet werden soll. Standard: 'utf8'.
  • signal <AbortSignal> Ein <AbortSignal>, das verwendet wird, um zu signalisieren, wann der Beobachter stoppen soll.
  • maxQueue <number> Gibt die Anzahl der Ereignisse an, die zwischen Iterationen des zurückgegebenen <AsyncIterator> in die Warteschlange gestellt werden sollen. Standard: 2048.
  • overflow <string> Entweder 'ignore' oder 'throw', wenn mehr Ereignisse in die Warteschlange gestellt werden sollen, als maxQueue erlaubt. 'ignore' bedeutet, dass Overflow-Ereignisse verworfen werden und eine Warnung ausgegeben wird, während 'throw' bedeutet, dass eine Ausnahme ausgelöst wird. Standard: 'ignore'.
  • ignore <string> | <RegExp> | <Function> | <Array> Zu ignorierende Muster. Strings sind Glob-Muster (unter Verwendung von minimatch), RegExp-Muster werden gegen den Dateinamen geprüft, und Funktionen erhalten den Dateinamen und geben true zurück, um ihn zu ignorieren. Standard: undefined.
• Rückgabe: <AsyncIterator> von Objekten mit den Eigenschaften
• eventType <string> Der Typ der Änderung
• filename <string> | <Buffer> | <null> Der Name der geänderten Datei.

Gibt einen asynchronen Iterator zurück, der Änderungen an filename beobachtet, wobei filename entweder eine Datei oder ein Verzeichnis ist.

const { watch } = require('node:fs/promises');

const ac = new AbortController();
const { signal } = ac;
setTimeout(() => ac.abort(), 10000);

(async () => {
  try {
    const watcher = watch(__filename, { signal });
    for await (const event of watcher)
      console.log(event);
  } catch (err) {
    if (err.name === 'AbortError')
      return;
    throw err;
  }
})();
copy

Auf den meisten Plattformen wird 'rename' ausgegeben, wenn ein Dateiname im Verzeichnis erscheint oder verschwindet.

Alle Caveats für fs.watch() gelten auch für fsPromises.watch().

fsPromises.writeFile(file, data[, options])#

• file <string> | <Buffer> | <URL> | <FileHandle> Dateiname oder FileHandle
• data <string> | <Buffer> | <TypedArray> | <DataView> | <AsyncIterable> | <Iterable> | <Stream>
• options <Object> | <string>
  • encoding <string> | <null> Standard: 'utf8'
  • mode <integer> Standard: 0o666
  • flag <string> Siehe Unterstützung von Dateisystem-flags. Standard: 'w'.
  • flush <boolean> Wenn alle Daten erfolgreich in die Datei geschrieben wurden und flush auf true gesetzt ist, wird filehandle.sync() verwendet, um die Daten zu flushen. Standard: false.
  • signal <AbortSignal> erlaubt das Abbrechen eines laufenden writeFile-Vorgangs
• Rückgabe: <Promise> Wird bei Erfolg mit undefined erfüllt.

Schreibt Daten asynchron in eine Datei und ersetzt die Datei, falls sie bereits existiert. data kann ein String, ein Puffer, ein <AsyncIterable> oder ein <Iterable>-Objekt sein.

Die Option encoding wird ignoriert, wenn data ein Puffer ist.

Wenn options ein String ist, dann spezifiziert er die Kodierung.

Die mode-Option betrifft nur die neu erstellte Datei. Siehe fs.open() für weitere Details.

Jedes angegebene <FileHandle> muss das Schreiben unterstützen.

Es ist unsicher, fsPromises.writeFile() mehrfach auf dieselbe Datei anzuwenden, ohne auf den Abschluss des Promises zu warten.

Ähnlich wie fsPromises.readFile ist fsPromises.writeFile eine Komfortmethode, die intern mehrere write-Aufrufe durchführt, um den übergebenen Puffer zu schreiben. Erwägen Sie für leistungskritischen Code die Verwendung von fs.createWriteStream() oder filehandle.createWriteStream().

Es ist möglich, ein <AbortSignal> zu verwenden, um ein fsPromises.writeFile() abzubrechen. Der Abbruch ist ein "Best-Effort"-Vorgang, und es ist wahrscheinlich, dass bereits eine gewisse Menge an Daten geschrieben wurde.

import { writeFile } from 'node:fs/promises';
import { Buffer } from 'node:buffer';

try {
  const controller = new AbortController();
  const { signal } = controller;
  const data = new Uint8Array(Buffer.from('Hello Node.js'));
  const promise = writeFile('message.txt', data, { signal });

  // Abort the request before the promise settles.
  controller.abort();

  await promise;
} catch (err) {
  // When a request is aborted - err is an AbortError
  console.error(err);
}
copy

Das Abbrechen einer laufenden Anfrage bricht nicht die einzelnen Betriebssystemanfragen ab, sondern das interne Puffern, das fs.writeFile durchführt.

fsPromises.constants#

• Typ: <Object>

Gibt ein Objekt zurück, das häufig verwendete Konstanten für Dateisystemoperationen enthält. Das Objekt ist identisch mit fs.constants. Weitere Einzelheiten finden Sie unter FS-Konstanten.

Callback-API#

Die Callback-APIs führen alle Operationen asynchron aus, ohne die Event-Loop zu blockieren, und rufen dann eine Callback-Funktion nach Abschluss oder Fehler auf.

Die Callback-APIs verwenden den zugrunde liegenden Node.js-Threadpool, um Dateisystemoperationen außerhalb des Event-Loop-Threads auszuführen. Diese Operationen sind nicht synchronisiert oder threadsicher. Es ist Vorsicht geboten, wenn mehrere gleichzeitige Modifikationen an derselben Datei vorgenommen werden, da es sonst zu Datenbeschädigungen kommen kann.

fs.access(path[, mode], callback)#

• path <string> | <Buffer> | <URL>
• mode <integer> Standard: fs.constants.F_OK
• callback <Function>
  • err <Error>

Testet die Berechtigungen eines Benutzers für die durch path angegebene Datei oder das Verzeichnis. Das mode-Argument ist eine optionale Ganzzahl, die die durchzuführenden Zugriffsprüfungen angibt. mode sollte entweder der Wert fs.constants.F_OK sein oder eine Maske, die aus der bitweisen ODER-Verknüpfung von fs.constants.R_OK, fs.constants.W_OK und fs.constants.X_OK besteht (z. B. fs.constants.W_OK | fs.constants.R_OK). Prüfen Sie Dateizugriffskonstanten für mögliche mode-Werte.

Das letzte Argument, callback, ist eine Callback-Funktion, die mit einem möglichen Fehlerargument aufgerufen wird. Wenn eine der Zugriffsprüfungen fehlschlägt, ist das Fehlerargument ein Error-Objekt. Die folgenden Beispiele prüfen, ob package.json existiert und ob es lesbar oder schreibbar ist.

import { access, constants } from 'node:fs';

const file = 'package.json';

// Check if the file exists in the current directory.
access(file, constants.F_OK, (err) => {
  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);
});

// Check if the file is readable.
access(file, constants.R_OK, (err) => {
  console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);
});

// Check if the file is writable.
access(file, constants.W_OK, (err) => {
  console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);
});

// Check if the file is readable and writable.
access(file, constants.R_OK | constants.W_OK, (err) => {
  console.log(`${file} ${err ? 'is not' : 'is'} readable and writable`);
});
copy

Verwenden Sie nicht fs.access(), um die Zugänglichkeit einer Datei zu prüfen, bevor Sie fs.open(), fs.readFile() oder fs.writeFile() aufrufen. Dies führt zu einer Race-Condition, da andere Prozesse den Status der Datei zwischen den beiden Aufrufen ändern könnten. Stattdessen sollte der Benutzercode die Datei direkt öffnen/lesen/schreiben und den Fehler behandeln, falls die Datei nicht zugänglich ist.

Schreiben (NICHT EMPFOHLEN)

import { access, open, close } from 'node:fs';

access('myfile', (err) => {
  if (!err) {
    console.error('myfile already exists');
    return;
  }

  open('myfile', 'wx', (err, fd) => {
    if (err) throw err;

    try {
      writeMyData(fd);
    } finally {
      close(fd, (err) => {
        if (err) throw err;
      });
    }
  });
});
copy

Schreiben (EMPFOHLEN)

import { open, close } from 'node:fs';

open('myfile', 'wx', (err, fd) => {
  if (err) {
    if (err.code === 'EEXIST') {
      console.error('myfile already exists');
      return;
    }

    throw err;
  }

  try {
    writeMyData(fd);
  } finally {
    close(fd, (err) => {
      if (err) throw err;
    });
  }
});
copy

Lesen (NICHT EMPFOHLEN)

import { access, open, close } from 'node:fs';
access('myfile', (err) => {
  if (err) {
    if (err.code === 'ENOENT') {
      console.error('myfile does not exist');
      return;
    }

    throw err;
  }

  open('myfile', 'r', (err, fd) => {
    if (err) throw err;

    try {
      readMyData(fd);
    } finally {
      close(fd, (err) => {
        if (err) throw err;
      });
    }
  });
});
copy

Lesen (EMPFOHLEN)

import { open, close } from 'node:fs';

open('myfile', 'r', (err, fd) => {
  if (err) {
    if (err.code === 'ENOENT') {
      console.error('myfile does not exist');
      return;
    }

    throw err;
  }

  try {
    readMyData(fd);
  } finally {
    close(fd, (err) => {
      if (err) throw err;
    });
  }
});
copy

Die "nicht empfohlenen" Beispiele oben prüfen auf Zugänglichkeit und verwenden dann die Datei; die "empfohlenen" Beispiele sind besser, weil sie die Datei direkt verwenden und den Fehler, falls vorhanden, behandeln.

Prüfen Sie die Zugänglichkeit einer Datei im Allgemeinen nur, wenn die Datei nicht direkt verwendet wird, zum Beispiel wenn ihre Zugänglichkeit ein Signal von einem anderen Prozess ist.

Unter Windows können Zugriffssteuerungsrichtlinien (ACLs) für ein Verzeichnis den Zugriff auf eine Datei oder ein Verzeichnis einschränken. Die Funktion fs.access() prüft jedoch nicht die ACL und kann daher melden, dass ein Pfad zugänglich ist, selbst wenn die ACL den Benutzer daran hindert, ihn zu lesen oder zu schreiben.