在Node.js中编写文件-Java 学习之路

1255

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

12 回答

这里我们使用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' .

回复于 2024-05-17T14:55:48+08:00

458

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

回复于 2024-05-17T14:55:48+08:00

1950

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

回复于 2024-05-17T14:55:48+08:00

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

回复于 2024-05-17T14:55:48+08:00

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

回复于 2024-05-17T14:55:48+08:00

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

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

回复于 2024-05-17T14:55:48+08:00

Synchronous Write

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

fs = require('fs');

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

Asynchronous Write

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

fs = require('fs');

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

Where

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

值得阅读官方文件系统（fs）docs .

回复于 2024-05-17T14:55:48+08:00

210
我知道有关“写入”的问题，但在更一般的意义上，“追加”在某些情况下可能很有用，因为它很容易在循环中用于向文件添加文本（无论文件是否存在） . 如果要添加行，请使用“\ n”，例如：
```
var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
```
回复于 2024-05-17T14:55:48+08:00

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

您可能还希望通过使用 Promises 和 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);
}

回复于 2024-05-17T14:55:48+08:00

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

回复于 2024-05-17T14:55:48+08:00

24
目前有三种写文件的方法：
- fs.write(fd, buffer, offset, length, position, callback)
您需要等待回调以确保将缓冲区写入磁盘 . 它没有缓冲 .
- fs.writeFile(filename, data, [encoding], callback)
所有数据必须同时存储;你不能执行顺序写入 .
- fs.createWriteStream(path, [options])
创建一个WriteStream，这很方便，因为你没有't need to wait for a callback. But again, it'没有缓冲 .

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

In other words: “缓冲区”是对象 . 它是否“缓冲”是该对象的属性 .

如果查看代码， 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月6日公布的稳定版）中现在支持两个函数：cork()和uncork() . 看来这些函数最终会允许你缓冲/刷新写调用 .

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

我没有发现任何东西，只记得应该如何进行磁盘访问 .
回复于 2024-05-17T14:55:48+08:00
4
我喜欢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); 来获取文件的写入位置 .
回复于 2024-05-17T14:55:48+08:00

在Node.js中编写文件

12 回答

相关问题