File system (FS) di Node.js

Node.js FS

Node FS è un modulo integrato di Node.js che ti aiuta a gestire e operare sui file.

Operazioni sui file NodeJs FS

Utilizzando Node FS, puoi eseguire le seguenti operazioni sui file:

• Lettura del file

• Crea o sovrascrive il file

• Aggiorna il file

• Eliminazione del file

• Rinomina il file

Node.js fornisce un insieme di API di operazioni su file simili allo standard UNIX (POSIX). La sintassi di importazione del modulo di sistema di file Node.js (fs) è come segue:

var fs = require("fs")

Asincrono e sincrono

Il modulo fs del sistema di file Node.js (modulo fs) offre metodi sia asincroni che sincroni, ad esempio, le funzioni di lettura del contenuto del file hanno fs.readFile() asincrono e fs.readFileSync() sincrono.

L'ultimo parametro del metodo asincrono è la funzione di callback, il primo parametro della funzione di callback contiene le informazioni di errore (error).

Si consiglia di utilizzare il metodo asincrono, poiché rispetto al sincrono, il metodo asincrono ha prestazioni migliori e velocità più elevate, e non blocca.

Esempio

Crea il file 'input.txt' con il seguente contenuto:

Official tutorial website address: it.oldtoolbag.com
Esempio di lettura del file

Crea il file 'file.js' con il seguente codice:

var fs = require("fs");
// 异步读取
fs.readFile('input.txt', function(err, data) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("异步读取: " + data.toString());
});
// 阅读文件同步
var data = fs.readFileSync('input.txt');
console.log("Lettura sincrona: " + data.toString());
console.log("Fine dell'esecuzione del programma.");

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Lettura sincrona: Indirizzo del tutorial di base: it.oldtoolbag.com
Esempio di lettura del file
Fine dell'esecuzione del programma.
Lettura asincrona: Indirizzo del tutorial di base: it.oldtoolbag.com
Esempio di lettura del file

Ora, diamo un'occhiata più da vicino ai metodi del sistema di file di Node.js.

Apri il file

Sintassi

Ecco il formato di sintassi per aprire un file in modo asincrono:

fs.open(path, flags[, mode], callback)

Parametro

Ecco la descrizione dell'uso dei parametri:

• path - Percorso del file.

• flags - Comportamento dell'apertura del file. Vedi i valori dettagliati di seguito.

• modalità - Imposta il modello di file (permessi), il permesso predefinito per la creazione del file è 0666 (leggibile, scrivibile).

• callback - Funzione di callback con due parametri come: callback(err, fd).

Il parametro flags può essere uno dei seguenti valori:

Esempio

Creiamo il file file.js e apriamo il file input.txt per leggere e scrivere, come segue:

var fs = require("fs");
// Apertura asincrona del file
console.log("Preparing to open the file!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　console.log("File opened successfully!");　　　　　
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparazione per aprire il file!
Apertura del file completata con successo!

Ottieni informazioni sul file

Sintassi

Ecco il formato di sintassi per ottenere informazioni sul file in modo asincrono:

fs.stat(path, callback)

Parametro

Ecco la descrizione dell'uso dei parametri:

• path - Percorso del file.

• callback - Funzione di callback con due parametri come: (err, stats), stats È un oggetto fs.Stats.

Dopo l'esecuzione di fs.stat(path), restituirà un'istanza della classe Stats al suo callback. Puoi utilizzare i metodi forniti dalla classe Stats per determinare le proprietà del file. Ad esempio, per determinare se è un file:

var fs = require('fs');
fs.stat('/Users/liuht/code/itbilu/demo/fs.js', function err, stats) {
　　　　console.log(stats.isFile()); // true
}

I metodi della classe stats sono:

Esempio

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
console.log("Preparing to open the file!");
fs.stat('input.txt', function err, stats) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log(stats);
　　　console.log("Informazioni sul file lette con successo!");
　　　
　　　// Verifica il tipo di file
　　　console.log("È un file (isFile) ? " + stats.isFile());
　　　console.log("È una directory (isDirectory) ? " + stats.isDirectory());　　　　
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparazione per aprire il file!
{ dev: 16777220,
　　mode: 33188,
　　nlink: 1,
　　uid: 501,
　　gid: 20,
　　rdev: 0,
　　blksize: 4096,
　　ino: 40333161,
　　size: 61,
　　blocks: 8,
　　atime: Lun Mar 07 2015 17:43:55 GMT+0800 (CST),
　　mtime: Lun Mar 07 2015 17:22:35 GMT+0800 (CST),
　　ctime: Lun Mar 07 2015 17:22:35 GMT+0800 (CST)
Informazioni sul file lette con successo!
È un file (isFile) ? true
È una directory (isDirectory) ? false

Scrittura del file

Sintassi

Ecco il formato della sintassi di scrittura del file in modalità asincrona:

fs.writeFile(file, data[, options], callback)

L'apertura del file diretto tramite writeFile è predefinito a w modalità, quindi se il file esiste, il contenuto scritto da questo metodo sovrascriverà il contenuto del file vecchio.

Parametro

Ecco la descrizione dell'uso dei parametri:

• file - Il nome del file o il descrittore del file.

• data - I dati da scrivere nel file, può essere un oggetto String (stringa) o Buffer (buffer).

• options - Il parametro è un oggetto che contiene {encoding, mode, flag}. L'encoding predefinito è utf8, il modello è 0666 e il flag è 'w'.

• callback - La funzione di callback, la funzione di callback contiene solo il parametro dell'errore (err) e viene restituito quando la scrittura fallisce.

Esempio

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
console.log("Preparazione della scrittura del file");
fs.writeFile('input.txt', 'Il contenuto del file scritto tramite fs.writeFile', function(err) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Scrittura dei dati avvenuta con successo!");
　　　console.log("--------Siamo alla fine della riga-------------")
　　　console.log("Lettura dei dati scritti!");
　　　fs.readFile('input.txt', function(err, data) {
　　　　　　if(err) {
　　　　　　　　　return console.error(err);
　　　　　　}
　　　　　　console.log("Lettura dei dati del file in modalità asincrona: " + data.toString());
　　　});
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparazione della scrittura del file
Scrittura dei dati avvenuta con successo!
--------Siamo alla fine della riga-------------
Lettura dei dati scritti!
Lettura dei dati del file in modalità asincrona: il contenuto del file scritto tramite fs.writeFile

Lettura del file

Sintassi

Ecco il formato della sintassi di lettura del file in modalità asincrona:

fs.read(fd, buffer, offset, length, position, callback)

This method uses a file descriptor to read the file.

Parametro

Ecco la descrizione dell'uso dei parametri:

• fd - File descriptor returned by the fs.open() method.

• buffer - Il buffer in cui i dati vengono scritti.

• offset - L'offset di scrittura nel buffer.

• length - Il numero di byte da leggere dal file.

• position - La posizione di inizio della lettura del file, se il valore di position è null, verrà letto dalla posizione corrente del puntatore del file.

• callback - Callback function, with three parameters err, bytesRead, buffer, err is the error message, bytesRead indicates the number of bytes read, buffer is the buffer object.

Esempio

Il contenuto del file input.txt è:

Official tutorial website address: it.oldtoolbag.com

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
var buf = new Buffer.alloc(1024);
console.log("Preparing to open an existing file!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("File opened successfully!");
　　　console.log("Preparing to read the file:");
　　　fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}
　　　　　　console.log(bytes + "    bytes were read");
　　　　　　
　　　　　　// Only output the read bytes
　　　　　　if (bytes > 0) {
　　　　　　　　　console.log(buf.slice(0, bytes).toString());
　　　　　　}
　　　});
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparing to open an existing file!
Apertura del file completata con successo!
Preparing to read the file:
42 bytes were read
Official tutorial website address: it.oldtoolbag.com

Close file

Sintassi

The following is the syntax format for closing files in asynchronous mode:

fs.close(fd, callback)

This method uses a file descriptor to read the file.

Parametro

Ecco la descrizione dell'uso dei parametri:

• fd - File descriptor returned by the fs.open() method.

• callback - Funzione di callback, senza parametri.

Esempio

Il contenuto del file input.txt è:

Official tutorial website address: it.oldtoolbag.com

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
var buf = new Buffer.alloc(1024);
console.log("Preparing to open the file!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("File opened successfully!");
　　　console.log("Preparing to read the file!");
　　　fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}
　　　　　　// Only output the read bytes
　　　　　　if (bytes > 0) {
　　　　　　　　　console.log(buf.slice(0, bytes).toString());
　　　　　　}
　　　　　　// Close the file
　　　　　　fs.close(fd, function(err) {
　　　　　　　　　if (err) {
　　　　　　　　　　　　console.log(err);
　　　　　　　　　}　
　　　　　　　　　console.log("File closed successfully");
　　　　　　});
　　　});
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparazione per aprire il file!
Apertura del file completata con successo!
Preparing to read the file!
Official tutorial website address: it.oldtoolbag.com
Chiusura del file completata con successo

Truncate file

Sintassi

The following is the syntax format for truncating files in asynchronous mode:

fs.ftruncate(fd, len, callback)

This method uses a file descriptor to read the file.

Parametro

Ecco la descrizione dell'uso dei parametri:

• fd - File descriptor returned by the fs.open() method.

• len - Length of file content truncation.

• callback - Funzione di callback, senza parametri.

Esempio

Il contenuto del file input.txt è:

sito:it.oldtoolbag.com

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
var buf = new Buffer.alloc(1024);
console.log("Preparing to open the file!");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("File opened successfully!");
　　　console.log("Truncate the file content within 10 bytes, the exceeding part will be removed.");
　　　
　　　// Truncate the file
　　　fs.ftruncate(fd, 10, function(err) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}　
　　　　　　console.log("File truncation successful.");
　　　　　　console.log("Read the same file");　
　　　　　　fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
　　　　　　　　　if (err) {
　　　　　　　　　　　　console.log(err);
　　　　　　　　　}
　　　　　　　　　// Only output the read bytes
　　　　　　　　　if (bytes > 0) {
　　　　　　　　　　　　console.log(buf.slice(0, bytes).toString());
　　　　　　　　　}
　　　　　　　　　// Close the file
　　　　　　　　　fs.close(fd, function(err) {
　　　　　　　　　　　　if (err) {
　　　　　　　　　　　　　　　console.log(err);
　　　　　　　　　　　　}　
　　　　　　　　　　　　console.log("File closed successfully!");
　　　　　　　　　});
　　　　　　});
　　　});
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparazione per aprire il file!
Apertura del file completata con successo!
Tagliare i primi 10 byte del contenuto del file, la parte in eccesso verrà rimossa.
Ritrazione del file completata con successo.
Leggere lo stesso file
sito:www.r
Chiusura del file completata con successo

Eliminazione del file

Sintassi

Di seguito è riportato il formato sintattico per l'eliminazione del file:

fs.unlink(path, callback)

Parametro

Ecco la descrizione dell'uso dei parametri:

• path - Percorso del file.

• callback - Funzione di callback, senza parametri.

Esempio

Il contenuto del file input.txt è:

sito:it.oldtoolbag.com

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
console.log("Preparazione per eliminare il file!");
fs.unlink('input.txt', function(err) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Eliminazione del file completata con successo!");
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparazione per eliminare il file!
Eliminazione del file completata con successo!

Poi controllare il file input.txt, scoprire che non esiste più.

Creazione della directory

Sintassi

Di seguito è riportato il formato sintattico per la creazione della directory:

fs.mkdir(path[, options], callback)

Parametro

Ecco la descrizione dell'uso dei parametri:

• path - Percorso del file.

• Il parametro options può essere:

• recursive - Creare la directory in modo ricorsivo, il valore predefinito è false.

• modalità - Impostare i permessi della directory, il valore predefinito è 0777.

• callback - Funzione di callback, senza parametri.

Esempio

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
// La directory /tmp deve esistere
console.log("Creare la directory /tmp/test/");
fs.mkdir("/tmp/test/", function(err) {
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Creazione della directory completata con successo.");
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Creare la directory /tmp/test/
Creazione della directory completata con successo.

Puoi aggiungere il parametro recursive: true, indipendentemente dal fatto che le directory /tmp e /tmp/a esistano o meno:

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
　　if (err) throw err;
});

Lettura della directory

Sintassi

Di seguito è riportato il formato sintattico per la lettura della directory:

fs.readdir(path, callback)

Parametro

Ecco la descrizione dell'uso dei parametri:

• path - Percorso del file.

• callback - Funzione di callback, la funzione di callback accetta due parametri err, files, err è l'informazione di errore, files è l'array di liste dei file nella directory.

Esempio

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
console.log("Visualizzare la directory /tmp");
fs.readdir("/tmp/",function(err, files){
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　files.forEach(function(file){
　　　　　　　console.log(file);
　　　});
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Visualizzare la directory /tmp
input.out
output.out
test
test.txt

Rimozione della directory

Sintassi

Di seguito è riportato il formato sintattico per la rimozione della directory:

fs.rmdir(path, callback)

Parametro

Ecco la descrizione dell'uso dei parametri:

• path - Percorso del file.

• callback - Funzione di callback, senza parametri.

Esempio

Creiamo il file file.js con il seguente codice:

var fs = require("fs");
// Crea una directory vuota /tmp/test prima dell'esecuzione
console.log("Preparati a eliminare la directory /tmp/test");
fs.rmdir("/tmp/test",function(err){
　　　if(err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Leggi la directory /tmp");
　　　fs.readdir("/tmp/",function(err, files){
　　　　　　if(err) {
　　　　　　　　　　return console.error(err);
　　　　　　}
　　　　　　files.forEach(function(file){
　　　　　　　　　　console.log(file);
　　　　　　});
　　　});
});

Il risultato dell'esecuzione del codice sopra è il seguente:

$ node file.js　
Preparati a eliminare la directory /tmp/test
Leggi la directory /tmp
……

Manuale di riferimento dei metodi del modulo file

Ecco l'elenco dei metodi dello stesso modulo file di Node.js:

Per ulteriori informazioni, consultare la descrizione del modulo file sul sito ufficiale:File System.