¿Cómo adjuntar a un archivo en Node?

Estoy tratando de agregar una cadena a un archivo de registro. Sin embargo, writeFile borrará el contenido cada vez antes de escribir la cadena.

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

¿Alguna idea de cómo hacer esto de la manera fácil?

Para anexos ocasionales, puede usar appendFile, lo que crea un nuevo identificador de archivo cada vez que se llama:

Asincrónicamente :

const fs = require('fs');

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

Sincrónicamente :

const fs = require('fs');

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

Pero si agrega repetidamente al mismo archivo, es mucho mejor reutilizar el identificador de archivo .

Cuando desee escribir en un archivo de registro, es decir, agregar datos al final de un archivo, nunca lo use appendFile. appendFileabre un identificador de archivo para cada pieza de datos que agrega a su archivo, después de un tiempo obtiene un hermoso EMFILEerror.

Puedo agregar que appendFileno es más fácil de usar que a WriteStream.

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

Hasta 8000 en mi computadora, puede agregar datos al archivo, luego obtiene esto:

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

Además, appendFileescribirá cuando esté habilitado, por lo que sus registros no se escribirán con marca de tiempo. Puede probar con el ejemplo, establecer 1000 en lugar de 100000, el orden será aleatorio, depende del acceso al archivo.

Si desea agregar a un archivo, debe usar una secuencia de escritura como esta:

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

Lo terminas cuando quieres. Ni siquiera está obligado a usar stream.end(), la opción predeterminada es AutoClose:true, por lo que su archivo finalizará cuando finalice su proceso y evite abrir demasiados archivos.

Su código usando createWriteStream crea un descriptor de archivo para cada escritura. log.end es mejor porque le pide al nodo que se cierre inmediatamente después de la escritura.

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

Además appendFile, también puede pasar una bandera writeFilepara agregar datos a un archivo existente.

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

Al pasar la marca 'a', los datos se agregarán al final del archivo.

Debe abrirlo y luego escribirle.

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

Aquí hay algunos enlaces que ayudarán a explicar los parámetros.

abrir
escribir
cerrar

EDITAR : Esta respuesta ya no es válida, busque el nuevo método fs.appendFile para agregar .

Node.js 0.8 tiene fs.appendFile:

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

Documentación

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

Si desea una forma fácil y sin estrés de escribir registros línea por línea en un archivo, le recomiendo 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');

Probado con Nodo v8.9.4.

Mi enfoque es bastante especial. Básicamente uso la WriteStreamsolución pero sin realmente 'cerrar' el fd usando stream.end(). En cambio uso cork/ uncork. Esto obtuvo el beneficio del uso bajo de RAM (si eso es importante para alguien) y creo que es más seguro usarlo para iniciar sesión / grabar (mi caso de uso original).

El siguiente es un ejemplo bastante simple. Tenga en cuenta que acabo de agregar un pseudo forbucle para mostrar: en el código de producción estoy esperando los mensajes de websocket.

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

uncork vaciará los datos al archivo en el siguiente tic.

En mi escenario, hay picos de hasta ~ 200 escrituras por segundo en varios tamaños. Durante la noche, sin embargo, solo se necesitan unas pocas escrituras por minuto. El código funciona súper confiable incluso durante las horas pico.

Ofrezco esta sugerencia solo porque el control sobre las marcas abiertas a veces es útil, por ejemplo, es posible que desee truncar primero un archivo existente y luego agregarle una serie de escrituras, en cuyo caso use la bandera 'w' al abrir el archivo y no lo cierre hasta que todas las escrituras estén terminadas. Por supuesto, appendFile puede ser lo que buscas :-)

  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 el paquete jfile :

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

Usar fs.appendFileo fsPromises.appendFileson las opciones más rápidas y sólidas cuando necesita agregar algo a un archivo.

A diferencia de algunas de las respuestas sugeridas, si la ruta del archivo se proporciona a la appendFilefunción, en realidad se cierra sola . Solo cuando pasa un identificador de archivo que pasa por algo así como fs.open()tiene que encargarse de cerrarlo.

Lo probé con más de 50,000 líneas en un archivo.

Ejemplos:

(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
Ejecución de ejemplo: https://github.com/apickjs/apickFS/blob/master/writeLines.js

Aquí hay un guión completo. ¡Complete sus nombres de archivo y ejecútelo y debería funcionar! Aquí hay un video tutorial sobre la lógica detrás del guió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);

una manera más fácil de hacer esto es

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

Además de la respuesta de denysonique , a veces appendFilese utilizan tipos asíncronos y otros métodos asíncronos en NodeJS donde se devuelve la promesa en lugar de pasar la devolución de llamada. Para hacerlo, debe ajustar la función con promisifyHOF o importar funciones asíncronas desde el espacio de nombres de promesas:

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

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

Espero que ayude 😉