Základný sprievodca manipuláciou so systémom súborov v Node.js

Jednou zo vstavaných funkcií Node.js je manipulácia so súborovým systémom operačného systému pomocou modulu fs. Tento modul Node.js obsahuje mnoho užitočných funkcií pre prácu so súbormi a adresármi.

Súbory sa jednoducho označujú ako trvalé objekty alebo kusy údajov, ktoré sú zvyčajne uložené na pevnom médiu známom ako disk alebo pamäť. Súbory môžu byť rôznych typov, od textových súborov po obrazové súbory, zvukové súbory a mnohé ďalšie.

VYUŽITIE VIDEA DŇA

Čo je teda súborový systém a ako môžete jednoducho interagovať so súborovým systémom operačného systému v Node.js?

Čo je súborový systém?

Súborový systém definuje, ako môže operačný systém identifikovať, organizovať, ukladať a pristupovať k súborom spolu s ďalšími operáciami.

Súborový systém operačného systému tiež vykonáva úlohu zoskupovania súborov do kolekcií známych ako adresáre alebo priečinky. Bežné súbory a adresáre sú najbežnejšími časťami súborového systému, s ktorými sa často interaguje okrem iného.

čo znamená zvýraznený komentár na youtube

Niektoré príklady súborových systémov zahŕňajú New Technology File System (NTFS), UNIX File System (UFS) a Hierarchical File System (HFS).

ako dostať Windows 10 na flash disk

Čo je modul Node.js fs?

Súbor Node.js fs modul je vstavaná knižnica poskytovaná Node.js na prácu so súborovým systémom ľubovoľného operačného systému, ktorý podporuje Node. The fs modul je ľahko prístupný a je hlavnou knižnicou pre operácie so súbormi, napr čítanie zo súborov alebo zapisovanie údajov do súborov v Node.js .

Veľmi bežne sa používa s cesta a vy moduly na vykonávanie rôznych operácií so súbormi. Ak chcete použiť fs modul vo svojich programoch, môžete ho importovať do zdrojového kódu, ako je uvedené v kóde nižšie.

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

Čo je modul cesty Node.js?

Môžete použiť súbor Node.js cesta modul na manipuláciu s cestami k súborom. Obsahuje nástroje na jednoduchú interakciu s cestami k súborom a adresárom. Pomocou fs a cesta moduly v tandeme na dokončenie úlohy je štandardnou praxou. Je to preto, že väčšina fs funkcie modulu závisia od ciest k cieľovým súborom alebo adresárom, ktoré majú fungovať.

Môžete importovať cesta modul do vášho kódu so syntaxou uvedenou nižšie:

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

Bežné funkcie pre prístup k súborovému systému v Node.js

Tu sú najčastejšie používané súbory Node.js fs a cesta funkcie modulu a ako ich používať na interakciu so súbormi a adresármi.

Práca s cestami

path.resolve: Toto je funkcia na rozlíšenie cesty zo zoznamu inštrukcií cesty odovzdaných ako parametre. Napríklad:

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: The normalizovať funkcia vráti správnu a normalizovanú cestu z danej vstupnej cesty. Napríklad:
```
path.normalize('home/projects/web/../mobile/./code'); 
// returns home/projects/mobile/code 
```
path.join: Táto funkcia vytvára cestu z niekoľkých segmentov. Napríklad:
```
path.join('home', 'projects', '../', 'movies'); 
// returns home/movies 
```

path.basename: The základné meno funkcia vráti posledný segment cesty. Môžete ho použiť dvoma spôsobmi:

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: Táto funkcia vráti cestu k poslednému adresáru danej cesty. Príklad:
```
path.dirname('home/projects/web/index.js'); 
// returns home/projects/web 
```
path.extname: Pomocou tejto funkcie môžete získať príponu súboru z danej cesty.
```
path.extname('home/projects/web/index.js'); 
// returns '.js' 
```

Otváranie a zatváranie súborov

fs.open: Toto je funkcia na synchrónne otvorenie alebo vytvorenie súboru v Node.js. Synchrónna forma fs.open je fs.openSync . fs.open a akceptuje štyri argumenty, ktorými sú cesta k súboru, príznaky, otvorený režim a funkcia spätného volania. Vlajky a OTVORENÉ režim majú predvolenú hodnotu a môžete sa o nich dozvedieť viac na stránke Node.js fs.open dokumentácia.
```
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: Je dobrou praxou vždy zatvoriť všetky otvorené súbory, keď už nie sú potrebné. Node.js má fs.close funkcia pre toto:

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

Vytváranie a odstraňovanie

fs.mkdir: Toto funguje rovnako ako mkdir terminálový príkaz, ktorý vytvorí nový adresár. Ako parametre berie cestu, režim (voliteľné) a funkciu spätného volania. Môžete ho použiť takto:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```

fs.unlink: Táto funkcia odstráni alebo vymaže súbor na ceste zadanej ako argument. Zvážte príklad kódu nižšie:

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

fs.rmdir: Táto metóda vymaže adresár na danej ceste. Používa sa veľmi podobne ako metóda odpojenia:

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

Metadáta súboru

fs.exists: The existuje metóda skontroluje, či súbor na danej ceste existuje. Implementácia je nasledovná:

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

fs.stat: Ide o synchrónnu funkciu, ktorá vracia vlastnosti súboru. Vracia an fs.Stats objekt, ktorý odhaľuje niektoré metódy prístupu k vlastnostiam súboru. Tu je príklad:

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