Pamata rokasgrāmata failu sistēmas manipulēšanai pakalpojumā Node.js

Viena no Node.js iebūvētajām funkcijām ir manipulācijas ar operētājsistēmas failu sistēmu, izmantojot fs moduli. Šis Node.js modulis satur daudzas noderīgas funkcijas darbam ar failiem un direktorijiem.

Failus sauc vienkārši par noturīgiem objektiem vai datu gabaliem, kas parasti tiek glabāti cietā datu nesējā, kas pazīstama kā disks vai atmiņa. Faili var būt dažāda veida, sākot no teksta failiem līdz attēlu failiem, audio failiem un daudz ko citu.

DIENAS VIDEO MAKEUSEOF

Tātad, kas ir failu sistēma un kā jūs varat viegli mijiedarboties ar operētājsistēmas failu sistēmu pakalpojumā Node.js?

nav nodrošināts internets, lai labotu Windows 10

Kas ir failu sistēma?

Failu sistēma nosaka, kā operētājsistēma var identificēt, kārtot, uzglabāt failus un tiem piekļūt, kā arī citas darbības.

Operētājsistēmas failu sistēma veic arī failu grupēšanas darbu kolekcijās, kas pazīstamas kā direktoriji vai mapes. Parastie faili un direktoriji ir visizplatītākās failu sistēmas daļas, ar kurām bieži notiek mijiedarbība starp daudzām citām.

Daži failu sistēmu piemēri ir jauno tehnoloģiju failu sistēma (NTFS), UNIX failu sistēma (UFS) un hierarhiskā failu sistēma (HFS).

lietotne bezmaksas tālruņa zvaniem

Kas ir Node.js fs modulis?

Node.js fs modulis ir Node.js nodrošināta iebūvēta bibliotēka darbam ar jebkuras operētājsistēmas failu sistēmu, kas atbalsta Node. The fs modulis ir viegli pieejams, un tas ir bibliotēka, kas ļauj veikt tādas darbības kā lasīšana no failiem vai ierakstot datus failos node.js .

To ļoti bieži lieto kopā ar ceļš un tu moduļi dažādu darbību veikšanai ar failiem. Lai izmantotu fs moduli savās programmās, varat importēt to savā pirmkodā, kā parādīts tālāk esošajā kodā.

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

Kas ir Node.js ceļa modulis?

Varat izmantot Node.js ceļš modulis, lai manipulētu ar failu ceļiem. Tajā ir iekļautas utilītas ērtai mijiedarbībai ar failu un direktoriju ceļiem. Izmantojot fs un ceļš Moduļi tandēmā, lai izpildītu uzdevumu, ir standarta prakse. Tas ir tāpēc, ka lielākā daļa no fs moduļa funkcijas ir atkarīgas no ceļiem uz mērķa failiem vai direktorijiem, lai tie darbotos.

cik ilgi ir 10 000 stundas

Jūs varat importēt ceļš moduli savā kodā ar tālāk norādīto sintaksi:

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

Kopējās funkcijas, lai piekļūtu failu sistēmai pakalpojumā Node.js

Šeit ir visbiežāk izmantotie Node.js fs un ceļš moduļa funkcijas un kā tās izmantot, lai mijiedarbotos ar failiem un direktorijiem.

Darbs ar ceļiem

path.resolve: Šī ir funkcija ceļa atrisināšanai no ceļa instrukciju saraksta, kas nodots kā parametri. Piemēram:

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 normalizēt funkcija atgriež pareizo un normalizēto ceļu no dotā ievades ceļa. Piemēram:
```
path.normalize('home/projects/web/../mobile/./code'); 
// returns home/projects/mobile/code 
```

path.join: Šī funkcija veido ceļu no vairākiem segmentiem. Piemēram:

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

path.basename: The pamatnosaukums funkcija atgriež pēdējo ceļa segmentu. Varat to izmantot divos veidos:

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

ceļš.dirname: Šī funkcija atgriež ceļu uz dotā ceļa pēdējo direktoriju. Piemērs:
```
path.dirname('home/projects/web/index.js'); 
// returns home/projects/web 
```
path.extname: Izmantojot šo funkciju, varat iegūt faila paplašinājumu no noteiktā ceļa.
```
path.extname('home/projects/web/index.js'); 
// returns '.js' 
```

Failu atvēršana un aizvēršana

fs.open: Šī ir funkcija faila sinhronai atvēršanai vai izveidošanai pakalpojumā Node.js. Sinhronā forma fs.open ir fs.openSync . fs.open a pieņem četrus argumentus, kas ir faila ceļš, karodziņi, atvērtais režīms un atzvanīšanas funkcija. Karogi un atvērts režīmā ir noklusējuma vērtība, un jūs varat uzzināt vairāk par tām no Node.js fs.open dokumentācija.
```
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: Laba prakse ir vienmēr aizvērt visus atvērtos failus, kad tie vairs nav vajadzīgi. Node.js ir fs.close funkcija šim:

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

Izveidošana un dzēšana

fs.mkdir: Tas darbojas tāpat kā mkdir termināļa komanda, kas izveido jaunu direktoriju. Tas izmanto ceļu, režīmu (neobligāti) un atzvanīšanas funkciju kā parametrus. Varat to izmantot šādi:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```

fs.unlink: Šī funkcija noņem vai dzēš failu ceļā, kas ievadīts kā arguments. Apsveriet tālāk sniegto koda piemēru:

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

fs.rmdir: Šī metode izdzēš direktoriju noteiktā ceļā. Tās lietojums ir ļoti līdzīgs atsaistīšanas metodei:

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

Faila metadati

fs.eksistē: The pastāv metode pārbauda, vai fails noteiktā ceļā pastāv. Īstenošana ir šāda:

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

fs.stat: Šī ir sinhrona funkcija, kas atgriež faila rekvizītus. Tas atgriež an fs.Stats objektu, kas atklāj dažas metodes, kā piekļūt faila rekvizītiem. Šeit ir piemērs:

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