Node.js හි ගොනු ලිවීම

මම Node.js භාවිතා කරන විට ගොනුවකට ලිවීමට ක්‍රමයක් සෙවීමට උත්සාහ කළ නමුත් එය සාර්ථක නොවීය. මට එය කළ හැක්කේ කෙසේද?

ගොනු පද්ධති API හි බොහෝ විස්තර තිබේ . වඩාත් පොදු ක්‍රමය නම්:

const fs = require('fs');

fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }
    console.log("The file was saved!");
}); 

// Or
fs.writeFileSync('/tmp/test-sync', 'Hey there!');

ගොනුවක් ලිවීමට දැනට ක්‍රම තුනක් තිබේ:

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

   බෆරය තැටියට ලියා ඇති බව සහතික කිරීම සඳහා ඔබ ඇමතුම ලබා ගැනීම සඳහා බලා සිටිය යුතුය. එය ආරක්ෂිත නොවේ.

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

   සියලුම දත්ත එකවර ගබඩා කළ යුතුය; ඔබට අනුක්‍රමික ලිවීම් කළ නොහැක.

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

   සාදනු WriteStreamඔබ callback සඳහා බලා සිටීමට අවශ්ය නැති නිසා පහසු වන. නමුත් නැවතත්, එය ආරක්ෂිත නොවේ.

A WriteStream, නම පවසන පරිදි, ධාරාවකි. අර්ථ දැක්වීම අනුව ප්‍රවාහයක් යනු එක් දිශාවකට (ප්‍රභව ► ගමනාන්තය) ගමන් කරන දත්ත අඩංගු “බෆරයක්” වේ. නමුත් ලිවිය හැකි ප්‍රවාහයක් අනිවාර්යයෙන්ම “බෆර්” නොවේ. ඔබ nවේලාවන් ලියන විට ධාරාවක් “ n+1ස්වාරක්ෂක” වන අතර, එම අවස්ථාවේ දී, ධාරාව කර්නලය වෙත බෆරය යවයි (මන්ද එය පිරී ඇති අතර එය පිස දැමිය යුතු බැවිනි).

වෙනත් වචන වලින් කිවහොත්: “බෆරය” යනු වස්තුවයි. එය “බෆර් කර තිබේද” යන්න එම වස්තුවේ දේපලකි.

ඔබ කේතය දෙස බැලුවහොත්, WriteStreamලිවිය හැකි Streamවස්තුවකින් උරුම වේ . ඔබ අවධානය යොමු කරන්නේ නම්, ඔවුන් අන්තර්ගතය ගලවන ආකාරය ඔබට පෙනෙනු ඇත; ඔවුන්ට කිසිදු බෆරින් පද්ධතියක් නොමැත.

ඔබ නූලක් ලියන්නේ නම්, එය බෆරයක් බවට පරිවර්තනය කර, පසුව ස්වදේශීය ස්ථරයට යවා තැටියට ලියා ඇත. නූල් ලියන විට, ඔවුන් කිසිදු බෆරයක් පුරවන්නේ නැත. එබැවින්, ඔබ එසේ කරන්නේ නම්:

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

ඔබ කරනවා:

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

එය I / O ස්තරයට ඇමතුම් තුනක් . ඔබ “බෆර” භාවිතා කළද, දත්ත ආරක්ෂිත නොවේ. ස්වාරක්ෂක ප්‍රවාහයක් කරන්නේ : fs.write(new Buffer ("abc")), I / O ස්තරයට එක් ඇමතුමක්.

මේ වන විට, Node.js v0.12 හි (ස්ථාවර අනුවාදය 02/06/2015 නිවේදනය කර ඇත) දැන් කාර්යයන් දෙකකට සහය දක්වයි: cork()සහ uncork(). මෙම කාර්යයන් අවසානයේ ඔබට ලිවීමේ ඇමතුම් බෆර් / ෆ්ලෂ් කිරීමට ඉඩ දෙන බව පෙනේ.

උදාහරණයක් ලෙස, ජාවා හි ස්වාරක්ෂක ධාරාවන් සපයන පන්ති කිහිපයක් ඇත ( BufferedOutputStream, BufferedWriter...). ඔබ බයිට් තුනක් ලියන්නේ නම්, මෙම බයිට් බයිට් තුනක් සඳහා I / O ඇමතුමක් ලබා ගැනීම වෙනුවට බෆරයේ (මතකය) ගබඩා වේ. බෆරය පිරී ඇති විට අන්තර්ගතය ෆ්ලෂ් කර තැටියට සුරකිනු ලැබේ. මෙය කාර්ය සාධනය වැඩි දියුණු කරයි.

මම කිසිවක් සොයා නොගත්තෙමි, තැටියට ප්‍රවේශ විය යුතු ආකාරය මතක තබා ගන්න.

ඔබට එය තව ටිකක් දියුණු කළ හැකිය. අවහිර නොකිරීම, බිටු සහ කෑලි ලිවීම, සම්පූර්ණ ගොනුව එකවරම ලිවීම නොවේ:

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

සමමුහුර්ත ලිවීම

fs.writeFileSync (ගොනුව, දත්ත [, විකල්ප])

fs = require('fs');

fs.writeFileSync("synchronous.txt", "synchronous write!")

අසමමුහුර්ත ලිවීම

fs.writeFile (ගොනුව, දත්ත [, විකල්ප], ඇමතුම් ආපසු)

fs = require('fs');

fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
  if (err) throw err;
  console.log('The file has been saved!');
});

කොහෙද

file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>

අක්‍රීය ගොනු පද්ධතිය (fs) ලියකියවිලි කියවීම වටී .

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

මම ./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);කිරීම.

ලබා දී ඇති පිළිතුරු දින වකවානු වන අතර මෙය කිරීමට නව ක්‍රමයක් වන්නේ:

const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')

වැඩි විස්තර සඳහා මෙහි ලේඛන බලන්න

"ලිවීම" ගැන ඇසූ ප්‍රශ්නය මම දනිමි, නමුත් වඩාත් සාමාන්‍ය අර්ථයෙන් "උපග්‍රන්ථය" සමහර අවස්ථාවලදී ප්‍රයෝජනවත් විය හැකි බැවින් ගොනුවකට පෙළ එක් කිරීම සඳහා ලූපයක් භාවිතා කිරීම පහසුය (ගොනුව තිබේද නැද්ද යන්න). ඔබට පේළි එක් කිරීමට අවශ්‍ය නම් "\ n" භාවිතා කරන්න උදා:

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}

හරි, එය node එකක් මතම ඊට අදාල මේ සඳහා ක්රියාකාරිත්වය ඉදි-ඇති පරිදි, එයට අමතන්නේ ඉතා සරලයි fsසඳහා කි්රයා කරන ගොනු පද්ධතිය හා මූලික වශයෙන්, NodeJS ගොනු පද්ධතිය මොඩියුලය ...

එබැවින් පළමුව ඔබේ server.js ගොනුවට මෙය අවශ්‍ය වේ:

var fs = require('fs');

fsගොනුවට ලිවීමට ක්‍රම කිහිපයක් ඇත, නමුත් මා කැමති ක්‍රමය භාවිතා කරයි appendFile, මෙය ගොනුවට දේවල් එකතු කරන අතර ගොනුව නොපවතින විට එකක් නිර්මාණය කරයි, කේතය පහත පරිදි විය හැකිය:

fs.appendFile('myFile.txt', 'Hi Ali!', function (err) {
  if (err) throw err;
  console.log('Thanks, It\'s saved to the file!');
});

ඔබට fs (ගොනු පද්ධතිය) මොඩියුලය භාවිතා කර ගොනුවකට ලිවිය හැකිය .

ඔබට එය කළ හැකි ආකාරය පිළිබඳ උදාහරණයක් මෙන්න:

const fs = require('fs');

const writeToFile = (fileName, callback) => {
  fs.open(fileName, 'wx', (error, fileDescriptor) => {
    if (!error && fileDescriptor) {
      // Do something with the file here ...
      fs.writeFile(fileDescriptor, newData, (error) => {
        if (!error) {
          fs.close(fileDescriptor, (error) => {
            if (!error) {
              callback(false);
            } else {
              callback('Error closing the file');
            }
          });
        } else {
          callback('Error writing to new file');
        }
      });
    } else {
      callback('Could not create new file, it may already exists');
    }
  });
};

පොරොන්දු සහ async/ awaitප්‍රකාශ භාවිතා කිරීමෙන් ඔබට මෙම ඇමතුම් ආපසු ඇතුළත ඇමතුම් ලබා ගැනීමේ කේත ව්‍යුහයෙන් මිදීමට අවශ්‍ය විය හැකිය . මෙය අසමමුහුර්ත කේත ව්‍යුහය වඩාත් සමතලා කරනු ඇත. එසේ කිරීම සඳහා ඉතා ප්‍රයෝජනවත් උපයෝගීතාවයක් ඇත. (මුල්) ශ්‍රිතය භාවිතා කළ හැකිය. ඇමතුම් වලින් ආපසු පොරොන්දු වෙත මාරු වීමට එය අපට ඉඩ දෙයි. fsපහත කාර්යයන් සමඟ උදාහරණය දෙස බලන්න:

// Dependencies.
const util = require('util');
const fs = require('fs');

// Promisify "error-back" functions.
const fsOpen = util.promisify(fs.open);
const fsWrite = util.promisify(fs.writeFile);
const fsClose = util.promisify(fs.close);

// Now we may create 'async' function with 'await's.
async function doSomethingWithFile(fileName) {
  const fileDescriptor = await fsOpen(fileName, 'wx');

  // Do something with the file here...

  await fsWrite(fileDescriptor, newData);
  await fsClose(fileDescriptor);
}

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

මෙහිදී අපි ක්‍රියා දෙකම කියවීමට / ලිවීමට 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' යන්නයි.

Csv ගොනුව දේශීයව කියවා csv ගොනුව දේශීයව ලියන ආකාරය පිළිබඳ නියැදිය මෙන්න.

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()

fs.createWriteStream(path[,options])

optionsstartගොනුවේ ආරම්භයේ සිට යම් ස්ථානයක දත්ත ලිවීමට ඉඩ දීමේ විකල්පයක් ද ඇතුළත් විය හැකිය . ගොනුවක් ප්‍රතිස්ථාපනය කරනවාට වඩා වෙනස් කිරීම පෙරනිමි ප්‍රකාරයට වඩා flagsමාදිලියක් අවශ්‍ය විය හැකිය . කේතනය කිරීම බෆර් විසින් පිළිගත් ඕනෑම එකක් විය හැකිය .r+w

autoCloseසත්‍ය ලෙස සකසා ඇත්නම් (පෙරනිමි හැසිරීම) 'error'හෝ 'finish'ගොනු විස්තරය ස්වයංක්‍රීයව වසා දමනු ඇත. autoCloseඅසත්‍ය නම් , දෝෂයක් තිබුණද, ගොනු විස්තරය වසා නොදමනු ඇත. එය වසා දමා ගොනු විස්තර කිරීමේ කාන්දුවක් නොමැති බවට වග බලා ගැනීම යෙදුමේ වගකීම වේ.

ReadStream මෙන් , fdනියම කර ඇත්නම් , WriteStreampath තර්කය නොසලකා හරිනු ඇති අතර නිශ්චිත ගොනු විස්තරය භාවිතා කරනු ඇත. මෙයින් අදහස් කරන්නේ කිසිදු 'open'සිදුවීමක් විමෝචනය නොවන බවයි. fdඅවහිර කළ යුතුය; අවහිර නොකරන ලද fdඒවා net.Socket වෙත යැවිය යුතුය .

නම් optionsවැලක් වන අතර, එවිට එය කේතන දක්වයි.

පසුව, මෙම දිගු ලිපිය කියවීම. එය ක්‍රියාත්මක වන ආකාරය ඔබ තේරුම් ගත යුතුය. ඉතින්, මෙන්න උදාහරණයක් createWriteStream().

/* The fs.createWriteStream() returns an (WritableStream {aka} internal.Writeable) and we want the encoding as 'utf'-8 */
/* The WriteableStream has the method write() */
fs.createWriteStream('out.txt', 'utf-8')
.write('hello world');

ඔබට පුස්තකාලය භාවිතා කළ හැකිය easy-file-manager

පළමුව npm සිට ස්ථාපනය කරන්න 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);
});

ඔබට ධාරාවන් සහිත ලිපිගොනු වලට ලිවිය හැකිය.

මේ ආකාරයට කරන්න:

const fs = require('fs');

const stream = fs.createWriteStream('./test.txt');
stream.write("Example text");

පහත දැක්වෙන කේත උදාහරණයෙන් ඔබට ගොනුවක ලිවිය හැකිය:

var data = [{ 'test': '123', 'test2': 'Lorem Ipsem ' }];
fs.open(datapath + '/data/topplayers.json', 'wx', function (error, fileDescriptor) {
  if (!error && fileDescriptor) {
    var stringData = JSON.stringify(data);
    fs.writeFile(fileDescriptor, stringData, function (error) {
      if (!error) {
        fs.close(fileDescriptor, function (error) {
          if (!error) {
            callback(false);
          } else {
            callback('Error in close file');
          }
        });
      } else {
        callback('Error in writing file.');
      }
    });
  }
});