กำลังเขียนไฟล์ใน 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])

   สร้าง a WriteStreamซึ่งสะดวกเพราะคุณไม่ต้องรอการติดต่อกลับ แต่อีกครั้งมันไม่ได้ถูกบัฟเฟอร์

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

นั่นเป็นสามสายไปยัง O ชั้นผมที่ / แม้ว่าคุณจะใช้“ บัฟเฟอร์” ข้อมูลจะไม่ถูกบัฟเฟอร์ สตรีมแบบบัฟเฟอร์จะทำ: fs.write(new Buffer ("abc"))หนึ่งการเรียกไปยังชั้น I / O

ณ ตอนนี้ใน Node.js v0.12 (รุ่นที่มีเสถียรภาพประกาศ 2015/02/06) ในขณะนี้สนับสนุนทั้งสองฟังก์ชั่น: และcork() uncork()ดูเหมือนว่าในที่สุดฟังก์ชั่นเหล่านี้จะช่วยให้คุณสามารถบัฟเฟอร์ / ล้างสายการเขียน

ตัวอย่างเช่นใน Java มีบางคลาสที่จัดเตรียมสตรีมบัฟเฟอร์ ( 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>

คุ้มค่าการอ่านอย่างเป็นทางการ File System (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!

อัปเดต:
เช่นเดียวกับในโหนด Linux เขียนในไดเรกทอรีปัจจุบันดูเหมือนว่าบางคนไม่ทำดังนั้นฉันจึงเพิ่มความคิดเห็นนี้ในกรณี:
ใช้สิ่งนี้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");
}

ตกลงมันค่อนข้างง่ายเพราะโหนดมีฟังก์ชั่นในตัวมันเรียกว่าfsซึ่งย่อมาจากFile Systemและโดยทั่วไปแล้วโมดูล NodeJS File System ...

ดังนั้นก่อนอื่นต้องการมันในไฟล์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!');
});

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

คุณสามารถเขียนไฟล์โดยใช้โมดูล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');
    }
  });
};

คุณอาจต้องการกำจัดโครงสร้างรหัส callback-inside-callback นี้โดยใช้สัญญาและasync/ awaitstatement สิ่งนี้จะทำให้โครงสร้างโค้ดแบบอะซิงโครนัสมีลักษณะแบนมากขึ้น สำหรับการทำเช่นนั้นอาจมีการใช้งานฟังก์ชั่นutil.promisify (ดั้งเดิม) มันช่วยให้เราเปลี่ยนจากการโทรกลับเป็นสัญญา ดูตัวอย่างด้วย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);
}

ที่นี่เราใช้ 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 จาก local และเขียนไฟล์ csv เป็น local

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

optionsอาจรวมถึงstartตัวเลือกเพื่ออนุญาตให้เขียนข้อมูลในบางตำแหน่งผ่านจุดเริ่มต้นของไฟล์ แก้ไขไฟล์มากกว่าแทนที่มันอาจต้องใช้flagsโหมดของการมากกว่าโหมดเริ่มต้นr+ wการเข้ารหัสสามารถเป็นหนึ่งของผู้ที่ได้รับการยอมรับโดยบัฟเฟอร์

หากautoCloseตั้งค่าเป็นเปิด (พฤติกรรมเริ่มต้น) 'error'หรือ'finish'ตัวให้คำอธิบายไฟล์จะถูกปิดโดยอัตโนมัติ หากautoCloseเป็นเท็จตัวอธิบายไฟล์จะไม่ถูกปิดแม้ว่าจะมีข้อผิดพลาด มันเป็นความรับผิดชอบของแอพพลิเคชั่นที่จะปิดมันและทำให้แน่ใจว่าไม่มีไฟล์ descriptor รั่วไหล

เช่นเดียวกับReadStreamหากfdมีการระบุไว้WriteStreamจะไม่สนใจpathอาร์กิวเมนต์และจะใช้ file descriptor ที่ระบุ ซึ่งหมายความว่าจะไม่มี'open'เหตุการณ์ใดถูกปล่อยออกมา fdควรปิดกั้น non-blocking 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);
});

คุณสามารถเขียนไฟล์ด้วยตัวอย่างของรหัสต่อไปนี้:

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