Node.js
फाइलसिस्टम I / O

टिप्पणियों

किसी फ़ाइल को लिखने के लिए लिखने का उपयोग करके लिखने या लिखने के लिए

var fs = require('fs');

// Save the string "Hello world!" in a file called "hello.txt" in
// the directory "/tmp" using the default encoding (utf8).
// This operation will be completed in background and the callback
// will be called when it is either done or failed.
fs.writeFile('/tmp/hello.txt', 'Hello world!', function(err) {
  // If an error occurred, show it and return
  if(err) return console.error(err);
  // Successfully wrote to the file!
});

// Save binary data to a file called "binary.txt" in the current
// directory. Again, the operation will be completed in background.
var buffer = new Buffer([ 0x48, 0x65, 0x6c, 0x6c, 0x6f ]);
fs.writeFile('binary.txt', buffer, function(err) {
  // If an error occurred, show it and return
  if(err) return console.error(err);
  // Successfully wrote binary contents to the file!
});

fs.writeFileSync की तरह ही व्यवहार करती है fs.writeFile , लेकिन एक कॉलबैक नहीं ले के रूप में यह तुल्यकालिक और इसलिए ब्लॉक मुख्य थ्रेड पूरा करता है। अधिकांश नोड.जेएस डेवलपर्स अतुल्यकालिक वेरिएंट को पसंद करते हैं जो कार्यक्रम के निष्पादन में लगभग कोई देरी नहीं करेगा।

नोट: मुख्य धागे को ब्लॉक करना नोड में बुरा अभ्यास है। सिंक्रोनस फ़ंक्शन का उपयोग केवल डिबगिंग के दौरान किया जाना चाहिए या जब कोई अन्य विकल्प उपलब्ध नहीं हो।

// Write a string to another file and set the file mode to 0755
try {
  fs.writeFileSync('sync.txt', 'anni', { mode: 0o755 });
} catch(err) {
  // An error occurred
  console.error(err);
}

अतुल्यकालिक रूप से फ़ाइलों से पढ़ें

सभी फ़ाइल संचालन के लिए फाइलसिस्टम मॉड्यूल का उपयोग करें:

const fs = require('fs');

एन्कोडिंग के साथ

इस उदाहरण में, निर्देशिका /tmp से hello.txt पढ़ें। यह ऑपरेशन पृष्ठभूमि में पूरा हो जाएगा और कॉलबैक पूरा होने या विफलता पर होता है:

fs.readFile('/tmp/hello.txt', { encoding: 'utf8' }, (err, content) => {
  // If an error occurred, output it and return
  if(err) return console.error(err);

  // No error occurred, content is a string
  console.log(content);
});

बिना एनकोडिंग के

बाइनरी फ़ाइल पढ़ें binary.txt वर्तमान निर्देशिका से एसिंक्रोनस रूप पृष्ठभूमि में। ध्यान दें कि हम 'एन्कोडिंग' विकल्प सेट नहीं करते हैं - यह Node.js को एक स्ट्रिंग में सामग्री को डिकोड करने से रोकता है:

fs.readFile('binary', (err, binaryContent) => {
  // If an error occurred, output it and return
  if(err) return console.error(err);

  // No error occurred, content is a Buffer, output it in
  // hexadecimal representation.
  console.log(content.toString('hex'));
});

सापेक्ष पथ

ध्यान रखें कि, सामान्य स्थिति में, आपकी स्क्रिप्ट को एक मनमाने ढंग से चालू कार्यशील निर्देशिका के साथ चलाया जा सकता है। वर्तमान स्क्रिप्ट के सापेक्ष किसी फ़ाइल को संबोधित करने के लिए, __dirname या __filename उपयोग करें:

fs.readFile(path.resolve(__dirname, 'someFile'), (err, binaryContent) => {
  //Rest of Function
}

रीडिर या रीडडिरसिंक के साथ लिस्टिंग निर्देशिका सामग्री

const fs = require('fs');

// Read the contents of the directory /usr/local/bin asynchronously.
// The callback will be invoked once the operation has either completed
// or failed.
fs.readdir('/usr/local/bin', (err, files) => {
  // On error, show it and return
  if(err) return console.error(err);

  // files is an array containing the names of all entries
  // in the directory, excluding '.' (the directory itself)
  // and '..' (the parent directory).

  // Display directory entries
  console.log(files.join(' '));
});

एक सिंक्रोनस वेरिएंट readdirSync रूप में उपलब्ध है जो मुख्य थ्रेड को ब्लॉक करता है और इसलिए एक ही समय में एसिंक्रोनस कोड के निष्पादन को रोकता है। अधिकांश डेवलपर्स प्रदर्शन में सुधार करने के लिए तुल्यकालिक IO कार्यों से बचते हैं।

let files;

try {
  files = fs.readdirSync('/var/tmp');
} catch(err) {
  // An error occurred
  console.error(err);
}

एक जनरेटर का उपयोग करना

const fs = require('fs');

// Iterate through all items obtained via
// 'yield' statements
// A callback is passed to the generator function because it is required by
// the 'readdir' method
function run(gen) {
  var iter = gen((err, data) => {
    if (err) { iter.throw(err); }

    return iter.next(data);
  });

  iter.next();
}

const dirPath = '/usr/local/bin';

// Execute the generator function
run(function* (resume) {
  // Emit the list of files in the directory from the generator
  var contents = yield fs.readdir(dirPath, resume);
  console.log(contents);
});

फ़ाइल से सिंक्रोनस को पढ़ना

किसी भी फ़ाइल संचालन के लिए, आपको फ़ाइल सिस्टम मॉड्यूल की आवश्यकता होगी:

const fs = require('fs');

एक स्ट्रिंग पढ़ना

fs.readFileSync की तरह ही व्यवहार करती है fs.readFile , लेकिन एक कॉलबैक नहीं ले के रूप में यह तुल्यकालिक और इसलिए ब्लॉक मुख्य थ्रेड पूरा करता है। अधिकांश नोड.जेएस डेवलपर्स अतुल्यकालिक वेरिएंट को पसंद करते हैं जो कार्यक्रम के निष्पादन में लगभग कोई देरी नहीं करेगा।

यदि encoding विकल्प निर्दिष्ट किया जाता है, तो एक स्ट्रिंग वापस किया जाएगा, अन्यथा एक Buffer वापस किया जाएगा।

// Read a string from another file synchronously
let content;
try {
  content = fs.readFileSync('sync.txt', { encoding: 'utf8' });
} catch(err) {
  // An error occurred
  console.error(err);
}

अनलिंक या अनलिंक का उपयोग करके किसी फ़ाइल को हटाना

एक फाइल को असिंक्रोनस रूप से हटाएं:

var fs = require('fs');

fs.unlink('/path/to/file.txt', function(err) {
  if (err) throw err;

  console.log('file deleted');
});

आप इसे सिंक्रोनाइज़ * भी हटा सकते हैं:

var fs = require('fs');

fs.unlinkSync('/path/to/file.txt');
console.log('file deleted');

* तुल्यकालिक तरीकों से बचें क्योंकि वे पूरी प्रक्रिया को तब तक रोकते हैं जब तक निष्पादन खत्म नहीं हो जाता।

धाराओं का उपयोग करके एक फ़ाइल को बफ़र में पढ़ना

फ़ाइल से सामग्री को पढ़ते समय पहले से ही fs.readFile() पद्धति का उपयोग करके अतुल्यकालिक है, कभी-कभी हम स्ट्रीम fs.readFile() में डेटा को एक साधारण कॉलबैक में प्राप्त करना चाहते हैं। यह हमें इस डेटा को अन्य स्थानों पर पाइप करने या इसे संसाधित करने की अनुमति देता है क्योंकि यह अंत में एक बार में सभी में आता है।

const fs = require('fs');

// Store file data chunks in this array
let chunks = [];
// We can use this variable to store the final data
let fileBuffer;

// Read file into stream.Readable
let fileStream = fs.createReadStream('text.txt');

// An error occurred with the stream
fileStream.once('error', (err) => {
    // Be sure to handle this properly!
    console.error(err); 
});

// File is done being read
fileStream.once('end', () => {
    // create the final data Buffer from data chunks;
    fileBuffer = Buffer.concat(chunks);
    
    // Of course, you can do anything else you need to here, like emit an event!
});

// Data is flushed from fileStream in chunks,
// this callback will be executed for each chunk
fileStream.on('data', (chunk) => {
    chunks.push(chunk); // push data chunk to array

    // We can perform actions on the partial data we have so far!
});

फ़ाइल या निर्देशिका की अनुमतियाँ जांचें

fs.access() यह निर्धारित करता है कि कोई पथ मौजूद है और उपयोगकर्ता को उस पथ पर फ़ाइल या निर्देशिका के लिए क्या अनुमति है। fs.access किसी परिणाम को नहीं लौटाता है, यदि यह एक त्रुटि नहीं देता है, तो पथ मौजूद है और उपयोगकर्ता के पास वांछित अनुमतियाँ हैं।

अनुमति मोड fs ऑब्जेक्ट, fs.constants पर एक संपत्ति के रूप में उपलब्ध हैं

• fs.constants.F_OK - अनुमतियों को पढ़ें / लिखें / निष्पादित करें (यदि कोई मोड प्रदान नहीं किया गया है, तो यह डिफ़ॉल्ट है)
• fs.constants.R_OK - ने अनुमतियाँ पढ़ ली हैं
• fs.constants.W_OK - लिखने की अनुमति है
• fs.constants.X_OK - अनुमतियों को निष्पादित करता है (विंडोज पर fs.constants.F_OK के समान काम करता है)

अतुल्यकालिक रूप से

var fs = require('fs');
var path = '/path/to/check';

// checks execute permission
fs.access(path, fs.constants.X_OK, (err) => {
    if (err) {
        console.log("%s doesn't exist", path);
    } else {
        console.log('can execute %s', path);
    }
});
// Check if we have read/write permissions
// When specifying multiple permission modes
// each mode is separated by a pipe : `|`
fs.access(path, fs.constants.R_OK | fs.constants.W_OK, (err) => {
    if (err) {
        console.log("%s doesn't exist", path);
    } else {
        console.log('can read/write %s', path);
    }
});

तुल्यकालिक

fs.access भी एक तुल्यकालिक संस्करण है fs.accessSync । fs.accessSync का उपयोग करते fs.accessSync आपको इसे एक कोशिश / कैच ब्लॉक में संलग्न करना होगा।

// Check write permission
try {
    fs.accessSync(path, fs.constants.W_OK);
    console.log('can write %s', path);
}
catch (err) {
    console.log("%s doesn't exist", path);
}

मौजूदा निर्देशिका बनाते या उपयोग करते समय दौड़ की स्थितियों से बचना

नोड की अतुल्यकालिक प्रकृति के कारण, पहले से एक निर्देशिका बनाना या उपयोग करना:

1. fs.stat() साथ अपने अस्तित्व की जाँच करना
2. अस्तित्व की जाँच के परिणामों के आधार पर इसे बनाना या उपयोग करना,

अगर चेक के समय और निर्माण के समय के बीच फ़ोल्डर बनाया जाता है, तो दौड़ की स्थिति पैदा हो सकती है। नीचे दी गई विधि fs.mkdir() और fs.mkdirSync() त्रुटि-पकड़ने वाले रैपर में है जो अपवाद को पास करते हैं यदि इसका कोड EEXIST (पहले से मौजूद है)। यदि त्रुटि कुछ और है, जैसे EPERM (pemission नकारा गया), तो एरर को फेंकें या पास करें जैसे कि देशी फ़ंक्शंस करते हैं।

fs.mkdir() साथ अतुल्यकालिक संस्करण

var fs = require('fs');

function mkdir (dirPath, callback) {
  fs.mkdir(dirPath, (err) => {
    callback(err && err.code !== 'EEXIST' ? err : null);
  });
}

mkdir('./existingDir', (err) => {

  if (err)
    return console.error(err.code);

  // Do something with `./existingDir` here

});

fs.mkdirSync() साथ तुल्यकालिक संस्करण

function mkdirSync (dirPath) {
  try {
    fs.mkdirSync(dirPath);
  } catch(e) {
    if ( e.code !== 'EEXIST' ) throw e;
  }
}

mkdirSync('./existing-dir');
// Do something with `./existing-dir` now

यदि कोई फ़ाइल या निर्देशिका मौजूद है, तो जाँच करना

अतुल्यकालिक रूप से

var fs = require('fs');

fs.stat('path/to/file', function(err) {
    if (!err) {
        console.log('file or directory exists');
    }
    else if (err.code === 'ENOENT') {
        console.log('file or directory does not exist');
    }
});

तुल्यकालिक

यहां, हमें त्रुटि को संभालने के लिए फ़ंक्शन कॉल को एक try/catch ब्लॉक में लपेटना चाहिए।

var fs = require('fs');

try {
    fs.statSync('path/to/file');
    console.log('file or directory exists');
}
catch (err) {
  if (err.code === 'ENOENT') {
    console.log('file or directory does not exist');
  }
}

धाराओं का उपयोग करके किसी फ़ाइल को क्लोन करना

इस कार्यक्रम को दिखाता है एक पठनीय और लिखने योग्य धाराओं का इस्तेमाल करके का उपयोग कर एक फाइल कैसे कॉपी कर सकते हैं createReadStream() और createWriteStream() कार्यों फाइल सिस्टम मॉड्यूल द्वारा प्रदान की।

//Require the file System module
var fs = require('fs');

/*
  Create readable stream to file in current directory (__dirname) named 'node.txt'
  Use utf8 encoding 
  Read the data in 16-kilobyte chunks
*/
var readable = fs.createReadStream(__dirname + '/node.txt', { encoding: 'utf8', highWaterMark: 16 * 1024 });

// create writable stream
var writable = fs.createWriteStream(__dirname + '/nodeCopy.txt');

// Write each chunk of data to the writable stream
readable.on('data', function(chunk) {
    writable.write(chunk);
});

स्ट्रीम पाइपिंग करके फ़ाइलों को कॉपी करना

इस कार्यक्रम के प्रतियों के साथ एक फ़ाइल पठनीय का उपयोग कर और एक लिखने योग्य धारा pipe() धारा वर्ग द्वारा प्रदान समारोह

// require the file system module
var fs = require('fs');

/*
    Create readable stream to file in current directory named 'node.txt'
    Use utf8 encoding 
    Read the data in 16-kilobyte chunks
*/
var readable = fs.createReadStream(__dirname + '/node.txt', { encoding: 'utf8', highWaterMark: 16 * 1024 });

// create writable stream
var writable = fs.createWriteStream(__dirname + '/nodePipe.txt');

// use pipe to copy readable to writable
readable.pipe(writable);

पाठ फ़ाइल की सामग्री बदलना

उदाहरण। यह एक टेक्स्ट फ़ाइल index.txt में एक name लिए शब्द email replace(/email/gim, 'name')

var fs = require('fs');
 
fs.readFile('index.txt', 'utf-8', function(err, data) {
    if (err) throw err;
 
    var newValue = data.replace(/email/gim, 'name');
 
    fs.writeFile('index.txt', newValue, 'utf-8', function(err, data) {
        if (err) throw err;
        console.log('Done!');
    })
})

एक पाठ फ़ाइल की लाइन गिनती का निर्धारण

app.js

const readline = require('readline');
const fs = require('fs');

var file = 'path.to.file';
var linesCount = 0;
var rl = readline.createInterface({
    input: fs.createReadStream(file),
    output: process.stdout,
    terminal: false
});
rl.on('line', function (line) {
    linesCount++; // on each linebreak, add +1 to 'linesCount'
});
rl.on('close', function () {
    console.log(linesCount); // print the result when the 'close' event is called
});

उपयोग:

नोड ऐप

एक फ़ाइल लाइन लाइन द्वारा पढ़ना

app.js

const readline = require('readline');
const fs = require('fs');

var file = 'path.to.file';
var rl = readline.createInterface({
    input: fs.createReadStream(file),
    output: process.stdout,
    terminal: false
});

rl.on('line', function (line) {
    console.log(line) // print the content of the line on each linebreak
});

उपयोग:

नोड ऐप