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.

MAKEUSE AV DAGENS VIDEO

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).

bästa gratis mind mapping -programvara 2019

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

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

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

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'); 
// returns home/projects/mobile/code 
```

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

path.join('home', 'projects', '../', 'movies'); 
// returns home/movies

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'); 
// returns index.js 
  
path.basename('home/projects/web/index.js', '.js'); 
// removes the extension and returns 'index'

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'); 
// returns home/projects/web 
```
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'); 
// returns '.js' 
```

Öppna och stänga filer

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 a accepterar fyra argument som är filsökvägen, flaggor, öppet läge och en återuppringningsfunktion. Flaggor och öppna läge har ett standardvärde, och du kan lära dig mer om dem från 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 ä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(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'); 
    }); 
})

Skapa och ta bort

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

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:

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

fs.rmdir: Denna metod tar bort katalogen på en given sökväg. Det är väldigt likt i användningen av länkningsmetoden:

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

Fil Metadata

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

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

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

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