Question

我一直在尝试使用Node.js找到写入文件的方法，但没有成功。我怎么能这样做？

Answer 1

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

Answer 2

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

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

您需要等待回调以确保将缓冲区写入磁盘。它没有缓冲。
fs.writeFile(filename, data, [encoding], callback)

所有数据必须同时存储;你无法执行顺序写入。
fs.createWriteStream(path, [options])

创建一个WriteStream，这很方便，因为您不需要等待回调。但同样，它没有被缓冲。

如名称所示，WriteStream是一个流。根据定义，流是“缓冲区”，包含在一个方向上移动的数据（源►目的地）。但是可写流不一定是“缓冲的”。当您写n次时，流被“缓冲”，并且在时间n+1，流将缓冲区发送到内核（因为它已满，需要刷新）。

换句话说：“缓冲区”是对象。它是否“缓冲”是该对象的属性。

如果查看代码，WriteStream继承自可写{{1}}对象。如果你注意，你会看到他们如何刷新内容;他们没有任何缓冲系统。

如果您编写一个字符串，它将转换为缓冲区，然后发送到本机层并写入磁盘。在编写字符串时，它们不会填充任何缓冲区。所以，如果你这样做：

Stream

你在做：

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

这是三个调用I / O层。虽然您使用的是“缓冲区”，但数据不会被缓冲。缓冲流将执行：fs.write(new Buffer("a")) fs.write(new Buffer("b")) fs.write(new Buffer("c"))，一次调用I / O层。

截至目前，在Node.js v0.12（2015年2月6日公布的稳定版）中，现在支持两个功能： cork()和 uncork()。看来这些函数最终会允许你缓冲/刷新写调用。

例如，在Java中，有一些类提供缓冲流（fs.write(new Buffer ("abc"))，BufferedOutputStream ...）。如果写入三个字节，这些字节将存储在缓冲区（内存）中，而不是仅为三个字节进行I / O调用。当缓冲区已满时，内容将被刷新并保存到磁盘。这样可以提高性能。

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

Answer 3

你当然可以让它更先进一点。非阻塞，写入碎片，而不是一次写入整个文件：

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

Answer 4

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

Answer 5

同步写入

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）docs。

Answer 6

我喜欢 Index of ./articles/file-system 。

它对我有用。

另请参阅 How do I write files in 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);来获取文件的写入位置。

Answer 7

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

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

Answer 8

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

Answer 9

您可以使用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');
    }
  });
};

您可能还想通过使用 Promise 和async / await语句来摆脱这种内部回调的代码结构。这将使异步代码结构更加平坦。为此，可以使用方便的util.promisify(original)函数。它使我们能够从回调切换到承诺。看看下面带有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);
}

Answer 10

这里我们使用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');
            })
        });
    }
});

内容表示您必须写入文件及其长度，＆＃39; content.length＆＃39;。

Answer 11

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

Answer 12

好的，这很简单，因为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!');
});

Answer 13

您可以使用流写入文件。

只需这样做：

 ArrayList<byte[]> stringImgArry = new ArrayList<byte[]>();

 bitmap = (Bitmap) data.getExtras().get("data");
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
        byte[] byteArray = stream.toByteArray();
        stringImgArry.add(byteArray);

  Log.d("LOG_TAG", " byteArray  " + byteArray);//[B@73c1473
        Log.d("LOG_TAG", " String_byteArray  " + stringImgArry);//[[B@73c1473, [B@d50868c]

        List<String> encodedImageList = new ArrayList<>();
        for (int i = 0; i < stringImgArry.size(); i ++) {
            encodedImageList.add(Base64.encodeToString(stringImgArry.get(i), Base64.DEFAULT));
        }

        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
             ImgString = String.join("    NEXT IMAGE    ", encodedImageList);
        }

        Log.d("LOG_TAG", "Array  base64 image : " + ImgString);
        Log.d("LOG_TAG", "encoded Image List  : " + encodedImageList);
        Log.d("LOG_TAG", "Array  base64 image size  : " + encodedImageList.size());//2

Answer 14

fs.createWriteStream(path[,options])

options也可以包含一个start选项，以允许在文件开头之后的某个位置写入数据。修改文件而不是替换文件可能需要flags的{{1}}模式，而不是默认模式r+。编码可以是Buffer接受的任何一种编码。

如果在w或autoClose上将'error'设置为true（默认行为），则文件描述符将自动关闭。如果'finish'为假，则即使有错误，也不会关闭文件描述符。关闭它并确保没有文件描述符泄漏是应用程序的责任。

类似于ReadStream，如果指定了autoClose，则WriteStream将忽略fd参数，并使用指定的文件描述符。这意味着将不会发出path事件。 'open'应该被屏蔽；非阻塞fd应该传递给net.Socket。

如果fd是字符串，则它指定编码。

之后，请阅读这篇长文章。您应该了解它是如何工作的。因此，这是options的示例。

createWriteStream()

Answer 15

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

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

Answer 16

提供的答案已过时，并且更新的方法是：

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

see doco here for more info

Answer 17

您可以使用库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);
});

Answer 18

尝试以下操作：

fs.readFile(`${__dirname}/fileName`, 'utf-8',(err, contents) => {
    if (err) throw Error(err){
        console.log(contents)
    }
});

Answer 19

第1点：

如果要向文件中写入内容。表示：它将删除文件中已经保存的所有内容并写入新内容。使用 fs.promises.writeFile（）

第2点：

如果要在文件中附加内容。意思是：它将不会删除文件中已经保存的任何内容，而是将新项添加到文件内容中。然后首先读取文件，然后将内容添加到可读值中，然后将其写入文件中。因此请使用 fs.promises.readFile和fs.promises.writeFile（）

示例1：我想在JSON文件中写入一个JSON对象。

const fs = require('fs');

writeFile（文件名，writedata）异步功能writeFile（文件名，writedata）{ 尝试{ 等待fs.promises.writeFile（filename，JSON.stringify（writedata，null，4），'utf8'）; 返回真 } catch（err）{ 返回假 } }

Answer 20

第1点：

如果要向文件中写入内容。表示：它将删除文件中已经保存的所有内容并写入新内容。使用 fs.promises.writeFile（）

第2点：

如果要在文件中附加内容。意思是：它将不会删除文件中已经保存的任何内容，而是将新项添加到文件内容中。然后首先读取文件，然后将内容添加到可读值中，然后将其写入文件中。因此请使用 fs.promises.readFile和fs.promises.writeFile（）

示例1：我想在JSON文件中写入一个JSON对象。

const fs = require('fs');
writeFile  ('./my_data.json' , {id:1, name:'my name'} )
async function writeFile  (filename ,writedata) {
    try {
        await fs.promises.writeFile(filename, JSON.stringify(writedata,null, 4), 'utf8');
       console.log ('data is written successfully in the file')
    }
    catch(err) {
        console.log ('not able to write data in the file ')
    }
}

example2：如果要将数据附加到JSON文件。您想要将数据 {id：1，name：'my name'} 添加到同一文件夹根目录下的 my_data.json 文件中。只需调用 append_data（file_path，data）函数。

如果文件存在，它将在JSON文件中追加数据。否则它将创建文件并向其中添加数据。

   const fs = require('fs');
   data = {id:1, name:'my name'}
   file_path = './my_data.json'
   append_data (file_path , data )

   async function append_data (filename , data ) {

      if (fs.existsSync(filename)) {
         read_data = await readFile(filename)
         if (read_data == false) {
             console.log('not able to read file')
         }
         else {
             read_data.push(data)
             dataWrittenStatus = await writeFile(filename, read_data)
             if dataWrittenStatus == true {
               console.log('data added successfully')
             }
            else{
               console.log('data adding failed')
            }
        }
       else{
          dataWrittenStatus = await writeFile(filename, [data])
          if dataWrittenStatus == true {
             console.log('data added successfully')
          }
          else{
             console.log('data adding failed')
          }
      }
   }



async function readFile  (filePath) {
  try {
    const data = await fs.promises.readFile(filePath, 'utf8')
    return JSON.parse(data)
  }
 catch(err) {
     return false;
  }
}

async function writeFile  (filename ,writedata) {
  try {
      await fs.promises.writeFile(filename, JSON.stringify(writedata,null, 4), 'utf8');
      return true
  }
  catch(err) {
      return false
  }
}

在Node.js中编写文件

20 个答案:

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