Node.js - File System
Il nodo implementa l'I / O di file utilizzando semplici wrapper attorno alle funzioni POSIX standard. Il modulo Node File System (fs) può essere importato utilizzando la seguente sintassi:
var fs = require("fs")Sincrono vs asincrono
Ogni metodo nel modulo fs ha forme sincrone e asincrone. I metodi asincroni accettano l'ultimo parametro come callback della funzione di completamento e il primo parametro della funzione callback come errore. È preferibile utilizzare un metodo asincrono invece di un metodo sincrono, poiché il primo non blocca mai un programma durante la sua esecuzione, mentre il secondo lo fa.
Esempio
Crea un file di testo denominato input.txt con il seguente contenuto -
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!Creiamo un file js denominato main.js con il seguente codice -
var fs = require("fs");
// Asynchronous read
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchronous read: " + data.toString());
});
// Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());
console.log("Program Ended");Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Synchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Program Ended
Asynchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!Le sezioni seguenti di questo capitolo forniscono una serie di buoni esempi sui principali metodi di I / O di file.
Apri un file
Sintassi
Di seguito è riportata la sintassi del metodo per aprire un file in modalità asincrona:
fs.open(path, flags[, mode], callback)Parametri
Ecco la descrizione dei parametri utilizzati:
path - Questa è la stringa con il nome del file incluso il percorso.
flags- I flag indicano il comportamento del file da aprire. Tutti i valori possibili sono stati menzionati di seguito.
mode- Imposta la modalità del file (permessi e sticky bits), ma solo se il file è stato creato. Il valore predefinito è 0666, leggibile e scrivibile.
callback - Questa è la funzione di callback che ottiene due argomenti (err, fd).
Bandiere
I flag per le operazioni di lettura / scrittura sono:
| Sr.No. | Bandiera e descrizione |
|---|---|
| 1 |
r Apri file per la lettura. Si verifica un'eccezione se il file non esiste. |
| 2 |
r+ Apri file in lettura e scrittura. Si verifica un'eccezione se il file non esiste. |
| 3 |
rs Apri file per la lettura in modalità sincrona. |
| 4 |
rs+ Apri il file per la lettura e la scrittura, chiedendo al sistema operativo di aprirlo in modo sincrono. Vedere le note per "rs" sull'utilizzo di questo con cautela. |
| 5 |
w Apri file per la scrittura. Il file viene creato (se non esiste) o troncato (se esiste). |
| 6 |
wx Come "w" ma fallisce se il percorso esiste. |
| 7 |
w+ Apri file in lettura e scrittura. Il file viene creato (se non esiste) o troncato (se esiste). |
| 8 |
wx+ Come 'w +' ma fallisce se il percorso esiste. |
| 9 |
a Apri file da aggiungere. Il file viene creato se non esiste. |
| 10 |
ax Come "a" ma fallisce se il percorso esiste. |
| 11 |
a+ Apri il file per la lettura e l'aggiunta. Il file viene creato se non esiste. |
| 12 |
ax+ Come "a +" ma fallisce se il percorso esiste. |
Esempio
Creiamo un file js denominato main.js con il codice seguente per aprire un file input.txt per la lettura e la scrittura.
var fs = require("fs");
// Asynchronous - Opening File
console.log("Going to open file!");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("File opened successfully!");
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to open file!
File opened successfully!Ottieni informazioni sul file
Sintassi
Di seguito è riportata la sintassi del metodo per ottenere le informazioni su un file:
fs.stat(path, callback)Parametri
Ecco la descrizione dei parametri utilizzati:
path - Questa è la stringa con il nome del file incluso il percorso.
callback - Questa è la funzione di callback che ottiene due argomenti (err, stats) dove stats è un oggetto di tipo fs.Stats che è stampato sotto nell'esempio.
Oltre agli attributi importanti che sono stampati di seguito nell'esempio, sono disponibili diversi metodi utili in fs.Statsclasse che può essere utilizzata per controllare il tipo di file. Questi metodi sono riportati nella tabella seguente.
| Sr.No. | Metodo e descrizione |
|---|---|
| 1 |
stats.isFile() Restituisce vero se il tipo di file di un file semplice. |
| 2 |
stats.isDirectory() Restituisce vero se il tipo di file di una directory. |
| 3 |
stats.isBlockDevice() Restituisce vero se il tipo di file di un dispositivo a blocchi. |
| 4 |
stats.isCharacterDevice() Restituisce vero se il tipo di file di un dispositivo a caratteri. |
| 5 |
stats.isSymbolicLink() Restituisce vero se il tipo di file di un collegamento simbolico. |
| 6 |
stats.isFIFO() Restituisce vero se il tipo di file di un FIFO. |
| 7 |
stats.isSocket() Restituisce vero se il tipo di file di asocket. |
Esempio
Creiamo un file js denominato main.js con il seguente codice -
var fs = require("fs");
console.log("Going to get file info!");
fs.stat('input.txt', function (err, stats) {
if (err) {
return console.error(err);
}
console.log(stats);
console.log("Got file info successfully!");
// Check file type
console.log("isFile ? " + stats.isFile());
console.log("isDirectory ? " + stats.isDirectory());
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to get file info!
{
dev: 1792,
mode: 33188,
nlink: 1,
uid: 48,
gid: 48,
rdev: 0,
blksize: 4096,
ino: 4318127,
size: 97,
blocks: 8,
atime: Sun Mar 22 2015 13:40:00 GMT-0500 (CDT),
mtime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT),
ctime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT)
}
Got file info successfully!
isFile ? true
isDirectory ? falseScrivere un file
Sintassi
Di seguito è riportata la sintassi di uno dei metodi per scrivere in un file:
fs.writeFile(filename, data[, options], callback)Questo metodo sovrascriverà il file se il file esiste già. Se vuoi scrivere in un file esistente, dovresti usare un altro metodo disponibile.
Parametri
Ecco la descrizione dei parametri utilizzati:
path - Questa è la stringa con il nome del file incluso il percorso.
data - Questa è la stringa o il buffer da scrivere nel file.
options- Il terzo parametro è un oggetto che conterrà {encoding, mode, flag}. Per impostazione predefinita. la codifica è utf8, la modalità è il valore ottale 0666 e il flag è 'w'
callback - Questa è la funzione di callback che ottiene un singolo parametro err che restituisce un errore in caso di errore di scrittura.
Esempio
Creiamo un file js denominato main.js avente il seguente codice -
var fs = require("fs");
console.log("Going to write into existing file");
fs.writeFile('input.txt', 'Simply Easy Learning!', function(err) {
if (err) {
return console.error(err);
}
console.log("Data written successfully!");
console.log("Let's read newly written data");
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchronous read: " + data.toString());
});
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to write into existing file
Data written successfully!
Let's read newly written data
Asynchronous read: Simply Easy Learning!Leggere un file
Sintassi
Di seguito è riportata la sintassi di uno dei metodi per leggere da un file:
fs.read(fd, buffer, offset, length, position, callback)Questo metodo utilizzerà il descrittore di file per leggere il file. Se si desidera leggere il file direttamente utilizzando il nome del file, è necessario utilizzare un altro metodo disponibile.
Parametri
Ecco la descrizione dei parametri utilizzati:
fd - Questo è il descrittore di file restituito da fs.open ().
buffer - Questo è il buffer in cui verranno scritti i dati.
offset - Questo è l'offset nel buffer da cui iniziare a scrivere.
length - Questo è un numero intero che specifica il numero di byte da leggere.
position- Questo è un numero intero che specifica da dove iniziare la lettura nel file. Se la posizione è nulla, i dati verranno letti dalla posizione del file corrente.
callback - Questa è la funzione di callback che ottiene i tre argomenti, (err, bytesRead, buffer).
Esempio
Creiamo un file js denominato main.js con il seguente codice -
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going 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("Going to read the file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err){
console.log(err);
}
console.log(bytes + " bytes read");
// Print only read bytes to avoid junk.
if(bytes > 0){
console.log(buf.slice(0, bytes).toString());
}
});
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to open an existing file
File opened successfully!
Going to read the file
97 bytes read
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!Chiusura di un file
Sintassi
Di seguito è riportata la sintassi per chiudere un file aperto:
fs.close(fd, callback)Parametri
Ecco la descrizione dei parametri utilizzati:
fd - Questo è il descrittore di file restituito dal metodo file fs.open ().
callback - Questa è la funzione di callback Nessun argomento diverso da una possibile eccezione viene fornito al callback di completamento.
Esempio
Creiamo un file js denominato main.js avente il seguente codice -
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going 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("Going to read the file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
if (err) {
console.log(err);
}
// Print only read bytes to avoid junk.
if(bytes > 0) {
console.log(buf.slice(0, bytes).toString());
}
// Close the opened file.
fs.close(fd, function(err) {
if (err) {
console.log(err);
}
console.log("File closed successfully.");
});
});
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to open an existing file
File opened successfully!
Going to read the file
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
File closed successfully.Troncare un file
Sintassi
Di seguito è riportata la sintassi del metodo per troncare un file aperto:
fs.ftruncate(fd, len, callback)Parametri
Ecco la descrizione dei parametri utilizzati:
fd - Questo è il descrittore di file restituito da fs.open ().
len - Questa è la lunghezza del file dopo la quale il file verrà troncato.
callback - Questa è la funzione di callback Nessun argomento diverso da una possibile eccezione viene fornito al callback di completamento.
Esempio
Creiamo un file js denominato main.js avente il seguente codice -
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going 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("Going to truncate the file after 10 bytes");
// Truncate the opened file.
fs.ftruncate(fd, 10, function(err) {
if (err) {
console.log(err);
}
console.log("File truncated successfully.");
console.log("Going to read the same file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err) {
console.log(err);
}
// Print only read bytes to avoid junk.
if(bytes > 0) {
console.log(buf.slice(0, bytes).toString());
}
// Close the opened file.
fs.close(fd, function(err) {
if (err) {
console.log(err);
}
console.log("File closed successfully.");
});
});
});
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to open an existing file
File opened successfully!
Going to truncate the file after 10 bytes
File truncated successfully.
Going to read the same file
Tutorials
File closed successfully.Elimina un file
Sintassi
Di seguito è riportata la sintassi del metodo per eliminare un file:
fs.unlink(path, callback)Parametri
Ecco la descrizione dei parametri utilizzati:
path - Questo è il nome del file incluso il percorso.
callback - Questa è la funzione di callback Nessun argomento diverso da una possibile eccezione viene fornito al callback di completamento.
Esempio
Creiamo un file js denominato main.js avente il seguente codice -
var fs = require("fs");
console.log("Going to delete an existing file");
fs.unlink('input.txt', function(err) {
if (err) {
return console.error(err);
}
console.log("File deleted successfully!");
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to delete an existing file
File deleted successfully!Crea una directory
Sintassi
Di seguito è riportata la sintassi del metodo per creare una directory:
fs.mkdir(path[, mode], callback)Parametri
Ecco la descrizione dei parametri utilizzati:
path - Questo è il nome della directory incluso il percorso.
mode- Questa è l'autorizzazione della directory da impostare. Il valore predefinito è 0777.
callback - Questa è la funzione di callback Nessun argomento diverso da una possibile eccezione viene fornito al callback di completamento.
Esempio
Creiamo un file js denominato main.js avente il seguente codice -
var fs = require("fs");
console.log("Going to create directory /tmp/test");
fs.mkdir('/tmp/test',function(err) {
if (err) {
return console.error(err);
}
console.log("Directory created successfully!");
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to create directory /tmp/test
Directory created successfully!Leggere una directory
Sintassi
Di seguito è riportata la sintassi del metodo per leggere una directory:
fs.readdir(path, callback)Parametri
Ecco la descrizione dei parametri utilizzati:
path - Questo è il nome della directory incluso il percorso.
callback- Questa è la funzione di callback che ottiene due argomenti (err, files) dove files è un array dei nomi dei file nella directory escluso '.' e '..'.
Esempio
Creiamo un file js denominato main.js avente il seguente codice -
var fs = require("fs");
console.log("Going to read directory /tmp");
fs.readdir("/tmp/",function(err, files) {
if (err) {
return console.error(err);
}
files.forEach( function (file) {
console.log( file );
});
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to read directory /tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test
test.txtRimuovi una directory
Sintassi
Di seguito è riportata la sintassi del metodo per rimuovere una directory:
fs.rmdir(path, callback)Parametri
Ecco la descrizione dei parametri utilizzati:
path - Questo è il nome della directory incluso il percorso.
callback - Questa è la funzione di callback Nessun argomento diverso da una possibile eccezione viene fornito al callback di completamento.
Esempio
Creiamo un file js denominato main.js avente il seguente codice -
var fs = require("fs");
console.log("Going to delete directory /tmp/test");
fs.rmdir("/tmp/test",function(err) {
if (err) {
return console.error(err);
}
console.log("Going to read directory /tmp");
fs.readdir("/tmp/",function(err, files) {
if (err) {
return console.error(err);
}
files.forEach( function (file) {
console.log( file );
});
});
});Ora esegui main.js per vedere il risultato -
$ node main.jsVerifica l'output.
Going to read directory /tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test.txtRiferimento ai metodi
| Suor n | Metodo e descrizione |
|---|---|
| 1 |
fs.rename(oldPath, newPath, callback) Rename asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 2 |
fs.ftruncate(fd, len, callback) Ftruncate () asincrono. Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 3 |
fs.ftruncateSync(fd, len) Ftruncate sincrono (). |
| 4 |
fs.truncate(path, len, callback) Truncate asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 5 |
fs.truncateSync(path, len) Truncate sincrono (). |
| 6 |
fs.chown(path, uid, gid, callback) Chown asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 7 |
fs.chownSync(path, uid, gid) Chown sincrono (). |
| 8 |
fs.fchown(fd, uid, gid, callback) Fchown asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 9 |
fs.fchownSync(fd, uid, gid) Fchown sincrono (). |
| 10 |
fs.lchown(path, uid, gid, callback) Lchown asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 11 |
fs.lchownSync(path, uid, gid) Lchown sincrono (). |
| 12 |
fs.chmod(path, mode, callback) Chmod asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 13 |
fs.chmodSync(path, mode) Chmod sincrono (). |
| 14 |
fs.fchmod(fd, mode, callback) Fchmod asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 15 |
fs.fchmodSync(fd, mode) Fchmod sincrono (). |
| 16 |
fs.lchmod(path, mode, callback) Lchmod asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. Disponibile solo su Mac OS X. |
| 17 |
fs.lchmodSync(path, mode) Lchmod sincrono (). |
| 18 |
fs.stat(path, callback) Stat asincrona (). Il callback ottiene due argomenti (err, stats) dove stats è un oggetto fs.Stats. |
| 19 |
fs.lstat(path, callback) Lstat asincrono (). Il callback ottiene due argomenti (err, stats) dove stats è un oggetto fs.Stats. lstat () è identico a stat (), tranne per il fatto che se path è un collegamento simbolico, il collegamento stesso è stat-ed, non il file a cui si riferisce. |
| 20 |
fs.fstat(fd, callback) Fstat asincrono (). Il callback ottiene due argomenti (err, stats) dove stats è un oggetto fs.Stats. fstat () è identico a stat (), tranne per il fatto che il file da modificare è specificato dal descrittore di file fd. |
| 21 |
fs.statSync(path) Stat sincrona (). Restituisce un'istanza di fs.Stats. |
| 22 |
fs.lstatSync(path) Lstat () sincrono. Restituisce un'istanza di fs.Stats. |
| 23 |
fs.fstatSync(fd) Fstat sincrono (). Restituisce un'istanza di fs.Stats. |
| 24 |
fs.link(srcpath, dstpath, callback) Collegamento asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 25 |
fs.linkSync(srcpath, dstpath) Collegamento sincrono (). |
| 26 |
fs.symlink(srcpath, dstpath[, type], callback) Symlink asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. L'argomento tipo può essere impostato su "dir", "file" o "junction" (l'impostazione predefinita è "file") ed è disponibile solo su Windows (ignorato su altre piattaforme). Notare che i punti di giunzione di Windows richiedono che il percorso di destinazione sia assoluto. Quando si utilizza "junction", l'argomento di destinazione verrà automaticamente normalizzato al percorso assoluto. |
| 27 |
fs.symlinkSync(srcpath, dstpath[, type]) Symlink sincrono (). |
| 28 |
fs.readlink(path, callback) Readlink asincrono (). Il callback ottiene due argomenti (err, linkString). |
| 29 |
fs.realpath(path[, cache], callback) Realpath () asincrono. Il callback ottiene due argomenti (err, resolvedPath). Può utilizzare process.cwd per risolvere i percorsi relativi. cache è un oggetto letterale di percorsi mappati che può essere utilizzato per forzare una risoluzione di percorso specifica o evitare chiamate fs.stat aggiuntive per percorsi reali noti. |
| 30 |
fs.realpathSync(path[, cache]) Realpath () sincrono. Restituisce il percorso risolto. |
| 31 |
fs.unlink(path, callback) Unlink asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 32 |
fs.unlinkSync(path) Unlink sincrono (). |
| 33 |
fs.rmdir(path, callback) Rmdir asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 34 |
fs.rmdirSync(path) Rmdir sincrono (). |
| 35 |
fs.mkdir(path[, mode], callback) Mkdir asincrono (2). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. la modalità predefinita è 0777. |
| 36 |
fs.mkdirSync(path[, mode]) Mkdir sincrono (). |
| 37 |
fs.readdir(path, callback) Readdir asincrono (3). Legge il contenuto di una directory. Il callback ottiene due argomenti (err, files) dove files è un array dei nomi dei file nella directory escluso '.' e '..'. |
| 38 |
fs.readdirSync(path) Readdir sincrono (). Restituisce un array di nomi di file escluso "." e '..'. |
| 39 |
fs.close(fd, callback) Chiusura asincrona (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 40 |
fs.closeSync(fd) Chiusura sincrona (). |
| 41 |
fs.open(path, flags[, mode], callback) File asincrono aperto. |
| 42 |
fs.openSync(path, flags[, mode]) Versione sincrona di fs.open (). |
| 43 |
fs.utimes(path, atime, mtime, callback)
|
| 44 |
fs.utimesSync(path, atime, mtime) Modificare i timestamp del file a cui fa riferimento il percorso fornito. |
| 45 |
fs.futimes(fd, atime, mtime, callback)
|
| 46 |
fs.futimesSync(fd, atime, mtime) Modificare i timestamp di un file a cui fa riferimento il descrittore di file fornito. |
| 47 |
fs.fsync(fd, callback) Fsync asincrono. Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. |
| 48 |
fs.fsyncSync(fd) Fsync sincrono. |
| 49 |
fs.write(fd, buffer, offset, length[, position], callback) Scrive il buffer nel file specificato da fd. |
| 50 |
fs.write(fd, data[, position[, encoding]], callback) Scrive i dati nel file specificato da fd. Se i dati non sono un'istanza Buffer, il valore verrà convertito in una stringa. |
| 51 |
fs.writeSync(fd, buffer, offset, length[, position]) Versioni sincrone di fs.write (). Restituisce il numero di byte scritti. |
| 52 |
fs.writeSync(fd, data[, position[, encoding]]) Versioni sincrone di fs.write (). Restituisce il numero di byte scritti. |
| 53 |
fs.read(fd, buffer, offset, length, position, callback) Legge i dati dal file specificato da fd. |
| 54 |
fs.readSync(fd, buffer, offset, length, position) Versione sincrona di fs.read. Restituisce il numero di byteRead. |
| 55 |
fs.readFile(filename[, options], callback) Legge in modo asincrono l'intero contenuto di un file. |
| 56 |
fs.readFileSync(filename[, options]) Versione sincrona di fs.readFile. Restituisce il contenuto del nome del file. |
| 57 |
fs.writeFile(filename, data[, options], callback) Scrive in modo asincrono i dati in un file, sostituendolo se esiste già. i dati possono essere una stringa o un buffer. |
| 58 |
fs.writeFileSync(filename, data[, options]) La versione sincrona di fs.writeFile. |
| 59 |
fs.appendFile(filename, data[, options], callback) Accoda i dati in modo asincrono a un file, creando il file se non esiste. i dati possono essere una stringa o un buffer. |
| 60 |
fs.appendFileSync(filename, data[, options]) La versione sincrona di fs.appendFile. |
| 61 |
fs.watchFile(filename[, options], listener) Guarda i cambiamenti sul nome del file. Il listener di callback verrà chiamato ogni volta che si accede al file. |
| 62 |
fs.unwatchFile(filename[, listener]) Smetti di guardare le modifiche al nome del file. Se listener è specificato, viene rimosso solo quel particolare listener. Altrimenti, tutti i listener vengono rimossi e hai effettivamente smesso di guardare il nome del file. |
| 63 |
fs.watch(filename[, options][, listener]) Controlla le modifiche al nome del file, dove il nome del file è un file o una directory. L'oggetto restituito è un fs.FSWatcher. |
| 64 |
fs.exists(path, callback) Verifica se il percorso specificato esiste o meno controllando con il file system. Quindi chiama l'argomento callback con true o false. |
| 65 |
fs.existsSync(path) Esiste la versione sincrona di fs. |
| 66 |
fs.access(path[, mode], callback) Verifica le autorizzazioni di un utente per il file specificato dal percorso. mode è un numero intero opzionale che specifica i controlli di accessibilità da eseguire. |
| 67 |
fs.accessSync(path[, mode]) Versione sincrona di fs.access. Viene generato se qualsiasi controllo di accessibilità fallisce e non fa nulla altrimenti. |
| 68 |
fs.createReadStream(path[, options]) Restituisce un nuovo oggetto ReadStream. |
| 69 |
fs.createWriteStream(path[, options]) Restituisce un nuovo oggetto WriteStream. |
| 70 |
fs.symlink(srcpath, dstpath[, type], callback) Symlink asincrono (). Al callback di completamento non vengono forniti argomenti diversi da una possibile eccezione. L'argomento tipo può essere impostato su "dir", "file" o "junction" (l'impostazione predefinita è "file") ed è disponibile solo su Windows (ignorato su altre piattaforme). Notare che i punti di giunzione di Windows richiedono che il percorso di destinazione sia assoluto. Quando si utilizza "junction", l'argomento di destinazione verrà automaticamente normalizzato al percorso assoluto. |