Un ghid de bază pentru manipularea sistemului de fișiere în Node.js

Una dintre caracteristicile încorporate ale Node.js este manipularea sistemului de fișiere al sistemului de operare folosind modulul fs. Acest modul Node.js conține multe funcții utile pentru lucrul cu fișiere și directoare.

Fișierele sunt denumite pur și simplu obiecte persistente sau bucăți de date care sunt de obicei stocate pe un suport dur cunoscut sub numele de disc sau memorie. Fișierele pot fi de diferite tipuri, de la fișiere text la fișiere imagine, fișiere audio și multe altele.

cum să descărcați un videoclip de pe site

REALIZAREA VIDEOCLIPULUI ZILEI

Deci, ce este un sistem de fișiere și cum puteți interacționa cu ușurință cu sistemul de fișiere al unui sistem de operare în Node.js?

Ce este un sistem de fișiere?

Un sistem de fișiere definește modul în care un sistem de operare poate identifica, organiza, stoca și accesa fișiere, împreună cu alte operațiuni.

Sistemul de fișiere al unui sistem de operare face, de asemenea, sarcina de a grupa fișierele în colecții cunoscute sub numele de directoare sau foldere. Fișierele și directoarele obișnuite sunt cele mai comune părți ale unui sistem de fișiere cu care sunt adesea interacționate printre multe altele.

Câteva exemple de sisteme de fișiere includ New Technology File System (NTFS), UNIX File System (UFS) și Hierarchical File System (HFS).

Ce este modulul Node.js fs?

Node.js fs module este o bibliotecă încorporată furnizată de Node.js pentru lucrul cu sistemul de fișiere al oricărui sistem de operare care acceptă Node. The fs modulul este ușor accesibil și este biblioteca de bază pentru operațiuni cu fișiere, cum ar fi citind din fișiere sau scrierea datelor în fișiere în Node.js .

Este foarte frecvent folosit cu cale și tu module pentru a efectua diverse operații asupra fișierelor. Pentru a utiliza fs modul în programele dvs., îl puteți importa în codul sursă, așa cum se arată în codul de mai jos.

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

Ce este modulul calea Node.js?

Puteți folosi Node.js cale modul pentru a manipula căile fișierelor. Include utilitare pentru interacțiunea ușoară cu căile de fișiere și directoare. Folosind fs și cale module în tandem pentru a finaliza o sarcină este o practică standard. Acest lucru se datorează faptului că majoritatea fs funcțiile modulului depind de căile către fișierele țintă sau directoare pentru a funcționa.

Puteți importa cale modul în codul dvs. cu sintaxa de mai jos:

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

Funcții comune pentru accesarea sistemului de fișiere în Node.js

Iată cele mai frecvent utilizate Node.js fs și cale funcțiile modulului și cum să le folosiți pentru a interacționa cu fișierele și directoarele.

Lucrul cu căile

cale.rezolvare: Aceasta este funcția pentru rezolvarea unei căi dintr-o listă de instrucțiuni de cale transmise ca parametri. De exemplu:

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

cale.normaliza: The normaliza funcția returnează calea corectă și normalizată dintr-o cale de intrare dată. De exemplu:
```
path.normalize('home/projects/web/../mobile/./code'); 
// returns home/projects/mobile/code 
```
cale.ună: Această funcție construiește o cale din mai multe segmente. De exemplu:
```
path.join('home', 'projects', '../', 'movies'); 
// returns home/movies 
```

path.basename: The nume de bază funcția returnează segmentul final de cale. Îl puteți folosi în două moduri:

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

path.dirname: Această funcție returnează calea către ultimul director al unei căi date. Exemplu:
```
path.dirname('home/projects/web/index.js'); 
// returns home/projects/web 
```
path.extname: Cu această funcție, puteți obține extensia unui fișier dintr-o cale dată.
```
path.extname('home/projects/web/index.js'); 
// returns '.js' 
```

Deschiderea și închiderea fișierelor

fs.open: Aceasta este funcția pentru deschiderea sau crearea unui fișier sincron în Node.js. Forma sincronă a fs.deschis este fs.openSync . fs.deschide a acceptă patru argumente care sunt calea fișierului, steaguri, modul deschis și o funcție de apel invers. Steaguri și deschis modul au o valoare implicită și puteți afla mai multe despre ele din Node.js fs.open documentație.
```
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: Este o practică bună să închideți întotdeauna orice fișier deschis atunci când nu mai sunt necesare. Node.js are fs.close funcție pentru aceasta:

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'); 
    }); 
})

Crearea și ștergerea

fs.mkdir: Aceasta funcționează la fel ca mkdir comanda terminal care creează un director nou. Preia o cale, un mod (opțional) și o funcție de apel invers ca parametri. Îl puteți folosi astfel:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```

fs.unlink: Această funcție elimină sau șterge fișierul de la calea transmisă ca argument. Luați în considerare exemplul de cod de mai jos:

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

fs.rmdir: Această metodă șterge directorul de la o anumită cale. Este foarte similar în utilizare cu metoda de deconectare:

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

Metadatele fișierului

fs.există: The există metoda verifică dacă fișierul la o cale dată există. Implementarea este după cum urmează:

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

fs.stat: Aceasta este o funcție sincronă care returnează proprietățile unui fișier. Se întoarce un fs.Stats obiect care expune unele metode de accesare a proprietăților fișierului. Iată un exemplu:

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