javascript Node.js में फ़ाइलों को लिखना




fs (8)

वर्तमान में फ़ाइल लिखने के तीन तरीके हैं:

  1. fs.write(fd, buffer, offset, length, position, callback )

    कॉलबैक के लिए आपको यह सुनिश्चित करने की प्रतीक्षा करनी है कि बफर डिस्क पर लिखा गया हो। यह buffered नहीं है।

  2. fs.writeFile(filename, data, [encoding], callback)

    सभी डेटा एक ही समय में संग्रहीत किया जाना चाहिए; आप अनुक्रमिक लेखन नहीं कर सकते हैं।

  3. fs.createWriteStream(path, [options] )

    एक WriteStream बनाता है, जो सुविधाजनक है क्योंकि आपको कॉलबैक की प्रतीक्षा करने की आवश्यकता नहीं है। लेकिन फिर, यह buffered नहीं है।

एक WriteStream , जैसा कि नाम कहता है, एक धारा है। परिभाषा द्वारा एक धारा "एक बफर" होता है जिसमें डेटा होता है जो एक दिशा (स्रोत ► गंतव्य) में चलता है। लेकिन एक लिखने योग्य धारा जरूरी नहीं है "buffered"। जब आप n बार लिखते हैं, और समय पर n+1 पर स्ट्रीम "buffered" होती है, तो स्ट्रीम बफर को कर्नेल में भेजती है (क्योंकि यह पूर्ण है और इसे फ़्लश करने की आवश्यकता है)।

दूसरे शब्दों में: "एक बफर" वस्तु है। चाहे वह "buffered" है या नहीं, उस वस्तु की एक संपत्ति है।

यदि आप कोड को WriteStream , तो WriteStream एक लिखने योग्य Stream ऑब्जेक्ट से प्राप्त होता है। यदि आप ध्यान देते हैं, तो आप देखेंगे कि वे सामग्री को कैसे फ़्लश करते हैं; उनके पास कोई बफरिंग सिस्टम नहीं है।

यदि आप एक स्ट्रिंग लिखते हैं, तो इसे एक बफर में परिवर्तित कर दिया जाता है, और फिर मूल परत पर भेजा जाता है और डिस्क पर लिखा जाता है। तार लिखते समय, वे किसी भी बफर को भर नहीं रहे हैं। तो, यदि आप करते हैं:

write("a")
write("b")
write("c")

आप कर रहे हैं:

fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))

आई / ओ परत के लिए यह तीन कॉल है। यद्यपि आप "बफर" का उपयोग कर रहे हैं, डेटा buffered नहीं है। एक fs.write(new Buffer ("abc")) स्ट्रीम करेगा: fs.write(new Buffer ("abc")) , I / O परत पर एक कॉल।

अभी तक, नोड.जेएस v0.12 (स्थिर संस्करण 02/06/2015 की घोषणा) में अब दो कार्यों का समर्थन करता है: cork() और uncork() । ऐसा लगता है कि अंततः ये फ़ंक्शन आपको लिखने वाले कॉल को बफर / फ्लश करने की अनुमति देंगे।

उदाहरण के लिए, जावा में कुछ कक्षाएं हैं जो बफर्ड स्ट्रीम प्रदान करती हैं ( BufferedOutputStream , BufferedWriter ...)। यदि आप तीन बाइट्स लिखते हैं, तो इन बाइट्स को केवल तीन बाइट्स के लिए I / O कॉल करने के बजाय बफर (मेमोरी) में संग्रहीत किया जाएगा। जब बफर भर जाता है तो सामग्री फ़्लश हो जाती है और डिस्क में सहेजी जाती है। यह प्रदर्शन में सुधार करता है।

मैं कुछ भी नहीं खोज रहा हूं, बस यह याद रखना कि डिस्क एक्सेस कैसे किया जाना चाहिए।

मैं Node.js का उपयोग करते समय फ़ाइल में लिखने का एक तरीका खोजने का प्रयास कर रहा हूं, लेकिन बिना किसी सफलता के। मैं उसे कैसे कर सकता हूँ?


आप लाइब्रेरी easy-file-manager उपयोग कर सकते हैं

एनपीएम npm install easy-file-manager से पहले npm install easy-file-manager

फ़ाइलों को अपलोड और निकालने के लिए नमूना

var filemanager = require('easy-file-manager')
var path = "/public"
var filename = "test.jpg"
var data; // buffered image

filemanager.upload(path,filename,data,function(err){
    if (err) console.log(err);
});

filemanager.remove(path,"aa,filename,function(isSuccess){
    if (err) console.log(err);
});

मुझे इंडेक्स का ./articles/file-system पसंद आया।

यह मेरे लिए काम किया।

यह भी देखें कि मैं node.js में फ़ाइलों को कैसे लिखूं?

fs = require('fs');
fs.writeFile('helloworld.txt', 'Hello World!', function (err) {
    if (err) 
        return console.log(err);
    console.log('Wrote Hello World in file helloworld.txt, just check it');
});

Helloworld.txt की सामग्री:

Hello World!

अद्यतन करें:
जैसा कि लिनक्स नोड वर्तमान निर्देशिका में लिखता है, ऐसा लगता है कि कुछ अन्य लोगों में ऐसा नहीं होता है, इसलिए मैं इस टिप्पणी को केवल इस मामले में जोड़ता हूं:
इस ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); का उपयोग करना ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); यह कहने के लिए कि फाइल कहां लिखी गई है।


var path = 'public/uploads/file.txt',
buffer = new Buffer("some content\n");

fs.open(path, 'w', function(err, fd) {
    if (err) {
        throw 'error opening file: ' + err;
    }

    fs.write(fd, buffer, 0, buffer.length, null, function(err) {
        if (err) throw 'error writing file: ' + err;
        fs.close(fd, function() {
            console.log('file written');
        })
    });
});

 var fs = require('fs');
 fs.writeFile(path + "\\message.txt", "Hello", function(err){
 if (err) throw err;
  console.log("success");
}); 

उदाहरण के लिए: फ़ाइल पढ़ें और दूसरी फ़ाइल में लिखें:

  var fs = require('fs');
    var path = process.cwd();
    fs.readFile(path+"\\from.txt",function(err,data)
                {
                    if(err)
                        console.log(err)
                    else
                        {
                            fs.writeFile(path+"\\to.text",function(erro){
                                if(erro)
                                    console.log("error : "+erro);
                                else
                                    console.log("success");
                            });
                        }
                });

आप निश्चित रूप से इसे थोड़ा और उन्नत बना सकते हैं। गैर-अवरुद्ध, बिट्स और टुकड़े लिखना, पूरी फाइल को एक बार में नहीं लिखना:

var fs = require('fs');
var stream = fs.createWriteStream("my_file.txt");
stream.once('open', function(fd) {
  stream.write("My first row\n");
  stream.write("My second row\n");
  stream.end();
});

स्थानीय से फ़ाइल सीएसवी को पढ़ने और स्थानीय रूप से सीएसवी फ़ाइल लिखने का नमूना यहां दिया गया है।

var csvjson = require('csvjson'),
    fs = require('fs'),
    mongodb = require('mongodb'),
    MongoClient = mongodb.MongoClient,
    mongoDSN = 'mongodb://localhost:27017/test',
    collection;

function uploadcsvModule(){
    var data = fs.readFileSync( '/home/limitless/Downloads/orders_sample.csv', { encoding : 'utf8'});
    var importOptions = {
        delimiter : ',', // optional 
        quote     : '"' // optional 
    },ExportOptions = {
        delimiter   : ",",
        wrap        : false
    }
    var myobj = csvjson.toSchemaObject(data, importOptions)
    var exportArr = [], importArr = [];
    myobj.forEach(d=>{
        if(d.orderId==undefined || d.orderId=='') {
            exportArr.push(d)
        } else {
            importArr.push(d)
        }
    })
    var csv = csvjson.toCSV(exportArr, ExportOptions);
    MongoClient.connect(mongoDSN, function(error, db) {
        collection = db.collection("orders")
        collection.insertMany(importArr, function(err,result){
            fs.writeFile('/home/limitless/Downloads/orders_sample1.csv', csv, { encoding : 'utf8'});
            db.close();
        });            
    })
}

uploadcsvModule()

यहां हम दोनों कार्यों को पढ़ने / लिखने के लिए w + का उपयोग करते हैं और यदि फ़ाइल पथ नहीं मिला है तो यह स्वचालित रूप से बनाया जाएगा।

fs.open(path, 'w+', function(err, data) {
    if (err) {
        console.log("ERROR !! " + err);
    } else {
        fs.write(data, 'content', 0, 'content length', null, function(err) {
            if (err)
                console.log("ERROR !! " + err);
            fs.close(data, function() {
                console.log('written success');
            })
        });
    }
});

सामग्री का मतलब है कि आपको फ़ाइल और इसकी लंबाई, 'content.length' पर क्या लिखना है।







fs