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.

bedste tale til tekst -app android 2018

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.

MAKEUSE AF DAGENS VIDEO

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 du 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 
const fs = require('fs') 
  
// ES6 
import fs from '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.

hvad kan jeg slette fra min computer

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

// CommonJS 
const path = require('path') 
  
// ES6 
import path from 'path'

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

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', 'projects', 'web'); 
// returns <path_to_current_directory>/home/projects/web 
  
path.resolve('home/projects/web', '../mobile'); 
// returns <path_to_current_directory>/home/projects/mobile

path.normalize: Det normalisere funktion returnerer den korrekte og normaliserede sti fra en given inputsti. For eksempel:
```
path.normalize('home/projects/web/../mobile/./code'); 
// returns home/projects/mobile/code 
```
path.join: Denne funktion bygger en sti ud af flere segmenter. For eksempel:
```
path.join('home', 'projects', '../', 'movies'); 
// returns home/movies 
```

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

path.basename('home/projects/web/index.js'); 
// returns index.js 
  
path.basename('home/projects/web/index.js', '.js'); 
// removes the extension and returns 'index'

sti.dirnavn: Denne funktion returnerer stien til den sidste mappe i en given sti. Eksempel:
```
path.dirname('home/projects/web/index.js'); 
// returns home/projects/web 
```
sti.extname: Med denne funktion kan du få filudvidelsen fra en given sti.
```
path.extname('home/projects/web/index.js'); 
// returns '.js' 
```

Åbning og lukning af filer

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 en accepterer fire argumenter, som er filstien, flag, åben tilstand og en tilbagekaldsfunktion. Flag og åben mode har en standardværdi, og du kan muligvis lære mere om dem fra Node.js fs.open dokumentation.

const filePath = path.join(__dirname, '/videos/newVideo.mp4'); 
// __dirname returns the path to the current working directory. 
// filePath = <path_to_current_directory>/videos/newVideo.mp4 
  
fs.open(filePath, (error, fileDescriptor) => { 
    // handle errors 
    console.log(fileDescriptor); // prints an integer representing the file descriptor 
})

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(filePath, (error, fileDescriptor) => { 
    // handle errors, such as 'file/directory does not exist' 
    console.log(fileDescriptor); 
  
    // close the file 
    fs.close(fileDescriptor, (error) => { 
        // handle errors 
        console.log('File closed successfully'); 
    }); 
})

Oprettelse og sletning

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:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```

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

const filePath = path.join(_dirname, 'oldFile.js'); 
  
fs.unlink(filePath, (error) => { 
    // handle errors 
    console.log('File has been deleted successfully'); 
});

fs.rmdir: Denne metode sletter mappen på en given sti. Det er meget lig i brugen af unlink-metoden:

const dirPath = path.resolve('home', 'projects', 'web'); 
  
fs.rmdir(dirPath, (error) => { 
    // handle errors 
    console.log('Directory successfully deleted'); 
})

Fil Metadata

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

let filePath = path.join(__dirname, 'index.html'); 
  
fs.exists(filePath, (exists) => { 
    console.log(exists) // true or false 
})

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

fs.stat('index.js', (error, stats) => { 
    console.log(stats); // prints low level properties of the file 
    stats.isFile(); // returns true 
    stats.isDirectory(); // returns false 
})