同步写入

fs.writeFileSync（文件，数据[，选项]）

fs = require('fs');

fs.writeFileSync("foo.txt", "bar");

异步写入

fs.writeFile（文件，数据[，选项]，回调）

fs = require('fs');

fs.writeFile('foo.txt', 'bar', (err) => { if (err) throw err; });

哪里

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

值得阅读官方文件系统（fs）文档。

更新：async/await

fs = require('fs');
util = require('util');
writeFile = util.promisify(fs.writeFile);

fn = async () => { await writeFile('foo.txt', 'bar'); }

fn()

以下是如何从本地读取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()

你当然可以让它更高级一点。非阻塞、写入位和段，而不是一次写入整个文件：

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

我知道关于“写”的问题，但在更一般的意义上，“附加”在某些情况下可能有用，因为它很容易在循环中使用，以便向文件中添加文本（无论文件是否存在）。如果要添加行，请使用“\n”，例如：

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

您可以通过以下代码示例写入文件：

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

目前有三种方法可以写入文件：

fs.write（fd，缓冲区，偏移量，长度，位置，回调）您需要等待回调，以确保缓冲区已写入磁盘。它没有缓冲。fs.writeFile（文件名，数据，[编码]，回调）所有数据必须同时存储；不能执行顺序写入。fs.createWriteStream（路径，[options]）创建WriteStream，这很方便，因为您不需要等待回调。但同样，它没有缓冲。

顾名思义，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（2015年6月2日发布的稳定版本）现在支持两个功能：软木塞（）和解开（）。似乎这些函数最终将允许您缓冲/刷新写调用。

例如，在Java中，有一些类提供缓冲流（BufferedOutputStream、BufferedWriter…）。如果您写入三个字节，这些字节将存储在缓冲区（内存）中，而不是仅为三个字节执行I/O调用。当缓冲区已满时，内容将被刷新并保存到磁盘。这提高了性能。

我没有发现任何东西，只是记得应该如何进行磁盘访问。