En grundlæggende vejledning til manipulation af filsystemet i Node.js

En af de indbyggede funktioner i Node.js er manipulation af operativsystemets filsystem ved hjælp af fs-modulet. Dette Node.js-modul indeholder mange nyttige funktioner til at arbejde med filer og mapper.

Filer omtales simpelthen som vedvarende objekter eller bidder af data, der typisk er lagret på et hårdt medie kendt som en disk eller hukommelse. Filer kan være af forskellige typer, fra tekstfiler til billedfiler, lydfiler og mange flere.

Så hvad er et filsystem, og hvordan kan du nemt interagere med et operativsystems filsystem i Node.js?

Hvad er et filsystem?

Et filsystem definerer, hvordan et operativsystem kan identificere, organisere, gemme og få adgang til filer sammen med andre operationer.

Filsystemet i et operativsystem gør også jobbet med at gruppere filer i samlinger kendt som mapper eller mapper. Almindelige filer og mapper er de mest almindelige dele af et filsystem, som ofte interageres med blandt mange andre.

Nogle eksempler på filsystemer omfatter New Technology File System (NTFS), UNIX File System (UFS) og Hierarchical File System (HFS).

Hvad er Node.js fs-modulet?

Node.js fs modul er et indbygget bibliotek leveret af Node.js til at arbejde med filsystemet i ethvert operativsystem, der understøtter Node. Det fs modul er let tilgængeligt og er go-to-biblioteket til filhandlinger som f.eks læsning fra filer eller skrive data til filer i Node.js.

Det er meget almindeligt brugt sammen med sti og os moduler til at udføre forskellige handlinger på filer. For at bruge fs modul i dine programmer, kan du importere det til din kildekode som vist i koden nedenfor.

// CommonJS
konst fs = kræve('fs')
// ES6
importere fs fra 'fs'

Hvad er Node.js-stimodulet?

Du kan bruge Node.js sti modul til at manipulere filstier. Det inkluderer værktøjer til nemt at interagere med fil- og mappestier. Bruger fs og sti moduler i tandem for at fuldføre en opgave er standard praksis. Dette skyldes, at størstedelen af fs modulfunktioner afhænger af stier til målfiler eller mapper for at fungere.

Du kan importere sti modul ind i din kode med syntaksen nedenfor:

// CommonJS
konst sti = kræve('sti')
// ES6
importere sti fra 'sti'

Fælles funktioner til at få adgang til filsystemet i Node.js

Her er de mest brugte Node.js fs og sti modulfunktioner, og hvordan man bruger dem til at interagere med filer og mapper.

Arbejde med stier

1. path.resolve: Dette er funktionen til at løse en sti fra en liste over stiinstruktioner, der er sendt som parametre. For eksempel:

   path.resolve('home', 'projekter', 'web');
   // vender tilbage /home/projects/web
   path.resolve('home/projects/web', '../mobile');
   // vender tilbage /home/projects/mobile
   

2. path.normalize: Det normalisere funktion returnerer den korrekte og normaliserede sti fra en given inputsti. For eksempel:

   path.normalize('home/projects/web/../mobile/./code');
   // vender hjem/projekter/mobil/kode
   

3. path.join: Denne funktion bygger en sti ud af flere segmenter. For eksempel:

   path.join('home', 'projects', '../', 'movies');
   // vender hjem/film
   

4. sti.basenavn: Det basenavn funktion returnerer det sidste stisegment. Du kan bruge det på to måder:

   path.basename('home/projects/web/index.js');
   // returnerer index.js
   path.basename('home/projects/web/index.js', '.js');
   // fjerner udvidelsen og returnerer 'indeks'
   

5. sti.dirnavn: Denne funktion returnerer stien til den sidste mappe i en given sti. Eksempel:

   path.dirname('home/projects/web/index.js');
   // vender hjem/projekter/web
   

6. sti.extname: Med denne funktion kan du få filudvidelsen fra en given sti.

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

Åbning og lukning af filer

1. fs.open: Dette er funktionen til at åbne eller oprette en fil synkront i Node.js. Den synkrone form af fs.åben er fs.openSync. fs.åbn enaccepterer fire argumenter, som er filstien, flag, åben tilstand og en tilbagekaldsfunktion. Flag og åbenmode har en standardværdi, og du kan muligvis lære mere om dem fra Node.js fs.open dokumentation.

   konst filePath = path.join (__dirname, '/videos/newVideo.mp4');
   // __dirname returnerer stien til den aktuelle arbejdsmappe.
   // filsti = /videos/newVideo.mp4
   fs.open (filsti, (fejl, filbeskrivelse) => {
   // håndtere fejl
   konsol.log (filbeskrivelse); // udskriver et heltal, der repræsenterer filbeskrivelsen
   })
   

2. fs.close: Det er god praksis altid at lukke åbne filer, når de ikke længere er nødvendige. Node.js har fs.tæt funktion til dette:

   fs.open (filsti, (fejl, filbeskrivelse) => {
   // håndtere fejl, såsom 'fil/mappe findes ikke'
   konsol.log (filbeskrivelse);
   // luk filen
    fs.close (fildescriptor, (fejl) => {
   // håndtere fejl
   konsol.log('Fil lukket med succes');
    });
   })
   

Oprettelse og sletning

1. fs.mkdir: Dette fungerer ligesom mkdir terminal kommando, som opretter en ny mappe. Det tager en sti, tilstand (valgfrit) og tilbagekaldsfunktion som parametre. Du kan bruge det sådan her:

   konst dirPath = path.join (__dirname, 'newDirectory');
   fs.mkdir (dirPath, (fejl) => {
   // håndtere fejl
   konsol.log('Ny mappe oprettet med succes');
   });
   

2. fs.unlink: Denne funktion fjerner eller sletter filen på stien, der er sendt ind som et argument. Overvej kodeeksemplet nedenfor:

   konst filePath = path.join (_dirname, 'oldFile.js');
   fs.unlink (filsti, (fejl) => {
   // håndtere fejl
   konsol.log('Filen er blevet slettet');
   });
   

3. fs.rmdir: Denne metode sletter mappen på en given sti. Det ligner meget i brugen af ​​metoden for at fjerne linket:

   konst dirPath = path.resolve('home', 'projects', 'web');
   fs.rmdir (dirPath, (fejl) => {
   // håndtere fejl
   konsol.log('Mappen blev slettet');
   })
   

1. fs.eksisterer: Det eksisterer metoden kontrollerer, om filen på en given sti findes. Implementeringen er som følger:

   lade filePath = path.join (__dirname, 'index.html');
   fs.exists (filsti, (eksisterer) => {
   konsol.log (eksisterer) // sandt eller falsk
   })
   

2. fs.stat: Dette er en synkron funktion, der returnerer egenskaberne for en fil. Det returnerer en fs. Statistik objekt, som afslører nogle metoder til at få adgang til filens egenskaber. Her er et eksempel:

   fs.stat('index.js', (fejl, statistik) => {
   konsol.log (statistik); // udskriver lavniveauegenskaber for filen
    stats.isFile(); // returnerer sand
    stats.isDirectory(); // returnerer falsk
   })
   

Manipulering af filsystemet i Node.js

Udstrækningen af fs modul gør det meget nemt at få adgang til og interagere med filer på ethvert operativsystem. Når du bruger det sammen med sti modul, er du åben for mere funktionalitet og kan manipulere filsystemet, som du vil.

En stor fordel ved Node.js er dens portabilitet. Du kan udvikle dine apps på enhver platform og implementere dem hvor som helst uden at bekymre dig om grundlæggende kompatibilitetsproblemer.