Een basisgids voor het manipuleren van het bestandssysteem in Node.js

Een van de ingebouwde functies van Node.js is de manipulatie van het bestandssysteem van het besturingssysteem met behulp van de fs-module. Deze Node.js-module bevat veel handige functies voor het werken met bestanden en mappen.

Bestanden worden eenvoudigweg persistente objecten of stukjes gegevens genoemd die doorgaans worden opgeslagen op een hard medium dat schijf of geheugen wordt genoemd. Bestanden kunnen van verschillende typen zijn, van tekstbestanden tot afbeeldingsbestanden, audiobestanden en nog veel meer.

Dus, wat is een bestandssysteem en hoe kun je eenvoudig communiceren met het bestandssysteem van een besturingssysteem in Node.js?

Wat is een bestandssysteem?

Een bestandssysteem definieert hoe een besturingssysteem bestanden kan identificeren, organiseren, opslaan en openen, samen met andere bewerkingen.

Het bestandssysteem van een besturingssysteem zorgt er ook voor dat bestanden worden gegroepeerd in verzamelingen die mappen of mappen worden genoemd. Gewone bestanden en mappen zijn de meest voorkomende onderdelen van een bestandssysteem waarmee onder andere vaak interactie is.

Enkele voorbeelden van bestandssystemen zijn New Technology File System (NTFS), UNIX File System (UFS) en Hierarchical File System (HFS).

Wat is de Node.js fs-module?

De Node.js fs module is een ingebouwde bibliotheek geleverd door Node.js voor het werken met het bestandssysteem van elk besturingssysteem dat Node. De fs module is gemakkelijk toegankelijk en is de go-to-bibliotheek voor bestandsbewerkingen zoals lezen uit bestanden of schrijven van gegevens naar bestanden in Node.js.

Het wordt heel vaak gebruikt met de pad En os modules om verschillende bewerkingen op bestanden uit te voeren. Om de fs module in uw programma's, kunt u deze importeren in uw broncode zoals weergegeven in de onderstaande code.

// CommonJS
const f = vereisen('fs')
// ES6
importeren fs van 'fs'

Wat is de Node.js-padmodule?

U kunt de Node.js gebruiken pad module om bestandspaden te manipuleren. Het bevat hulpprogramma's voor eenvoudige interactie met bestands- en mappaden. De... gebruiken fs En pad modules achter elkaar om een ​​taak te voltooien is standaardpraktijk. Dit komt omdat de meerderheid van fs modulefuncties zijn afhankelijk van paden naar doelbestanden of mappen om te functioneren.

U kunt de pad module in uw code met de onderstaande syntaxis:

// CommonJS
const pad = vereisen('pad')
// ES6
importeren pad van 'pad'

Algemene functies voor toegang tot het bestandssysteem in Node.js

Dit zijn de meest gebruikte Node.js fs En pad modulefuncties en hoe ze te gebruiken voor interactie met bestanden en mappen.

Werken met paden

1. path.resolve: Dit is de functie voor het oplossen van een pad uit een lijst met padinstructies die als parameters zijn doorgegeven. Bijvoorbeeld:

   path.resolve('thuis', 'projecten', 'web');
   // geeft terug /home/projects/web
   path.resolve('home/projects/web', '../mobile');
   // geeft terug /home/projects/mobile
   

2. path.normalize: De normaliseren functie retourneert het juiste en genormaliseerde pad van een gegeven invoerpad. Bijvoorbeeld:

   pad.normaliseren('home/projects/web/../mobile/./code');
   // keert terug naar home/projects/mobile/code
   

3. pad.join: Deze functie bouwt een pad op uit verschillende segmenten. Bijvoorbeeld:

   pad.join('thuis', 'projecten', '../', 'films');
   // keert terug naar home/films
   

4. pad.basisnaam: De basisnaam functie retourneert het laatste padsegment. Je kunt het op twee manieren gebruiken:

   pad.basisnaam('home/projects/web/index.js');
   // retourneert index.js
   pad.basisnaam('home/projects/web/index.js', '.js');
   // verwijdert de extensie en retourneert 'index'
   

5. pad.dirname: Deze functie retourneert het pad naar de laatste map van een bepaald pad. Voorbeeld:

   pad.mapnaam('home/projects/web/index.js');
   // keert terug naar home/projects/web
   

6. pad.extname: Met deze functie kunt u de extensie van een bestand uit een bepaald pad halen.

   pad.extname('home/projects/web/index.js');
   // retourneert '.js'
   

Bestanden openen en sluiten

1. fs.open: Dit is de functie voor het synchroon openen of aanmaken van een bestand in Node.js. De synchrone vorm van fs.open is fs.openSync. fs.open eenaccepteert vier argumenten: het bestandspad, vlaggen, open-modus en een callback-functie. vlaggen En openmodus hebben een standaardwaarde en u kunt er meer over te weten komen in de Node.js fs.open documentatie.

   const filePath = path.join (__dirname, '/videos/nieuweVideo.mp4');
   // __dirname retourneert het pad naar de huidige werkdirectory.
   // bestandspad = /videos/newVideo.mp4
   fs.open (filePath, (fout, fileDescriptor) => {
   // omgaan met fouten
   troosten.log (bestandsbeschrijving); // drukt een geheel getal af dat de bestandsdescriptor vertegenwoordigt
   })
   

2. fs.sluiten: Het is een goede gewoonte om geopende bestanden altijd te sluiten wanneer ze niet langer nodig zijn. Node.js heeft de fs.sluiten functie hiervoor:

   fs.open (filePath, (fout, fileDescriptor) => {
   // omgaan met fouten, zoals 'bestand/map bestaat niet'
   troosten.log (bestandsbeschrijving);
   // sluit het bestand
    fs.close (fileDescriptor, (fout) => {
   // omgaan met fouten
   troosten.log('Bestand succesvol gesloten');
    });
   })
   

Aanmaken en verwijderen

1. fs.mkdir: Dit werkt net als de mkdir terminal-opdracht die een nieuwe map maakt. Het neemt een pad, modus (optioneel) en callback-functie als parameters in beslag. Je kunt het zo gebruiken:

   const dirPath = pad.join (__dirname, 'nieuweDirectory');
   fs.mkdir (dirPath, (fout) => {
   // omgaan met fouten
   troosten.log('Nieuwe map succesvol aangemaakt');
   });
   

2. fs.unlink: Deze functie verwijdert of verwijdert het bestand op het pad dat als argument is doorgegeven. Beschouw het onderstaande codevoorbeeld:

   const filePath = path.join (_dirname, 'oldFile.js');
   fs.unlink (bestandspad, (fout) => {
   // omgaan met fouten
   troosten.log('Bestand is succesvol verwijderd');
   });
   

3. fs.rmdir: Deze methode verwijdert de map op een bepaald pad. Het lijkt erg op de ontkoppelingsmethode:

   const dirPath = path.resolve('thuis', 'projecten', 'web');
   fs.rmdir (dirPath, (fout) => {
   // omgaan met fouten
   troosten.log('Directory succesvol verwijderd');
   })
   

1. fs.bestaat: De bestaat methode controleert of het bestand op een bepaald pad bestaat. De uitvoering is als volgt:

   laten filePath = pad.join (__dirname, 'index.html');
   fs.exists (bestandspad, (bestaat) => {
   troosten.log (bestaat) // waar of niet waar
   })
   

2. fs.stat: Dit is een synchrone functie die de eigenschappen van een bestand retourneert. Het retourneert een fs. Statistieken object dat enkele methoden blootlegt voor toegang tot de eigenschappen van het bestand. Hier is een voorbeeld:

   fs.stat('index.js', (fout, statistieken) => {
   troosten.log (statistieken); // drukt eigenschappen op laag niveau van het bestand af
    statistieken.isBestand(); // retourneert waar
    statistieken.isDirectory(); // retourneert onwaar
   })
   

Het bestandssysteem manipuleren in Node.js

De uitgestrektheid van de fs module maakt het heel gemakkelijk om toegang te krijgen tot en interactie te hebben met bestanden op elk besturingssysteem. Wanneer u het samen met de pad module, sta je open voor meer functionaliteit en kun je het bestandssysteem manipuleren zoals je wilt.

Een groot voordeel van Node.js is de draagbaarheid. U kunt uw apps op elk platform ontwikkelen en overal implementeren zonder u zorgen te hoeven maken over fundamentele compatibiliteitsproblemen.