Útmutató a Node.js fájlrendszerének kezeléséhez

A Node.js egyik beépített funkciója az operációs rendszer fájlrendszerének manipulálása az fs modul segítségével. Ez a Node.js modul számos hasznos funkciót tartalmaz a fájlokkal és könyvtárakkal való munkához.

A fájlokat egyszerűen megmaradt objektumoknak vagy adatdaraboknak nevezzük, amelyeket általában egy merev adathordozón, azaz lemezen vagy memórián tárolnak. A fájlok különféle típusúak lehetnek, a szövegfájloktól a képfájlokig, hangfájlokig és még sok másig.

MAKEUSEOF A NAP VIDEÓJA

Tehát mi az a fájlrendszer, és hogyan tud egyszerűen együttműködni egy operációs rendszer Node.js fájlrendszerével?

ingyenes e -mail kliens a Windows 7 rendszerhez

Mi az a fájlrendszer?

A fájlrendszer meghatározza, hogy az operációs rendszer hogyan tudja azonosítani, rendezni, tárolni és elérni a fájlokat, más műveletekkel együtt.

nem tudom megtekinteni a pdf -et chrome -ban

Az operációs rendszer fájlrendszere azt a feladatot is ellátja, hogy a fájlokat könyvtáraknak vagy mappáknak nevezett gyűjteményekbe csoportosítsa. A közönséges fájlok és könyvtárak a fájlrendszer legáltalánosabb részei, amelyekkel gyakran kölcsönhatásba lép sok más mellett.

Néhány példa a fájlrendszerekre: az új technológiai fájlrendszer (NTFS), a UNIX fájlrendszer (UFS) és a hierarchikus fájlrendszer (HFS).

Mi az a Node.js fs modul?

A Node.js fs A modul a Node.js által biztosított beépített könyvtár, amely a Node-ot támogató bármely operációs rendszer fájlrendszerével működik. Az fs modul könnyen elérhető, és a könyvtár az olyan fájlműveletekhez, mint pl fájlokból olvasni vagy adatok írása a Node.js fájlba .

hogyan lehet ingyenesen növelni a ramot a laptopon

Nagyon gyakran használják a pálya és Ön modulok különféle műveletek végrehajtásához fájlokon. Használatához a fs modult a programjaiban, importálhatja azt a forráskódba az alábbi kód szerint.

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

Mi az a Node.js elérési út modul?

Használhatja a Node.js fájlt pálya modul a fájl elérési útjainak kezeléséhez. Segédprogramokat tartalmaz a fájl- és könyvtárútvonalakkal való egyszerű interakcióhoz. Használni a fs és pálya modulok párhuzamos végrehajtása egy feladat elvégzéséhez bevett gyakorlat. Ez azért van így, mert a legtöbb fs A modul funkciói a célfájlok vagy könyvtárak elérési útjától függenek.

Importálhatja a pálya modult a kódba az alábbi szintaxissal:

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

Gyakori funkciók a Node.js fájlrendszerének eléréséhez

Íme a leggyakrabban használt Node.js fs és pálya modul funkciókat, és hogyan használhatjuk őket a fájlokkal és könyvtárakkal való interakcióhoz.

Munka ösvényekkel

path.resolve: Ez a függvény egy elérési út feloldására a paraméterként átadott útvonal utasítások listájából. Például:

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: Az normalizálni függvény a helyes és normalizált útvonalat adja vissza egy adott bemeneti útvonalról. Például:
```
path.normalize('home/projects/web/../mobile/./code'); 
// returns home/projects/mobile/code 
```
path.join: Ez a függvény több szegmensből épít egy útvonalat. Például:
```
path.join('home', 'projects', '../', 'movies'); 
// returns home/movies 
```

path.basename: Az alapnév függvény a végső útvonalszakaszt adja vissza. Kétféleképpen használhatja:

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: Ez a függvény visszaadja az elérési utat egy adott útvonal utolsó könyvtárába. Példa:
```
path.dirname('home/projects/web/index.js'); 
// returns home/projects/web 
```
path.extname: Ezzel a funkcióval egy adott elérési útról kaphatja meg a fájl kiterjesztését.
```
path.extname('home/projects/web/index.js'); 
// returns '.js' 
```

Fájlok megnyitása és bezárása

fs.open: Ezzel a funkcióval szinkronban lehet megnyitni vagy létrehozni egy fájlt a Node.js-ben. A szinkron formája fs.open van fs.openSync . fs.open a négy argumentumot fogad el, amelyek a fájl elérési útja, zászlók, nyitott mód és egy visszahívási függvény. Zászlók és nyisd ki mód alapértelmezett értékük van, és többet megtudhat róluk a Node.js fs.open dokumentáció.
```
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: Célszerű minden megnyitott fájlt bezárni, amikor már nincs rájuk szükség. A Node.js rendelkezik a fs.close funkció ehhez:

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

Létrehozás és törlés

fs.mkdir: Ez ugyanúgy működik, mint a mkdir terminál parancs, amely egy új könyvtárat hoz létre. Paraméterként egy elérési utat, módot (opcionális) és visszahívási függvényt vesz fel. Így használhatod:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```

fs.unlink: Ez a függvény eltávolítja vagy törli az argumentumként megadott elérési úton lévő fájlt. Tekintsük az alábbi kódpéldát:

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

fs.rmdir: Ez a metódus törli az adott elérési úton lévő könyvtárat. Használatában nagyon hasonló a szétválasztási módszerhez:

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

Fájl metaadatai

fs.exists: Az létezik metódus ellenőrzi, hogy az adott elérési úton lévő fájl létezik-e. A megvalósítás a következő:

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

fs.stat: Ez egy szinkron függvény, amely visszaadja a fájl tulajdonságait. Visszaad egy fs.Stats objektum, amely felfed néhány módszert a fájl tulajdonságainak elérésére. Íme egy példa:

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