Una guida di base alla manipolazione del file system in Node.js

Una delle funzionalità integrate di Node.js è la manipolazione del file system del sistema operativo utilizzando il modulo fs. Questo modulo Node.js contiene molte funzioni utili per lavorare con file e directory.

I file vengono semplicemente indicati come oggetti persistenti o blocchi di dati che vengono generalmente archiviati su un supporto rigido noto come disco o memoria. I file possono essere di vari tipi, dai file di testo ai file immagine, file audio e molti altri.

Quindi, cos'è un file system e come puoi interagire facilmente con il file system di un sistema operativo in Node.js?

Che cos'è un file system?

Un file system definisce come un sistema operativo può identificare, organizzare, archiviare e accedere ai file, insieme ad altre operazioni.

Il file system di un sistema operativo svolge anche il compito di raggruppare i file in raccolte note come directory o cartelle. I file e le directory ordinari sono le parti più comuni di un file system con cui si interagisce spesso tra molti altri.

Alcuni esempi di file system includono New Technology File System (NTFS), UNIX File System (UFS) e Hierarchical File System (HFS).

Che cos'è il modulo Node.js fs?

Il Node.js fs module è una libreria integrata fornita da Node.js per lavorare con il file system di qualsiasi sistema operativo che supporti Node. IL fs è facilmente accessibile ed è la libreria di riferimento per operazioni sui file come lettura da file O scrittura di dati su file in Node.js.

È molto comunemente usato con il sentiero E os moduli per eseguire varie operazioni sui file. Per usare il fs module nei tuoi programmi, puoi importarlo nel tuo codice sorgente come mostrato nel codice qui sotto.

// CommonJS
cost fs = richiedere('fs')
// ES6
importare fs da 'fs'

Che cos'è il modulo del percorso Node.js?

Puoi usare Node.js sentiero modulo per manipolare i percorsi dei file. Include utilità per interagire facilmente con i percorsi di file e directory. Usando il fs E sentiero moduli in tandem per completare un'attività è una pratica standard. Questo perché la maggior parte di fs le funzioni del modulo dipendono dai percorsi per i file o le directory di destinazione per funzionare.

Puoi importare il file sentiero module nel codice con la sintassi seguente:

// CommonJS
cost percorso = richiedere('sentiero')
// ES6
importare sentiero da 'sentiero'

Funzioni comuni per l'accesso al file system in Node.js

Ecco i Node.js più comunemente usati fs E sentiero funzioni del modulo e come usarle per interagire con file e directory.

Lavorare con i percorsi

1. path.resolve: Questa è la funzione per risolvere un percorso da un elenco di istruzioni di percorso passate come parametri. Per esempio:

   path.resolve('home', 'progetti', 'web');
   // ritorna /home/projects/web
   path.resolve('home/progetti/web', '../mobile');
   // ritorna /home/projects/mobile
   

2. percorso.normalizzare: IL normalizzare La funzione restituisce il percorso corretto e normalizzato da un dato percorso di input. Per esempio:

   path.normalize('home/projects/web/../mobile/./code');
   // ritorna a casa/progetti/mobile/codice
   

3. path.join: Questa funzione costruisce un percorso da diversi segmenti. Per esempio:

   path.join('home', 'projects', '../', 'movies');
   // ritorna a casa/film
   

4. percorso.nomebase: IL basename La funzione restituisce il segmento finale del percorso. Puoi usarlo in due modi:

   path.basename('home/projects/web/index.js');
   // restituisce index.js
   path.basename('home/projects/web/index.js', '.js');
   // rimuove l'estensione e restituisce 'indice'
   

5. percorso.dirname: Questa funzione restituisce il percorso dell'ultima directory di un determinato percorso. Esempio:

   path.dirname('home/projects/web/index.js');
   // torna a casa/progetti/web
   

6. percorso.extname: Con questa funzione, puoi ottenere l'estensione di un file da un determinato percorso.

   path.extname('home/projects/web/index.js');
   // restituisce '.js'
   

Apertura e chiusura di file

1. fs.open: Questa è la funzione per aprire o creare un file in modo sincrono in Node.js. La forma sincrona di fs.open È fs.openSync. fs.open aaccetta quattro argomenti che sono il percorso del file, i flag, la modalità aperta e una funzione di callback. Bandiere E apriremodalità hanno un valore predefinito e puoi saperne di più su di loro dal Node.js fs.open documentazione.

   cost filePath = percorso.join (__dirname, '/videos/nuovoVideo.mp4');
   // __dirname restituisce il percorso della directory di lavoro corrente.
   // percorsofile = /videos/newVideo.mp4
   fs.open (filePath, (errore, fileDescriptor) => {
   // gestisce gli errori
   consolare.log (descrittore di file); // stampa un numero intero che rappresenta il descrittore del file
   })
   

2. fs.close: È buona norma chiudere sempre i file aperti quando non sono più necessari. Node.js ha il fs.chiudi funzione per questo:

   fs.open (filePath, (errore, fileDescriptor) => {
   // gestisce gli errori, come 'file/directory non esiste'
   consolare.log (descrittore di file);
   // chiude il file
    fs.close (fileDescriptor, (errore) => {
   // gestisce gli errori
   consolare.log('File chiuso con successo');
    });
   })
   

Creazione ed eliminazione

1. fs.mkdir: Questo funziona proprio come il mkdir comando terminale che crea una nuova directory. Accetta un percorso, una modalità (opzionale) e una funzione di callback come parametri. Puoi usarlo in questo modo:

   cost dirPath = path.join (__dirname, 'newDirectory');
   fs.mkdir (dirPath, (errore) => {
   // gestisce gli errori
   consolare.log('Nuova directory creata con successo');
   });
   

2. fs.unlink: Questa funzione rimuove o elimina il file nel percorso passato come argomento. Considera l'esempio di codice qui sotto:

   cost filePath = path.join (_dirname, 'oldFile.js');
   fs.unlink (filePath, (errore) => {
   // gestisce gli errori
   consolare.log('Il file è stato cancellato con successo');
   });
   

3. fs.rmdir: Questo metodo elimina la directory in un determinato percorso. È molto simile nell'uso al metodo unlink:

   cost dirPath = path.resolve('home', 'projects', 'web');
   fs.rmdir (dirPath, (errore) => {
   // gestisce gli errori
   consolare.log('Directory eliminata con successo');
   })
   

1. fs.esiste: IL esiste metodo controlla se esiste il file in un determinato percorso. L'implementazione è la seguente:

   permettere filePath = path.join (__dirname, 'index.html');
   fs.exists (filePath, (esiste) => {
   consolare.log (esiste) // vero o falso
   })
   

2. fs.stat: Questa è una funzione sincrona che restituisce le proprietà di un file. Restituisce un fs. Statistiche oggetto che espone alcuni metodi per accedere alle proprietà del file. Ecco un esempio:

   fs.stat('index.js', (errore, statistiche) => {
   consolare.log (statistiche); // stampa le proprietà di basso livello del file
    statistiche.isFile(); // restituisce true
    stats.isDirectory(); // restituisce falso
   })
   

Manipolazione del file system in Node.js

La vastità del fs rende molto facile l'accesso e l'interazione con i file su qualsiasi sistema operativo. Quando lo usi insieme al sentiero modulo, sei aperto a più funzionalità e puoi manipolare il file system come vuoi.

Uno dei principali vantaggi di Node.js è la sua portabilità. Puoi sviluppare le tue app su qualsiasi piattaforma e distribuirle ovunque senza preoccuparti dei problemi di compatibilità di base.