{"id":57381,"date":"2022-07-12T08:20:25","date_gmt":"2022-07-12T07:20:25","guid":{"rendered":"https:\/\/kinsta.com\/it\/?p=57381&post_type=knowledgebase&preview_id=57381"},"modified":"2025-10-01T20:46:32","modified_gmt":"2025-10-01T19:46:32","slug":"nodejs-fs","status":"publish","type":"post","link":"https:\/\/kinsta.com\/it\/blog\/nodejs-fs\/","title":{"rendered":"Il Modulo del File System di Node.js (FS)"},"content":{"rendered":"

JavaScript \u00e8 stato a lungo uno dei linguaggi di scripting pi\u00f9 popolari, ma per un lungo periodo di tempo non \u00e8 stato una grande scelta per lo sviluppo di applicazioni backend lato server. Poi \u00e8 arrivato Node.js, che viene utilizzato per creare applicazioni leggere, guidate dagli eventi e sviluppate lato server utilizzando il linguaggio di programmazione JavaScript.<\/p>\n

Node.js \u00e8 un runtime JavaScript open-source<\/a> che pu\u00f2 essere scaricato e installato gratuitamente su tutti i principali sistemi operativi (Windows, Mac, Linux). Negli ultimi anni \u00e8 diventato sempre pi\u00f9 popolare tra i creatori di app<\/a> e ha fornito molte nuove opportunit\u00e0 di lavoro<\/a> per gli sviluppatori JavaScript in cerca di una specializzazione.<\/p>\n\n

In questo articolo scopriremo come gestire il file system utilizzando Node.js. \u00c8 facile utilizzare le API di Node.js per interagire con il file system ed eseguire operazioni complesse.<\/p>\n

Cominciamo!<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Prerequisiti per Comprendere il File System di Node.js<\/h2>\n

Il prerequisito principale \u00e8 l’installazione di Node.js sul sistema operativo. Node.js non richiede un hardware avanzato, per cui \u00e8 facile scaricare e installare Node.js<\/a> sul proprio computer.<\/p>\n

Per lavorare sui moduli di Node.js come i file system (noti anche come “FS” o “fs”) \u00e8 utile avere una conoscenza di base di JavaScript<\/a>. Una conoscenza di alto livello delle funzioni, delle callback e delle promises di JavaScript aiuter\u00e0 a capire ancora pi\u00f9 velocemente l’argomento<\/a>.<\/p>\n

Modulo File System di Node.js<\/h2>\n

Lavorare con file e directory \u00e8 una delle esigenze fondamentali di un’applicazione full-stack. Gli utenti dell’app potrebbero voler caricare immagini, curriculum o altri file su un server. Allo stesso tempo, l’applicazione potrebbe aver bisogno di leggere i file di configurazione, spostare i file o addirittura modificarne i permessi in modo programmatico.<\/p>\n

Il modulo del file system di Node.js si occupa di tutti questi aspetti. Fornisce diverse API per interagire con i file system senza problemi. La maggior parte delle API sono personalizzabili con opzioni e flag. \u00c8 anche possibile utilizzarle per eseguire operazioni sia sincrone che asincrone sui file.<\/p>\n

Prima di approfondire il modulo del file system, diamo una sbirciatina al modulo di Node.js.<\/p>\n

I Moduli di Node.js<\/h3>\n

I moduli di Node.js sono un insieme di funzionalit\u00e0 disponibili come API che possono essere utilizzate da un programma utente. Ad esempio, esiste il modulo fs<\/code> per interagire con il file system. Allo stesso modo, un modulo http<\/code> utilizza le sue funzioni per creare un server ed eseguire molte altre operazioni. Node.js offre numerosi moduli per astrarre molte funzionalit\u00e0 di basso livello.<\/p>\n

\u00c8 anche possibile creare i propri moduli. Con Node.js versione 14 e successive, potete creare e utilizzare i moduli Node.js in due modi: Moduli CommonJS (CJS) e moduli ESM (MJS). Tutti gli esempi che vedremo in questo articolo sono in stile CJS.<\/p>\n

Lavorare con i File in Node.js<\/h2>\n

Lavorare con i file comporta diverse operazioni con i file e le directory (cartelle). Ora conosceremo ognuna di queste operazioni con un esempio di codice sorgente. Aprite il vostro editor di codice<\/a> preferito e provatele mentre leggete.<\/p>\n

Per prima cosa, importate il modulo fs<\/code> nel vostro file sorgente per iniziare a lavorare con i metodi del file system. Nello stile CJS, utilizziamo il metodo require<\/code> per importare un metodo da un modulo. Quindi, per importare e utilizzare i metodi del modulo fs, dovete procedere in questo modo:<\/p>\n

const { writeFile } = require('fs\/promises');<\/code><\/pre>\n
Si noti che stiamo importando il metodo writeFile<\/code> dal pacchetto fs\/promises<\/code>. Vogliamo utilizzare i metodi promeses perch\u00e9 sono i pi\u00f9 recenti e sono facili da usare con le parole chiave async\/await e richiedono meno codice. Alternative sono i metodi sincroni e le funzioni di callback che vedremo pi\u00f9 avanti.<\/p>\n
Come Creare e Scrivere su un File<\/h3>\n
Potete creare e scrivere su un file in tre modi:<\/p>\n
    \n
  1. Con il metodo writeFile<\/code><\/li>\n
  2. Con il metodo appendFile<\/code><\/li>\n
  3. Con il metodo openFile<\/code><\/li>\n<\/ol>\n
    Questi metodi accettano il percorso di un file e i dati da scrivere nel file. Se il file esiste, sostituiscono il contenuto del file. Altrimenti, creano un nuovo file con il contenuto.<\/p>\n
    1. Il Metodo writeFile<\/h4>\n
    Il frammento di codice che segue mostra come utilizzare il metodo writeFile<\/code>. Iniziate creando un file chiamato createFile.js<\/strong> e inserite il frammento di codice sottostante:<\/p>\n
    const { writeFile } = require('fs\/promises');\nasync function writeToFile(fileName, data) {\n  try {\n    await writeFile(fileName, data);\n    console.log(`Wrote data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to write the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Nota che stiamo usando la parola chiave await<\/code> per invocare il metodo che restituisce una promessa JavaScript. Una promessa andata a buon fine creer\u00e0\/scriver\u00e0 il file. Abbiamo un blocco try-catch per gestire gli errori nel caso in cui la promessa venga rifiutata.<\/p>\n
    Ora possiamo invocare la funzione writeToFile<\/code>:<\/p>\n
    writeToFile('friends.txt', 'Bob');<\/code><\/pre>\n
    Quindi, aprite un prompt dei comandi o un terminale ed eseguite il programma di cui sopra utilizzando il seguente comando:<\/p>\n
    node createFile.js<\/code><\/pre>\n
    Verr\u00e0 creato un nuovo file chiamato friends.txt<\/strong> con una riga che dice semplicemente:<\/p>\n
    Bob<\/code><\/pre>\n
    2. Il Metodo appendFile<\/h4>\n
    Come dice il nome, questo metodo viene utilizzato principalmente per aggiungere e modificare un file. Tuttavia, potete utilizzare lo stesso metodo anche per creare un file.<\/p>\n
    Date un’occhiata alla funzione qui sotto. Utilizziamo il metodo appendFile<\/code> con il flag w<\/code> per scrivere un file. Il flag predefinito per l’aggiunta a un file \u00e8 a<\/code>:<\/p>\n
    const { appendFile} = require('fs\/promises');\n\nasync function appendToFile(fileName, data) {\n  try {\n    await appendFile(fileName, data, { flag: 'w' });\n    console.log(`Appended data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to append the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Ora potete richiamare la funzione di cui sopra in questo modo:<\/p>\n
    appendToFile('activities.txt', 'Skiing');<\/code><\/pre>\n
    Successivamente, potete eseguire il codice nell’ambiente Node.js utilizzando il comando node, come abbiamo visto in precedenza. In questo modo verr\u00e0 creato un file chiamato activities.txt<\/strong> con il contenuto Skiing<\/code>.<\/p>\n
    3. Il Metodo open<\/h4>\n
    L’ultimo metodo che utilizzeremo per creare e scrivere su un file \u00e8 il metodo open<\/code>. Potete aprire un file utilizzando il flag w<\/code> (per “write”):<\/p>\n
    const { open} = require('fs\/promises');\n\nasync function openFile(fileName, data) {\n  try {\n    const file = await open(fileName, 'w');\n    await file.write(data);\n    console.log(`Opened file ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to open the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Ora richiamate la funzione openFile<\/code> con:<\/p>\n
    openFile('tasks.txt', 'Do homework');<\/code><\/pre>\n
    Quando eseguirete lo script con il comando node, verr\u00e0 creato un file chiamato tasks.txt<\/strong> con il contenuto iniziale:<\/p>\n
    Do homework<\/code><\/pre>\n
    Come Leggere un File<\/h3>\n
    Ora che sappiamo come creare e scrivere su un file, vediamo come leggerne il contenuto. Per farlo, utilizzeremo il metodo readFile<\/code> del modulo del file system.<\/p>\n
    Create un file chiamato readThisFile.js<\/strong> con il seguente codice:<\/p>\n
    \/\/ readThisFile.js\nconst { readFile } = require('fs\/promises');\nasync function readThisFile(filePath) {\n  try {\n    const data = await readFile(filePath);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(`Got an error trying to read the file: {error.message}`);\n }\n}<\/code><\/pre>\n
    Ora leggiamo tutti e tre i file che abbiamo creato invocando la funzione readThisFile<\/code>:<\/p>\n
    readThisFile('activities.txt');\nreadThisFile('friends.txt');\nreadThisFile('tasks.txt');<\/code><\/pre>\n
    Infine, eseguite lo script utilizzando il seguente comando node:<\/p>\n
    node readThisFile.js<\/code><\/pre>\n
    Dovreste vedere il seguente output nella console:<\/p>\n
    Skiing\nDo homework\nBob<\/code><\/pre>\n
    Un punto da notare: Il metodo readFile<\/code> legge il file in modo asincrono. Ci\u00f2 significa che l’ordine in cui viene letto il file e l’ordine in cui viene stampata la risposta nella console potrebbero non essere gli stessi. Bisogna usare la versione sincrona del metodo readFile<\/code> per ottenere l’ordine. Lo vedremo tra poco.<\/p>\n
    Come Rinominare un File<\/h3>\n
    Per rinominare un file, usate il metodo rename del modulo fs. Creiamo un file chiamato rename-me.txt<\/strong>. Rinomineremo questo file in modo programmatico.<\/p>\n
    Create un file chiamato renameFile.js<\/strong> con il seguente codice:<\/p>\n
    const { rename } = require('fs\/promises');\n\nasync function renameFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Renamed ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to rename the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Come avrete notato, il metodo rename richiede due argomenti. Uno \u00e8 il file con il nome di origine e l’altro \u00e8 il nome di destinazione.<\/p>\n
    Ora invochiamo la funzione di cui sopra per rinominare il file:<\/p>\n
    const oldName = \"rename-me.txt\";\nconst newName = \"renamed.txt\";\nrenameFile(oldName, newName);<\/code><\/pre>\n
    Come in precedenza, eseguite il file di script utilizzando il comando node per rinominare il file:<\/p>\n
    node renameFile.js<\/code><\/pre>\n
    Come Spostare un File<\/h3>\n
    Spostare un file da una directory all’altra \u00e8 come rinominarne il percorso. Quindi, possiamo utilizzare il metodo rename<\/code> per spostare i file.<\/p>\n
    Creiamo due cartelle, from<\/strong> e to<\/strong>. Poi creeremo un file chiamato move-me.txt<\/strong> all’interno della cartella from<\/strong>.<\/p>\n
    Successivamente, scriveremo il codice per spostare il file move-me.txt<\/strong>. Create un file chiamato moveFile.js<\/strong> con il seguente frammento:<\/p>\n
    const { rename } = require('fs\/promises');\nconst { join } = require('path');\nasync function moveFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Moved ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to move the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Qui stiamo usando il metodo rename<\/code> proprio come prima. Ma perch\u00e9 dobbiamo importare il metodo join<\/code> dal modulo path<\/code> (s\u00ec, il percorso \u00e8 un altro modulo fondamentale di Node.js)?<\/p>\n
    Il metodo join<\/code> viene utilizzato per unire diversi segmenti di percorso specificati per formare un unico percorso. Lo useremo per formare il percorso dei nomi dei file di origine e di destinazione:<\/p>\n
    const fromPath = join(__dirname, \"from\", \"move-me.txt\");\nconst destPath = join(__dirname, \"to\", \"move-me.txt\");\nmoveFile(fromPath, destPath);<\/code><\/pre>\n
    Ed ecco fatto! Se eseguite lo script moveFile.js<\/strong>, vedrete il file move-me.txt<\/strong> spostato nella cartella to<\/strong>.<\/p>\n
    Come Copiare un File<\/h3>\n
    Utilizziamo il metodo copyFile<\/code> del modulo fs<\/code> per copiare un file dall’origine alla destinazione.<\/p>\n
    Date un’occhiata al frammento di codice qui sotto:<\/p>\n
    const { copyFile } = require('fs\/promises');\nconst { join } = require('path');\nasync function copyAFile(from, to) {\n  try {\n    await copyFile(from, to);\n    console.log(`Copied ${from} to ${to}`);\n  } catch (err) {\n    console.error(`Got an error trying to copy the file: ${err.message}`);\n  }\n}<\/code><\/pre>\n
    Ora potete invocare la funzione di cui sopra con:<\/p>\n
    copyAFile('friends.txt', 'friends-copy.txt');<\/code><\/pre>\n
    Questo copier\u00e0 il contenuto del file friends.txt<\/strong> nel file friends-copy.txt<\/strong>.<\/p>\n
    \u00c8 fantastico, ma come si fa a copiare pi\u00f9 file?<\/p>\n
    Potete utilizzare l’API Promise.all<\/code> per eseguire pi\u00f9 promesse in parallelo:<\/p>\n
    async function copyAll(fromDir, toDir, filePaths) {\n  return Promise.all(filePaths.map(filePath => {\n   return copyAFile(join(fromDir, filePath), join(toDir, filePath));\n  }));\n}<\/code><\/pre>\n
    Ora potete fornire tutti i percorsi dei file da copiare da una directory all’altra:<\/p>\n
    copyFiles('from', 'to', ['copyA.txt', 'copyB.txt']);<\/code><\/pre>\n
    Potete seguire questo approccio anche per eseguire altre operazioni come lo spostamento, la scrittura e la lettura di file in parallelo.<\/p>\n
    Come Eliminare un File<\/h3>\n
    Per eliminare un file utilizziamo il metodo unlink<\/code>:<\/p>\n
    const { unlink } = require('fs\/promises');\nasync function deleteFile(filePath) {\n  try {\n    await unlink(filePath);\n    console.log(`Deleted ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ricordate che dovrete fornire il percorso del file per eliminarlo:<\/p>\n
    deleteFile('delete-me.txt');<\/code><\/pre>\n
    Se il percorso \u00e8 un link simbolico a un altro file, il metodo unlink canceller\u00e0 il link simbolico, ma il file originale non verr\u00e0 toccato. Parleremo pi\u00f9 avanti dei link simbolici.<\/p>\n
    Come Cambiare i Permessi e la Propriet\u00e0 dei File<\/h3>\n
    A volte potreste voler cambiare i permessi dei file in modo programmatico. Pu\u00f2 essere molto utile per rendere un file di sola lettura o completamente accessibile.<\/p>\n
    Utilizzeremo il metodo chmod<\/code> per modificare i permessi di un file:<\/p>\n
    const { chmod } = require('fs\/promises');\nasync function changePermission(filePath, permission) {\n  try {\n    await chmod(filePath, permission);\n    console.log(`Changed permission to ${permission} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change permission: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Possiamo passare il percorso del file e la bitmask del permesso per modificare il permesso.<\/p>\n
    Ecco la chiamata alla funzione per cambiare i permessi di un file in sola lettura:<\/p>\n
    changePermission('permission.txt', 0o400);<\/code><\/pre>\n
    Analogamente ai permessi, \u00e8 possibile anche cambiare la propriet\u00e0 di un file in modo programmatico. Per farlo utilizziamo il metodo chown<\/code>:<\/p>\n
    const { chown } = require('fs\/promises');\n\nasync function changeOwnership(filePath, userId, groupId) {\n  try {\n    await chown(filePath, userId, groupId);\n    console.log(`Changed ownership to ${userId}:${groupId} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change ownership: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Quindi invochiamo la funzione con il percorso del file, l’ID utente e l’ID gruppo:<\/p>\n
    changeOwnership('ownership.txt', 1000, 1010);<\/code><\/pre>\n
    Come Creare un Link Simbolico<\/h3>\n
    Il collegamento simbolico (noto anche come symlink)<\/a> \u00e8 un concetto del filesystem che permette di creare un collegamento a un file o a una cartella. I link simbolici vengono creati per creare dei collegamenti a un file\/cartella di destinazione nel file system. Il modulo Node.js filesystem<\/code> fornisce il metodo symlink<\/code> per creare un link simbolico.<\/p>\n
    Per creare il link simbolico, dobbiamo passare il percorso del file di destinazione, il percorso del file attuale e il tipo:<\/p>\n
    const { symlink } = require('fs\/promises');\nconst { join } = require('path');\nasync function createSymlink(target, path, type) {\n  try {\n    await symlink(target, path, type);\n    console.log(`Created symlink to ${target} at ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the symlink: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Possiamo invocare la funzione con:<\/p>\n
    createSymlink('join(__dirname, from, symMe.txt)', 'symToFile', 'file');<\/code><\/pre>\n
    Qui abbiamo creato un link simbolico chiamato symToFile<\/code>.<\/p>\n
    Come Osservare le Modifiche a un File<\/h3>\n
    Sapevate che \u00e8 possibile osservare le modifiche apportate a un file? \u00c8 un ottimo modo per monitorare le modifiche e gli eventi, soprattutto quando non ve li aspettate. Potete catturare e controllare queste modifiche per rivederle in seguito.<\/p>\n
    Il metodo watch<\/code> \u00e8 il modo migliore per osservare le modifiche di un file. Esiste un metodo alternativo chiamato watchFile<\/code>, ma non \u00e8 cos\u00ec performante come il metodo watch<\/code>.<\/p>\n
    Finora abbiamo utilizzato il metodo del modulo del file system con le parole chiave async\/await. Vediamo come usare la funzione di callback con questo esempio.<\/p>\n
    Il metodo watch<\/code> accetta come argomenti il percorso del file e una funzione di callback. Ogni volta che viene eseguita un’attivit\u00e0 sul file, viene richiamata la funzione callback<\/code>.<\/p>\n
    Possiamo sfruttare il parametro event<\/code> per ottenere maggiori informazioni sulle attivit\u00e0:<\/p>\n
    const fs = require('fs');\nfunction watchAFile(file) {\n  fs.watch(file, (event, filename) => {\n    console.log(`${filename} file Changed`);\n  });\n}<\/code><\/pre>\n
    Invocate la funzione passando il nome del file a watch<\/code>:<\/p>\n
    watchAFile('friends.txt');<\/code><\/pre>\n
    Ora stiamo catturando automaticamente tutte le attivit\u00e0 sul file friends.txt<\/strong>.<\/p>\n
    Lavorare con le Directory (Cartelle) in Node.js<\/h2>\n
    Vediamo ora come eseguire operazioni sulle directory o sulle cartelle. Molte operazioni come rinominare, spostare e copiare sono simili a quelle gi\u00e0 viste per i file. Tuttavia, alcuni metodi e operazioni specifiche sono utilizzabili solo sulle directory.<\/p>\n
    Come Creare una Directory<\/h3>\n
    Per creare una directory utilizziamo il metodo mkdir<\/code>. \u00c8 necessario passare il nome della directory come argomento:<\/p>\n
    const { mkdir } = require('fs\/promises');\nasync function createDirectory(path) {\n  try {\n    await mkdir(path);\n    console.log(`Created directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ora possiamo invocare la funzione createDirectory<\/code> con un percorso di directory:<\/p>\n
    createDirectory('new-directory');<\/code><\/pre>\n
    In questo modo verr\u00e0 creata una directory denominata new-directory<\/strong>.<\/p>\n
    Come Creare una Directory Temporanea<\/h3>\n
    Le directory temporanee non sono directory normali. Hanno un significato speciale per il sistema operativo. Potete creare una directory temporanea utilizzando il metodo mkdtemp()<\/code>.<\/p>\n
    Creiamo una cartella temporanea all’interno della directory temporanea del sistema operativo. Otteniamo le informazioni sulla posizione della directory temporanea dal metodo tmpdir()<\/code> del modulo os<\/code>:<\/p>\n
    const { mkdtemp } = require('fs\/promises');\nconst { join } = require('path');\nconst { tmpdir } = require('os');\nasync function createTemporaryDirectory(fileName) {\n  try {\n    const tempDirectory = await mkdtemp(join(tmpdir(), fileName));\n    console.log(`Created temporary directory ${tempDirectory}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the temporary directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ora invochiamo la funzione con il nome della cartella per crearla:<\/p>\n
    createTemporaryDirectory('node-temp-file-');<\/code><\/pre>\n
    Node.js aggiunger\u00e0 sei caratteri casuali alla fine del nome della cartella temporanea creata per mantenerlo unico.<\/p>\n
    Come Eliminare una Cartella<\/h3>\n
    Per rimuovere\/eliminare una directory bisogna utilizzare il metodo rmdir()<\/code>:<\/p>\n
    const { rmdir } = require('fs\/promises');\nasync function deleteDirectory(path) {\n  try {\n    await rmdir(path);\n    console.log(`Deleted directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Quindi, richiamate la funzione di cui sopra passando il percorso della cartella che volete rimuovere:<\/p>\n
    deleteDirectory('new-directory-renamed');<\/code><\/pre>\n
    API sincrone e asincrone<\/h2>\n
    Finora abbiamo visto molti esempi di metodi per il file system e tutti sono stati utilizzati in modo asincrono. Tuttavia, potreste aver bisogno di gestire alcune operazioni in modo sincrono.<\/p>\n
    Un esempio di operazione sincrona \u00e8 la lettura di pi\u00f9 file uno dopo l’altro. Il modulo fs<\/code> ha un metodo chiamato readFileSync()<\/code> per eseguire questa operazione:<\/p>\n
    const { readFileSync } = require('fs');\nfunction readFileSynchronously(path) {\n  try {\n    const data = readFileSync(path);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(error);\n  }\n}<\/code><\/pre>\n
    Il metodo readFileSync()<\/code> non \u00e8 richiesto dal pacchetto “fs\/promises”. Questo perch\u00e9 il metodo non \u00e8 asincrono. Quindi, potete chiamare la funzione di cui sopra con:<\/p>\n
    readFileSynchronously('activities.txt');\nreadFileSynchronously('friends.txt');\nreadFileSynchronously('tasks.txt');<\/code><\/pre>\n
    In questo caso, tutti i file verranno letti nell’ordine in cui sono state chiamate le funzioni.<\/p>\n
    Il modulo del file system di Node.js offre un metodo sincrono per altre operazioni come quella di lettura. Utilizzateli con attenzione e solo in caso di necessit\u00e0. I metodi asincroni sono molto pi\u00f9 utili per l’esecuzione parallela.<\/p>\n
    Gestire gli Errori<\/h2>\n
    Come ogni coder sa bene, bisogna aspettarsi sempre degli errori ed essere pronti a gestirli<\/a> quando si eseguono operazioni su un file o una directory. Cosa succede se il file non viene trovato o se non avete il permesso di scrivere su un file? Ci possono essere (e probabilmente ci saranno) molti casi in cui potreste imbattervi in un errore.<\/p>\n
    Dovreste sempre racchiudere le vostre chiamate di metodo in un blocco try-catch. In questo modo, se si verifica un errore, il controllo passer\u00e0 al blocco catch, dove potrete esaminare e gestire l’errore. Come avrete notato in tutti gli esempi precedenti, abbiamo utilizzato il blocco try-catch per gestire gli errori che abbiamo incontrato.<\/p>\n\n
    Riepilogo<\/h2>\n
    Rivediamo i punti chiave che abbiamo trattato in questo tutorial:<\/p>\n