Como anexar a um arquivo no Node?

Estou tentando anexar uma seqüência de caracteres a um arquivo de log. No entanto, o writeFile apagará o conteúdo todas as vezes antes de escrever a string.

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

Alguma idéia de como fazer isso da maneira mais fácil?

Para anexos ocasionais, você pode usar appendFile , o que cria um novo identificador de arquivo cada vez que é chamado:

Assíncrona :

const fs = require('fs');

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

Sincronicamente :

const fs = require('fs');

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

Mas se você anexar repetidamente ao mesmo arquivo, é muito melhor reutilizar o identificador de arquivo .

Quando você deseja gravar em um arquivo de log, ou seja, anexando dados ao final de um arquivo, nunca use appendFile. appendFileabre um identificador de arquivo para cada dado que você adiciona ao seu arquivo, após um tempo você recebe um EMFILEerro bonito .

Posso acrescentar que appendFilenão é mais fácil de usar do que a WriteStream.

Exemplo com 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());

Até 8000 no meu computador, você pode anexar dados ao arquivo e obter o seguinte:

{ 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' }

Além disso, appendFile gravará quando estiver ativado, para que seus logs não sejam gravados com carimbo de data e hora. Você pode testar, por exemplo, definir 1000 no lugar de 100000, a ordem será aleatória, depende do acesso ao arquivo.

Se você deseja anexar a um arquivo, deve usar um fluxo gravável como este:

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

Você termina quando quiser. Você nem precisa usar stream.end(), a opção padrão é que AutoClose:true, assim, seu arquivo será encerrado quando seu processo terminar e você evitará abrir muitos arquivos.

Seu código usando createWriteStream cria um descritor de arquivo para cada gravação. log.end é melhor porque pede que o nó feche imediatamente após a gravação.

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

Além disso appendFile, você também pode passar uma bandeira writeFilepara acrescentar dados a um arquivo existente.

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

Ao passar o sinalizador 'a', os dados serão anexados no final do arquivo.

Você precisa abri-lo e depois escrever nele.

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

Aqui estão alguns links que ajudarão a explicar os parâmetros

abrir
escrever
fechar

EDIT : esta resposta não é mais válida, procure o novo método fs.appendFile para anexar.

O Node.js 0.8 possui fs.appendFile:

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

Documentação

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

Se você deseja uma maneira fácil e sem estresse de escrever registros linha por linha em um arquivo, recomendo o fs-extra :

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

Testado com o nó v8.9.4.

Minha abordagem é bastante especial. Basicamente, uso a WriteStreamsolução, mas sem 'fechar' o fd usando stream.end(). Em vez disso, eu uso cork/uncork . Isso tem o benefício do baixo uso de RAM (se isso for importante para alguém) e acredito que é mais seguro usar para log / gravação (meu caso de uso original).

A seguir, é apresentado um exemplo bastante simples. Observe que acabei de adicionar um forloop pseudo para showcase - no código de produção, estou aguardando mensagens do websocket.

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

uncork liberará os dados para o arquivo no próximo tick.

No meu cenário, existem picos de até ~ 200 gravações por segundo em vários tamanhos. Durante a noite, porém, são necessárias apenas algumas gravações por minuto. O código está funcionando super confiável mesmo nos horários de pico.

Eu ofereço essa sugestão apenas porque o controle sobre os sinalizadores abertos às vezes é útil; por exemplo, você pode truncar primeiro um arquivo existente e depois anexar uma série de gravações a ele - nesse caso, use o sinalizador 'w' ao abrir o arquivo e não feche até que todas as gravações estejam concluídas. É claro que appendFile pode ser o que você procura :-)

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

Usando o pacote jfile :

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

Usar fs.appendFileou fsPromises.appendFilesão as opções mais rápidas e robustas quando você precisa acrescentar algo a um arquivo.

Ao contrário de algumas das respostas sugeridas, se o caminho do arquivo é fornecido para a appendFilefunção, ele realmente fecha sozinho . Somente quando você passa um identificador de arquivo que obtém algo como fs.open()você precisa cuidar para fechá-lo.

Eu tentei com mais de 50.000 linhas em um arquivo.

Exemplos :

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

Ref: https://github.com/nodejs/node/issues/7560
Exemplo de execução: https://github.com/apickjs/apickFS/blob/master/writeLines.js

Aqui está um script completo. Preencha os nomes dos arquivos e execute-os e ele deve funcionar! Aqui está um tutorial em vídeo sobre a lógica por trás do script.

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

uma maneira mais fácil de fazer isso é

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

Além da resposta da denysonique , às vezes appendFilesão utilizados tipos assíncronos e outros métodos assíncronos no NodeJS, nos quais a promessa retorna em vez da passagem de retorno de chamada. Para isso, é necessário agrupar a função com promisifyHOF ou importar funções assíncronas do namespace promises:

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

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

Espero que ajude 😉