En grunnleggende veiledning for å manipulere filsystemet i Node.js

En av de innebygde funksjonene til Node.js er manipulering av operativsystemets filsystem ved hjelp av fs-modulen. Denne Node.js-modulen inneholder mange nyttige funksjoner for å jobbe med filer og kataloger.

Filer er ganske enkelt referert til som vedvarende objekter eller biter av data som vanligvis er lagret på et hardt medium kjent som en disk eller et minne. Filer kan være av ulike typer, fra tekstfiler til bildefiler, lydfiler og mange flere.

Så, hva er et filsystem, og hvordan kan du enkelt samhandle med et operativsystems filsystem i Node.js?

Hva er et filsystem?

Et filsystem definerer hvordan et operativsystem kan identifisere, organisere, lagre og få tilgang til filer, sammen med andre operasjoner.

Filsystemet til et operativsystem gjør også jobben med å gruppere filer i samlinger kjent som kataloger eller mapper. Vanlige filer og kataloger er de vanligste delene av et filsystem som ofte samhandles med blant mange andre.

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

Hva er Node.js fs-modulen?

Node.js fs modul er et innebygd bibliotek levert av Node.js for å arbeide med filsystemet til et hvilket som helst operativsystem som støtter Node. De fs modulen er lett tilgjengelig og er det foretrukne biblioteket for filoperasjoner som lesing fra filer eller skrive data til filer i Node.js.

Det er veldig ofte brukt med sti og os moduler for å utføre ulike operasjoner på filer. For å bruke fs modul i programmene dine, kan du importere den til kildekoden som vist i koden nedenfor.

// CommonJS
konst fs = krever('fs')
// ES6
import fs fra 'fs'

Hva er Node.js-banemodulen?

Du kan bruke Node.js sti modul for å manipulere filstier. Den inkluderer verktøy for enkel samhandling med fil- og katalogstier. Bruker fs og sti moduler i tandem for å fullføre en oppgave er standard praksis. Dette er fordi flertallet av fs modulfunksjoner avhenger av stier til målfiler eller kataloger for å fungere.

Du kan importere sti modul inn i koden din med syntaksen nedenfor:

// CommonJS
konst sti = krever('sti')
// ES6
import sti fra 'sti'

Vanlige funksjoner for tilgang til filsystemet i Node.js

Her er de mest brukte Node.js fs og sti modulfunksjoner, og hvordan du bruker dem til å samhandle med filer og kataloger.

Arbeid med stier

1. path.resolve: Dette er funksjonen for å løse en bane fra en liste over baneinstruksjoner som sendes som parametere. For eksempel:

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

2. path.normalize: De normalisere funksjonen returnerer den korrekte og normaliserte banen fra en gitt inngangsbane. For eksempel:

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

3. path.join: Denne funksjonen bygger en bane av flere segmenter. For eksempel:

   path.join('home', 'projects', '../', 'movies');
   // kommer hjem/filmer
   

4. bane.basenavn: De basenavn funksjonen returnerer det siste banesegmentet. Du kan bruke den på to måter:

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

5. path.dirname: Denne funksjonen returnerer banen til den siste katalogen i en gitt bane. Eksempel:

   path.dirname('home/projects/web/index.js');
   // returnerer hjem/prosjekter/nett
   

6. bane.ekstnavn: Med denne funksjonen kan du få utvidelsen av en fil fra en gitt bane.

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

Åpne og lukke filer

1. fs.open: Dette er funksjonen for å åpne eller lage en fil synkront i Node.js. Den synkrone formen av fs.open er fs.openSync. fs.åpne aaksepterer fire argumenter som er filbanen, flagg, åpen modus og en tilbakeringingsfunksjon. Flagg og åpenmodus har en standardverdi, og du kan lære mer om dem fra Node.js fs.open dokumentasjon.

   konst filePath = path.join (__dirnavn, '/videos/newVideo.mp4');
   // __dirname returnerer banen til gjeldende arbeidskatalog.
   // filbane = /videos/newVideo.mp4
   fs.open (filbane, (feil, filbeskrivelse) => {
   // håndtere feil
   konsoll.log (filbeskrivelse); // skriver ut et heltall som representerer filbeskrivelsen
   })
   

2. fs.close: Det er god praksis å alltid lukke åpne filer når de ikke lenger er nødvendige. Node.js har fs.close funksjon for dette:

   fs.open (filbane, (feil, filbeskrivelse) => {
   // håndtere feil, for eksempel 'fil/katalog finnes ikke'
   konsoll.log (filbeskrivelse);
   // lukk filen
    fs.close (filbeskrivelse, (feil) => {
   // håndtere feil
   konsoll.log('Fil lukket vellykket');
    });
   })
   

Opprette og slette

1. fs.mkdir: Dette fungerer akkurat som mkdir terminalkommando som oppretter en ny katalog. Den tar inn en bane-, modus (valgfritt) og tilbakeringingsfunksjon som parametere. Du kan bruke det slik:

   konst dirPath = path.join (__dirnavn, 'newDirectory');
   fs.mkdir (dirPath, (feil) => {
   // håndtere feil
   konsoll.log('Ny katalog opprettet vellykket');
   });
   

2. fs.unlink: Denne funksjonen fjerner eller sletter filen ved banen som ble sendt inn som et argument. Tenk på kodeeksemplet nedenfor:

   konst filePath = path.join (_dirname, 'oldFile.js');
   fs.unlink (filbane, (feil) => {
   // håndtere feil
   konsoll.log('Filen er slettet');
   });
   

3. fs.rmdir: Denne metoden sletter katalogen på en gitt bane. Det er veldig likt i bruk med frakoblingsmetoden:

   konst dirPath = path.resolve('home', 'projects', 'web');
   fs.rmdir (dirPath, (feil) => {
   // håndtere feil
   konsoll.log('Katalog slettet');
   })
   

1. fs.exists: De finnes metoden sjekker om filen på en gitt bane eksisterer. Implementeringen er som følger:

   la filePath = path.join (__dirnavn, 'index.html');
   fs.exists (filbane, (eksisterer) => {
   konsoll.log (finnes) // sant eller usant
   })
   

2. fs.stat: Dette er en synkron funksjon som returnerer egenskapene til en fil. Den returnerer en fs. Statistikk objekt som viser noen metoder for å få tilgang til egenskapene til filen. Her er et eksempel:

   fs.stat('index.js', (feil, statistikk) => {
   konsoll.log (statistikk); // skriver ut lavnivåegenskaper for filen
    stats.isFile(); // returnerer sant
    stats.isDirectory(); // returnerer usant
   })
   

Manipulere filsystemet i Node.js

Omfanget av fs modulen gjør det veldig enkelt å få tilgang til og samhandle med filer på et hvilket som helst operativsystem. Når du bruker den sammen med sti modul, er du åpen for mer funksjonalitet og kan manipulere filsystemet som du vil.

En stor fordel med Node.js er portabiliteten. Du kan utvikle appene dine på hvilken som helst plattform og distribuere dem hvor som helst uten å bekymre deg for grunnleggende kompatibilitetsproblemer.