Làm thế nào để nối vào một tập tin trong Node?

Tôi đang cố gắng nối một chuỗi vào một tệp nhật ký. Tuy nhiên writeFile sẽ xóa nội dung mỗi lần trước khi viết chuỗi.

fs.writeFile('log.txt', 'Hello Node', function (err) {
  if (err) throw err;
  console.log('It\'s saved!');
}); // => message.txt erased, contains only 'Hello Node'

Bất kỳ ý tưởng làm thế nào để làm điều này một cách dễ dàng?

Đối với các lần bổ sung không thường xuyên, bạn có thể sử dụng appendFile, điều này tạo ra một tệp xử lý mới mỗi lần nó được gọi là:

Không đồng bộ :

const fs = require('fs');

fs.appendFile('message.txt', 'data to append', function (err) {
  if (err) throw err;
  console.log('Saved!');
});

Đồng bộ :

const fs = require('fs');

fs.appendFileSync('message.txt', 'data to append');

Nhưng nếu bạn nối lại nhiều lần vào cùng một tệp, tốt hơn hết là sử dụng lại phần xử lý tệp .

Khi bạn muốn ghi vào một tệp nhật ký, tức là nối thêm dữ liệu vào cuối tệp, không bao giờ sử dụng appendFile. appendFilemở một xử lý tệp cho mỗi phần dữ liệu bạn thêm vào tệp của mình, sau một thời gian bạn sẽ gặp một EMFILElỗi đẹp .

Tôi có thể thêm rằng appendFilekhông dễ sử dụng hơn a WriteStream.

Ví dụ với appendFile:

console.log(new Date().toISOString());
[...Array(10000)].forEach( function (item,index) {
    fs.appendFile("append.txt", index+ "\n", function (err) {
        if (err) console.log(err);
    });
});
console.log(new Date().toISOString());

Lên đến 8000 trên máy tính của tôi, bạn có thể nối dữ liệu vào tệp, sau đó bạn có được điều này:

{ Error: EMFILE: too many open files, open 'C:\mypath\append.txt'
    at Error (native)
  errno: -4066,
  code: 'EMFILE',
  syscall: 'open',
  path: 'C:\\mypath\\append.txt' }

Hơn nữa, appendFilesẽ viết khi nó được kích hoạt, vì vậy nhật ký của bạn sẽ không được ghi bởi dấu thời gian. Bạn có thể kiểm tra với ví dụ, đặt 1000 thay cho 100000, thứ tự sẽ là ngẫu nhiên, tùy thuộc vào quyền truy cập vào tệp.

Nếu bạn muốn thêm vào một tệp, bạn phải sử dụng một luồng có thể ghi như thế này:

var stream = fs.createWriteStream("append.txt", {flags:'a'});
console.log(new Date().toISOString());
[...Array(10000)].forEach( function (item,index) {
    stream.write(index + "\n");
});
console.log(new Date().toISOString());
stream.end();

Bạn kết thúc nó khi bạn muốn. Bạn thậm chí không bắt buộc phải sử dụng stream.end(), tùy chọn mặc định là AutoClose:truevậy, vì vậy tệp của bạn sẽ kết thúc khi quá trình của bạn kết thúc và bạn tránh mở quá nhiều tệp.

Mã của bạn bằng cách sử dụng createWriteStream tạo một mô tả tệp cho mỗi lần ghi. log.end tốt hơn bởi vì nó yêu cầu nút đóng ngay sau khi ghi.

var fs = require('fs');
var logStream = fs.createWriteStream('log.txt', {flags: 'a'});
// use {flags: 'a'} to append and {flags: 'w'} to erase and write a new file
logStream.write('Initial line...');
logStream.end('this is the end line');

Ngoài ra appendFile, bạn cũng có thể truyền cờ vào writeFileđể chắp thêm dữ liệu vào tệp hiện có.

fs.writeFile('log.txt', 'Hello Node',  {'flag':'a'},  function(err) {
    if (err) {
        return console.error(err);
    }
});

Bằng cách chuyển cờ 'a', dữ liệu sẽ được thêm vào cuối tệp.

Bạn cần mở nó, sau đó viết thư cho nó.

var fs = require('fs'), str = 'string to append to file';
fs.open('filepath', 'a', 666, function( e, id ) {
  fs.write( id, 'string to append to file', null, 'utf8', function(){
    fs.close(id, function(){
      console.log('file closed');
    });
  });
});

Dưới đây là một vài liên kết sẽ giúp giải thích các tham số

mở
viết
gần

EDIT : Câu trả lời này không còn hợp lệ, hãy xem phương pháp fs.appendFile mới để nối thêm.

Node.js 0.8 có fs.appendFile:

fs.appendFile('message.txt', 'data to append', (err) => {
  if (err) throw err;
  console.log('The "data to append" was appended to file!');
});

Tài liệu

fd = fs.openSync(path.join(process.cwd(), 'log.txt'), 'a')
fs.writeSync(fd, 'contents to append')
fs.closeSync(fd)

Nếu bạn muốn một cách dễ dàng và không căng thẳng để viết nhật ký từng dòng trong một tệp, thì tôi khuyên bạn nên fs-thêm :

const os = require('os');
const fs = require('fs-extra');

const file = 'logfile.txt';
const options = {flag: 'a'};

async function writeToFile(text) {
  await fs.outputFile(file, `${text}${os.EOL}`, options);
}

writeToFile('First line');
writeToFile('Second line');
writeToFile('Third line');
writeToFile('Fourth line');
writeToFile('Fifth line');

Đã thử nghiệm với Node v8.9.4.

Cách tiếp cận của tôi khá đặc biệt. Về cơ bản tôi sử dụng WriteStreamgiải pháp nhưng không thực sự 'đóng' fd bằng cách sử dụng stream.end(). Thay vào đó tôi sử dụng cork/ uncork. Điều này có lợi ích của việc sử dụng RAM thấp (nếu điều đó quan trọng với bất kỳ ai) và tôi tin rằng việc sử dụng để ghi / ghi lại (trường hợp sử dụng ban đầu của tôi) sẽ an toàn hơn.

Sau đây là một ví dụ khá đơn giản. Lưu ý rằng tôi vừa thêm một forvòng lặp giả để giới thiệu - trong mã sản xuất tôi đang chờ tin nhắn websocket.

var stream = fs.createWriteStream("log.txt", {flags:'a'});
for(true) {
  stream.cork();
  stream.write("some content to log");
  process.nextTick(() => stream.uncork());
}

uncork sẽ xóa dữ liệu vào tập tin trong tích tắc tiếp theo.

Trong kịch bản của tôi, có các đỉnh lên tới ~ 200 ghi mỗi giây với nhiều kích cỡ khác nhau. Tuy nhiên, vào ban đêm, chỉ cần một ít viết mỗi phút. Mã này đang hoạt động siêu đáng tin cậy ngay cả trong thời gian cao điểm.

Tôi chỉ đưa ra đề xuất này vì việc kiểm soát cờ mở đôi khi rất hữu ích, ví dụ, bạn có thể muốn cắt bớt tệp đó trước và sau đó nối thêm một loạt ghi vào nó - trong trường hợp đó sử dụng cờ 'w' khi mở tệp và không đóng nó cho đến khi tất cả các bài viết được thực hiện. Tất nhiên appendFile có thể là những gì bạn đang theo đuổi :-)

  fs.open('log.txt', 'a', function(err, log) {
    if (err) throw err;
    fs.writeFile(log, 'Hello Node', function (err) {
      if (err) throw err;
      fs.close(log, function(err) {
        if (err) throw err;
        console.log('It\'s saved!');
      });
    });
  });

Sử dụng gói jfile :

myFile.text+='\nThis is new line to be appended'; //myFile=new JFile(path);

Sử dụng fs.appendFilehoặc fsPromises.appendFilelà các tùy chọn nhanh nhất và mạnh mẽ nhất khi bạn cần nối một cái gì đó vào một tệp.

Ngược lại với một số câu trả lời được đề xuất, nếu đường dẫn tệp được cung cấp cho appendFilehàm, nó thực sự tự đóng . Chỉ khi bạn vượt qua trong một tập tin mà bạn nhận được bằng một cái gì đó giống như fs.open()bạn phải chăm sóc đóng nó.

Tôi đã thử nó với hơn 50.000 dòng trong một tập tin.

Ví dụ:

(async () => {
  // using appendFile.
  const fsp = require('fs').promises;
  await fsp.appendFile(
    '/path/to/file', '\r\nHello world.'
  );

  // using apickfs; handles error and edge cases better.
  const apickFileStorage = require('apickfs');
  await apickFileStorage.writeLines(
    '/path/to/directory/', 'filename', 'Hello world.'
  );
})();

Tham chiếu: https://github.com/nodejs/node/issues/7560
Thực thi ví dụ: https://github.com/apickjs/apickFS/blob/master/writeLines.js

Đây là một kịch bản đầy đủ. Điền vào tên tệp của bạn và chạy nó và nó sẽ hoạt động! Đây là một video hướng dẫn về logic đằng sau kịch bản.

var fs = require('fs');

function ReadAppend(file, appendFile){
  fs.readFile(appendFile, function (err, data) {
    if (err) throw err;
    console.log('File was read');

    fs.appendFile(file, data, function (err) {
      if (err) throw err;
      console.log('The "data to append" was appended to file!');

    });
  });
}
// edit this with your file names
file = 'name_of_main_file.csv';
appendFile = 'name_of_second_file_to_combine.csv';
ReadAppend(file, appendFile);

một cách dễ dàng hơn để làm điều này là

const fs = require('fs');
fs.appendFileSync('file.txt', 'message to append into file');

const inovioLogger = (logger = "") => {
    const log_file = fs.createWriteStream(__dirname + `/../../inoviopay-${new Date().toISOString().slice(0, 10)}.log`, { flags: 'a' });
    const log_stdout = process.stdout;
    log_file.write(logger + '\n');
}

Ngoài câu trả lời của denysonique , đôi khi loại không đồng bộ appendFilevà các phương thức không đồng bộ khác trong NodeJS được sử dụng khi trả lại lời hứa thay vì gọi lại. Để làm điều đó, bạn cần bọc hàm bằng promisifyHOF hoặc nhập các hàm async từ không gian tên hứa hẹn:

const { appendFile } = require('fs').promises;

await appendFile('path/to/file/to/append', dataToAppend, optionalOptions);

Tôi hy vọng nó sẽ giúp