Escribir en archivos en Node.js

Question 1

He estado tratando de encontrar una manera de escribir en un archivo cuando uso Node.js, pero sin éxito. ¿Cómo puedo hacer eso?

Question 2

Hay muchos detalles en el API del sistema de archivos. La forma más común es:

const fs = require('fs');

fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }
    console.log("The file was saved!");
}); 

// Or
fs.writeFileSync('/tmp/test-sync', 'Hey there!');

Question 3

Actualmente hay tres formas de escribir un archivo:

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

Debe esperar la devolución de llamada para asegurarse de que el búfer se escriba en el disco. No está amortiguado.
fs.writeFile(filename, data, [encoding], callback)

Todos los datos deben almacenarse al mismo tiempo; no puede realizar escrituras secuenciales.
fs.createWriteStream(path, [options])

Crea un WriteStream, lo cual es conveniente porque no necesita esperar una devolución de llamada. Pero, de nuevo, no está almacenado en búfer.

A WriteStream, como su nombre lo dice, es un arroyo. Una secuencia, por definición, es “un búfer” que contiene datos que se mueven en una dirección (fuente ► destino). Pero un flujo grabable no está necesariamente “almacenado en búfer”. Una transmisión se “almacena en búfer” cuando escribes n tiempos, y en el tiempo n+1la transmisión envía el búfer al kernel (porque está lleno y debe vaciarse).

En otras palabras: “Un amortiguador” es el objeto. Si está o no “en el búfer” es una propiedad de ese objeto.

Si miras el código, el WriteStream hereda de un escribible Stream objeto. Si prestas atención, verás como tiran el contenido; no tienen ningún sistema de almacenamiento en búfer.

Si escribe una cadena, se convierte en un búfer y luego se envía a la capa nativa y se escribe en el disco. Al escribir cadenas, no llenan ningún búfer. Entonces, si lo haces:

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

Estás haciendo:

fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))

Eso es Tres llamadas a la capa de E/S. Aunque esté utilizando “búferes”, los datos no se almacenan en búfer. Una secuencia almacenada en búfer haría: fs.write(new Buffer ("abc"))una llamada a la capa de E/S.

A partir de ahora, en Node.js v0.12 (versión estable anunciada el 06/02/2015) ahora admite dos funciones:
cork() y
uncork(). Parece que estas funciones finalmente le permitirán almacenar en búfer/vaciar las llamadas de escritura.

Por ejemplo, en Java hay algunas clases que proporcionan flujos almacenados en búfer (BufferedOutputStream, BufferedWriter…). Si escribe tres bytes, estos bytes se almacenarán en el búfer (memoria) en lugar de realizar una llamada de E/S solo para tres bytes. Cuando el búfer está lleno, el contenido se vacía y se guarda en el disco. Esto mejora el rendimiento.

No estoy descubriendo nada, solo recordando cómo se debe hacer un acceso al disco.

Question 4

Por supuesto, puedes hacerlo un poco más avanzado. Sin bloqueo, escribiendo fragmentos, sin escribir todo el archivo a la vez:

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

Question 5

Escritura síncrona

fs.writeFileSync(archivo, datos[, options])

fs = require('fs');

fs.writeFileSync("foo.txt", "bar");

Escritura asíncrona

fs.writeFile(archivo, datos[, options]llamar de vuelta)

fs = require('fs');

fs.writeFile('foo.txt', 'bar', (err) => { if (err) throw err; });

Donde

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

Vale la pena leer el sistema de archivos oficial (fs) documentos.

Actualización: asíncrono/espera

fs = require('fs');
util = require('util');
writeFile = util.promisify(fs.writeFile);

fn = async () => { await writeFile('foo.txt', 'bar'); }

fn()

Question 6

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

Question 7

Las respuestas proporcionadas están fechadas y una forma más nueva de hacerlo es:

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

ver documentos aquí para más información

Question 8

me gustó Índice de ./articles/file-system.

Funcionó para mí.

Ver también ¿Cómo escribo archivos en 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');
});

Contenido de holamundo.txt:

Hello World!

Actualizar:
Como en el nodo de Linux escribe en el directorio actual, parece que en otros no, así que agrego este comentario por si acaso:
Usando esto ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); para llegar donde está escrito el archivo.

¿Ha sido útil esta solución?