En grundläggande guide för att manipulera filsystemet i Node.js

En av de inbyggda funktionerna i Node.js är manipuleringen av operativsystemets filsystem med hjälp av fs-modulen. Denna Node.js-modul innehåller många användbara funktioner för att arbeta med filer och kataloger.

Filer kallas helt enkelt kvarvarande objekt eller bitar av data som vanligtvis lagras på ett hårt medium som kallas en disk eller ett minne. Filer kan vara av olika typer, från textfiler till bildfiler, ljudfiler och många fler.

Så, vad är ett filsystem, och hur kan du enkelt interagera med ett operativsystems filsystem i Node.js?

Vad är ett filsystem?

Ett filsystem definierar hur ett operativsystem kan identifiera, organisera, lagra och komma åt filer, tillsammans med andra operationer.

Filsystemet i ett operativsystem gör också jobbet med att gruppera filer i samlingar som kallas kataloger eller mappar. Vanliga filer och kataloger är de vanligaste delarna av ett filsystem som ofta interageras med bland många andra.

Några exempel på filsystem inkluderar New Technology File System (NTFS), UNIX File System (UFS) och Hierarchical File System (HFS).

Vad är Node.js fs-modulen?

Node.js fs modulen är ett inbyggt bibliotek som tillhandahålls av Node.js för att arbeta med filsystemet i alla operativsystem som stöder Node. De fs modulen är lättillgänglig och är det bästa biblioteket för filoperationer som läsa från filer eller skriva data till filer i Node.js.

Det används mycket ofta med väg och os moduler för att utföra olika operationer på filer. Att använda fs modul i dina program, kan du importera den till din källkod som visas i koden nedan.

// CommonJS
konst fs = behöva('fs')
// ES6
importera fs från 'fs'

Vad är Node.js-vägmodulen?

Du kan använda Node.js väg modul för att manipulera filsökvägar. Den innehåller verktyg för att enkelt interagera med fil- och katalogsökvägar. Använda fs och väg moduler i tandem för att slutföra en uppgift är standardpraxis. Detta beror på att majoriteten av fs modulfunktioner beror på sökvägar till målfiler eller kataloger för att fungera.

Du kan importera väg modul i din kod med syntaxen nedan:

// CommonJS
konst väg = behöva('väg')
// ES6
importera väg från 'väg'

Vanliga funktioner för åtkomst till filsystemet i Node.js

Här är de mest använda Node.js fs och väg modulfunktioner och hur man använder dem för att interagera med filer och kataloger.

Arbeta med stigar

1. path.resolve: Detta är funktionen för att lösa en sökväg från en lista med sökvägsinstruktioner som skickas som parametrar. Till exempel:

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

2. path.normalize: De normalisera funktion returnerar den korrekta och normaliserade sökvägen från en given inmatningsväg. Till exempel:

   path.normalize('home/projects/web/../mobile/./code');
   // returnerar hem/projekt/mobil/kod
   

3. path.join: Denna funktion bygger en väg av flera segment. Till exempel:

   path.join('home', 'projects', '../', 'movies');
   // återvänder hem/filmer
   

4. sökväg.basnamn: De basnamn funktion returnerar det sista sökvägssegmentet. Du kan använda den på två sätt:

   path.basename('home/projects/web/index.js');
   // returnerar index.js
   path.basename('home/projects/web/index.js', '.js');
   // tar bort tillägget och returnerar 'index'
   

5. sökväg.katalognamn: Denna funktion returnerar sökvägen till den sista katalogen i en given sökväg. Exempel:

   path.dirname('home/projects/web/index.js');
   // återvänder hem/projekt/webb
   

6. sökväg.extname: Med den här funktionen kan du få filtillägget från en given sökväg.

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

Öppna och stänga filer

1. fs.open: Detta är funktionen för att öppna eller skapa en fil synkront i Node.js. Den synkrona formen av fs.öppen är fs.openSync. fs.öppna aaccepterar fyra argument som är filsökvägen, flaggor, öppet läge och en återuppringningsfunktion. Flaggor och öppenläge har ett standardvärde, och du kan lära dig mer om dem från Node.js fs.open dokumentation.

   konst filPath = path.join (__dirname, '/videos/newVideo.mp4');
   // __dirname returnerar sökvägen till den aktuella arbetskatalogen.
   // filsökväg = /videos/newVideo.mp4
   fs.open (filPath, (error, fileDescriptor) => {
   // hantera fel
   trösta.log (filbeskrivning); // skriver ut ett heltal som representerar filbeskrivningen
   })
   

2. fs.close: Det är bra att alltid stänga alla öppna filer när de inte längre behövs. Node.js har fs.stäng funktion för detta:

   fs.open (filPath, (error, fileDescriptor) => {
   // hantera fel, som "fil/katalog finns inte"
   trösta.log (filbeskrivning);
   // stäng filen
    fs.close (filDescriptor, (fel) => {
   // hantera fel
   trösta.log('Filen stängdes framgångsrikt');
    });
   })
   

Skapa och ta bort

1. fs.mkdir: Detta fungerar precis som mkdir terminalkommando som skapar en ny katalog. Den tar in en sökväg, läge (valfritt) och återuppringningsfunktion som parametrar. Du kan använda det så här:

   konst dirPath = path.join (__dirname, 'newDirectory');
   fs.mkdir (dirPath, (fel) => {
   // hantera fel
   trösta.log('Ny katalog skapad framgångsrikt');
   });
   

2. fs.unlink: Denna funktion tar bort eller tar bort filen på sökvägen som skickas in som ett argument. Tänk på kodexemplet nedan:

   konst filePath = sökväg.join (_dirname, 'oldFile.js');
   fs.unlink (filPath, (fel) => {
   // hantera fel
   trösta.log('Filen har raderats framgångsrikt');
   });
   

3. fs.rmdir: Denna metod tar bort katalogen på en given sökväg. Det är mycket likt metoden för att ta bort länken:

   konst dirPath = path.resolve('home', 'projects', 'web');
   fs.rmdir (dirPath, (fel) => {
   // hantera fel
   trösta.log('Katalog raderad');
   })
   

1. fs.exists: De existerar metod kontrollerar om filen på en given sökväg finns. Implementeringen är som följer:

   låta filPath = sökväg.join (__katalognamn, 'index.html');
   fs.exists (filPath, (finns) => {
   trösta.log (finns) // sant eller falskt
   })
   

2. fs.stat: Detta är en synkron funktion som returnerar egenskaperna för en fil. Den returnerar en fs. Statistik objekt som visar några metoder för att komma åt filens egenskaper. Här är ett exempel:

   fs.stat('index.js', (fel, statistik) => {
   trösta.log (statistik); // skriver ut lågnivåegenskaper för filen
    stats.isFile(); // returnerar sant
    stats.isDirectory(); // returnerar falskt
   })
   

Manipulera filsystemet i Node.js

Storheten av fs modulen gör det mycket enkelt att komma åt och interagera med filer på alla operativsystem. När du använder den tillsammans med väg modul är du öppen för mer funktionalitet och kan manipulera filsystemet som du vill.

En stor fördel med Node.js är dess portabilitet. Du kan utveckla dina appar på vilken plattform som helst och distribuera dem var som helst utan att behöva oroa dig för grundläggande kompatibilitetsproblem.