Node.jsలో ఫైల్ సిస్టమ్‌ను మానిప్యులేట్ చేయడానికి ప్రాథమిక గైడ్

Node.js యొక్క అంతర్నిర్మిత లక్షణాలలో ఒకటి fs మాడ్యూల్ ఉపయోగించి ఆపరేటింగ్ సిస్టమ్ యొక్క ఫైల్ సిస్టమ్ యొక్క తారుమారు. ఈ Node.js మాడ్యూల్ ఫైల్‌లు మరియు డైరెక్టరీలతో పని చేయడానికి చాలా ఉపయోగకరమైన ఫంక్షన్‌లను కలిగి ఉంది.

ఫైల్‌లు సాధారణంగా డిస్క్ లేదా మెమరీ అని పిలువబడే హార్డ్ మాధ్యమంలో నిల్వ చేయబడిన నిరంతర వస్తువులు లేదా డేటా భాగాలుగా సూచించబడతాయి. ఫైల్‌లు టెక్స్ట్ ఫైల్‌ల నుండి ఇమేజ్ ఫైల్‌లు, ఆడియో ఫైల్‌లు మరియు మరెన్నో రకాలుగా ఉండవచ్చు.

రోజు యొక్క వీడియోను తయారు చేయండి

కాబట్టి, ఫైల్ సిస్టమ్ అంటే ఏమిటి మరియు మీరు Node.jsలో ఆపరేటింగ్ సిస్టమ్ ఫైల్ సిస్టమ్‌తో సులభంగా ఎలా పరస్పర చర్య చేయవచ్చు?

ఫైల్ సిస్టమ్ అంటే ఏమిటి?

ఫైల్ సిస్టమ్ ఇతర కార్యకలాపాలతో పాటు ఫైల్‌లను ఎలా గుర్తించగలదో, నిర్వహించగలదో, నిల్వ చేయగలదో మరియు యాక్సెస్ చేయగలదో ఒక ఫైల్ సిస్టమ్ నిర్వచిస్తుంది.

ఆపరేటింగ్ సిస్టమ్ యొక్క ఫైల్ సిస్టమ్ ఫైల్‌లను డైరెక్టరీలు లేదా ఫోల్డర్‌లుగా పిలవబడే సేకరణలుగా సమూహపరిచే పనిని కూడా చేస్తుంది. సాధారణ ఫైల్‌లు మరియు డైరెక్టరీలు అనేవి ఫైల్ సిస్టమ్‌లోని అత్యంత సాధారణ భాగాలు, ఇవి తరచుగా అనేక ఇతర వాటితో పరస్పర చర్య చేయబడతాయి.

ఫైల్ సిస్టమ్‌లకు కొన్ని ఉదాహరణలు న్యూ టెక్నాలజీ ఫైల్ సిస్టమ్ (NTFS), UNIX ఫైల్ సిస్టమ్ (UFS) మరియు క్రమానుగత ఫైల్ సిస్టమ్ (HFS).

Node.js fs మాడ్యూల్ అంటే ఏమిటి?

Node.js fs మాడ్యూల్ అనేది నోడ్‌కు మద్దతిచ్చే ఏదైనా ఆపరేటింగ్ సిస్టమ్ యొక్క ఫైల్ సిస్టమ్‌తో పనిచేయడానికి Node.js అందించిన అంతర్నిర్మిత లైబ్రరీ. ది fs మాడ్యూల్ సులభంగా యాక్సెస్ చేయగలదు మరియు ఫైల్ ఆపరేషన్ల కోసం గో-టు లైబ్రరీ ఫైళ్ళ నుండి చదవడం లేదా Node.jsలోని ఫైల్‌లకు డేటా రాయడం .

తో ఇది చాలా సాధారణంగా ఉపయోగించబడుతుంది మార్గం మరియు మీరు ఫైళ్లపై వివిధ కార్యకలాపాలను నిర్వహించడానికి మాడ్యూల్స్. ఉపయోగించడానికి fs మీ ప్రోగ్రామ్‌లలో మాడ్యూల్, దిగువ కోడ్‌లో చూపిన విధంగా మీరు దానిని మీ సోర్స్ కోడ్‌లోకి దిగుమతి చేసుకోవచ్చు.

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

Node.js పాత్ మాడ్యూల్ అంటే ఏమిటి?

మీరు Node.jsని ఉపయోగించవచ్చు మార్గం ఫైల్ పాత్‌లను మార్చటానికి మాడ్యూల్. ఫైల్ మరియు డైరెక్టరీ పాత్‌లతో సులభంగా ఇంటరాక్ట్ చేయడానికి ఇది యుటిలిటీలను కలిగి ఉంటుంది. ఉపయోగించి fs మరియు మార్గం ఒక పనిని పూర్తి చేయడానికి ఏకంగా మాడ్యూల్స్ ప్రామాణిక అభ్యాసం. దీనికి కారణం మెజారిటీ fs మాడ్యూల్ ఫంక్షన్‌లు టార్గెట్ ఫైల్‌లు లేదా డైరెక్టరీలు ఫంక్షన్ చేయడానికి మార్గాలపై ఆధారపడి ఉంటాయి.

మీరు దిగుమతి చేసుకోవచ్చు మార్గం దిగువ సింటాక్స్‌తో మీ కోడ్‌లోకి మాడ్యూల్ చేయండి:

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

Node.jsలో ఫైల్ సిస్టమ్‌ను యాక్సెస్ చేయడానికి సాధారణ విధులు

ఇక్కడ అత్యంత సాధారణంగా ఉపయోగించే Node.js ఉన్నాయి fs మరియు మార్గం మాడ్యూల్ ఫంక్షన్‌లు మరియు ఫైల్‌లు మరియు డైరెక్టరీలతో పరస్పర చర్య చేయడానికి వాటిని ఎలా ఉపయోగించాలి.

బూటబుల్ యుఎస్‌బి విండోస్ 7 ని ఎలా తయారు చేయాలి

మార్గాలతో పని చేయడం

మార్గం.పరిష్కారం: పారామితులుగా పంపబడిన పాత్ సూచనల జాబితా నుండి పాత్‌ను పరిష్కరించే ఫంక్షన్ ఇది. ఉదాహరణకు:
```
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('home/projects/web/../mobile/./code'); 
// returns home/projects/mobile/code 
```
path.join: ఈ ఫంక్షన్ అనేక విభాగాల నుండి ఒక మార్గాన్ని నిర్మిస్తుంది. ఉదాహరణకు:
```
path.join('home', 'projects', '../', 'movies'); 
// returns home/movies 
```
మార్గం.బేస్ పేరు: ది బేస్ పేరు ఫంక్షన్ చివరి మార్గం విభాగాన్ని అందిస్తుంది. మీరు దీన్ని రెండు విధాలుగా ఉపయోగించవచ్చు:
```
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('home/projects/web/index.js'); 
// returns home/projects/web 
```
path.extname: ఈ ఫంక్షన్‌తో, మీరు ఇచ్చిన మార్గం నుండి ఫైల్ యొక్క పొడిగింపును పొందవచ్చు.
```
path.extname('home/projects/web/index.js'); 
// returns '.js' 
```

ఫైళ్లను తెరవడం మరియు మూసివేయడం

fs.open: ఇది Node.jsలో ఫైల్‌ను సింక్రోనస్‌గా తెరవడం లేదా సృష్టించడం కోసం ఫంక్షన్. యొక్క సమకాలిక రూపం fs.open ఉంది fs.openSync . fs.ఓపెన్ a ఫైల్ మార్గం, ఫ్లాగ్‌లు, ఓపెన్ మోడ్ మరియు కాల్‌బ్యాక్ ఫంక్షన్ అనే నాలుగు ఆర్గ్యుమెంట్‌లను cసెప్ట్ చేస్తుంది. జెండాలు మరియు తెరవండి మోడ్ డిఫాల్ట్ విలువను కలిగి ఉంటుంది మరియు మీరు వాటి గురించి మరింత తెలుసుకోవచ్చు Node.js fs.open డాక్యుమెంటేషన్.
```
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: తెరిచిన ఫైల్‌లు అవసరం లేనప్పుడు వాటిని ఎల్లప్పుడూ మూసివేయడం మంచి పద్ధతి. Node.js ఉంది fs.close దీని కోసం ఫంక్షన్:

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

సృష్టించడం మరియు తొలగించడం

fs.mkdir: ఇది ఇలాగే పనిచేస్తుంది mkdir టెర్మినల్ కమాండ్ కొత్త డైరెక్టరీని సృష్టిస్తుంది. ఇది పాత్, మోడ్ (ఐచ్ఛికం) మరియు కాల్‌బ్యాక్ ఫంక్షన్‌లను పారామీటర్‌లుగా తీసుకుంటుంది. మీరు దీన్ని ఇలా ఉపయోగించవచ్చు:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```
fs.unlink: ఈ ఫంక్షన్ ఆర్గ్యుమెంట్‌గా పంపబడిన మార్గంలో ఫైల్‌ను తొలగిస్తుంది లేదా తొలగిస్తుంది. దిగువ కోడ్ ఉదాహరణను పరిగణించండి:
```
const filePath = path.join(_dirname, 'oldFile.js'); 
  
fs.unlink(filePath, (error) => { 
    // handle errors 
    console.log('File has been deleted successfully'); 
}); 
```
fs.rmdir: ఈ పద్ధతి ఇచ్చిన మార్గం వద్ద డైరెక్టరీని తొలగిస్తుంది. ఇది అన్‌లింక్ పద్ధతికి చాలా పోలి ఉంటుంది:
```
const dirPath = path.resolve('home', 'projects', 'web'); 
  
fs.rmdir(dirPath, (error) => { 
    // handle errors 
    console.log('Directory successfully deleted'); 
}) 
```

ఫైల్ మెటాడేటా

fs.ఉంది: ది ఉంది ఇచ్చిన మార్గం వద్ద ఫైల్ ఉనికిలో ఉందో లేదో పద్ధతి తనిఖీ చేస్తుంది. అమలు క్రింది విధంగా ఉంది:
```
let filePath = path.join(__dirname, 'index.html'); 
  
fs.exists(filePath, (exists) => { 
    console.log(exists) // true or false 
}) 
```
fs.stat: ఇది ఫైల్ యొక్క లక్షణాలను తిరిగి ఇచ్చే సింక్రోనస్ ఫంక్షన్. ఇది తిరిగి ఇస్తుంది fs. గణాంకాలు ఫైల్ యొక్క లక్షణాలను యాక్సెస్ చేయడానికి కొన్ని పద్ధతులను బహిర్గతం చేసే వస్తువు. ఇక్కడ ఒక ఉదాహరణ ఉంది:
```
fs.stat('index.js', (error, stats) => { 
    console.log(stats); // prints low level properties of the file 
    stats.isFile(); // returns true 
    stats.isDirectory(); // returns false 
}) 
```