Escribir archivos en Node.js

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

Hay muchos detalles en la 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!');

Actualmente hay tres formas de escribir un archivo:

1. 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á protegido.

2. fs.writeFile(filename, data, [encoding], callback)

   Todos los datos deben almacenarse al mismo tiempo; No puede realizar escrituras secuenciales.

3. fs.createWriteStream(path, [options])

   Crea un WriteStream, que es conveniente porque no necesita esperar una devolución de llamada. Pero de nuevo, no está protegido.

A WriteStream, como su nombre lo dice, es una corriente. Una secuencia, por definición, es "un búfer" que contiene datos que se mueven en una dirección (origen ► destino). Pero una secuencia de escritura no está necesariamente "almacenada". Una secuencia se “almacena en búfer” cuando escribe ntiempos, y en ese momento n+1, la secuencia envía el búfer al núcleo (porque está lleno y necesita ser vaciado).

En otras palabras: "Un búfer" es el objeto. Si está o no "almacenado" es una propiedad de ese objeto.

Si observa el código, el WriteStreamhereda de un Streamobjeto grabable . Si prestas atención, verás cómo eliminan 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 están llenando 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"))

Son tres llamadas a la capa de E / S. Aunque está utilizando "buffers", los datos no están almacenados. Una secuencia almacenada 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 02/02/2015) ahora admite dos funciones: cork()y uncork(). Parece que estas funciones finalmente le permitirán almacenar / borrar las llamadas de escritura.

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

No descubro nada, solo recuerdo cómo se debe hacer un acceso al disco.

Por supuesto, puedes hacerlo un poco más avanzado. Sin bloqueo, escribiendo bits y piezas, no escribiendo 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();
});

Escritura Sincrónica

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

fs = require('fs');

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

Escritura asincrónica

fs.writeFile (archivo, datos [, opciones], devolución de llamada)

fs = require('fs');

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

Dónde

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

Vale la pena leer el archivo oficial del sistema (fs) docs .

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

Me gustó Index of ./articles/file-system .

Funcionó para mi.

Consulte 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 helloworld.txt:

Hello World!

Actualización:
Al igual que en el nodo de Linux, escriba en el directorio actual, parece que en otros no, así que agrego este comentario por si acaso:
Utilizando esto ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);para llegar a donde se escribe el archivo.

Las respuestas proporcionadas son anticuadas y una nueva forma 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

Sé que la pregunta sobre "escribir", pero en un sentido más general, "agregar" podría ser útil en algunos casos, ya que es fácil de usar en un bucle para agregar texto a un archivo (ya sea que el archivo exista o no). Utilice un "\ n" si desea agregar líneas, por ejemplo:

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}

OK, es bastante simple ya que Node tiene una funcionalidad incorporada para esto, se llama fsque significa Sistema de archivos y, básicamente, el módulo del Sistema de archivos NodeJS ...

Así que primero pídalo en su archivo server.js como este:

var fs = require('fs');

fstiene pocos métodos para escribir en el archivo, pero mi forma preferida es usarlo appendFile, esto agregará las cosas al archivo y si el archivo no existe, creará uno, el código podría ser el siguiente:

fs.appendFile('myFile.txt', 'Hi Ali!', function (err) {
  if (err) throw err;
  console.log('Thanks, It\'s saved to the file!');
});

 var fs = require('fs');
 fs.writeFile(path + "\\message.txt", "Hello", function(err){
 if (err) throw err;
  console.log("success");
}); 

Por ejemplo: leer el archivo y escribir en otro archivo:

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

Puede escribir en un archivo usando el módulo fs (sistema de archivos).

Aquí hay un ejemplo de cómo puedes hacerlo:

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

También es posible que desee deshacerse de esta estructura de código de devolución de llamada dentro de devolución de llamada utilizando Promesas y declaraciones async/ await. Esto hará que la estructura del código asíncrono sea mucho más plana. Para ello, se puede utilizar una útil función util.promisify (original) . Nos permite cambiar de devoluciones de llamada a promesas. Eche un vistazo al ejemplo con las fsfunciones a continuación:

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

Aquí usamos w + para leer / escribir ambas acciones y si no se encuentra la ruta del archivo, se creará automáticamente.

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

Contenido significa lo que tiene que escribir en el archivo y su longitud, 'content.length'.

Aquí está la muestra de cómo leer el archivo csv desde local y escribir el archivo csv en local.

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

fs.createWriteStream(path[,options])

optionsTambién puede incluir una startopción para permitir la escritura de datos en alguna posición después del comienzo del archivo. Modificar un archivo en lugar de reemplazarlo puede requerir un flagsmodo en r+lugar del modo predeterminado w. La codificación puede ser cualquiera de las aceptadas por Buffer .

Si autoClosese establece en verdadero (comportamiento predeterminado) 'error'o 'finish'el descriptor de archivo se cerrará automáticamente. Si autoClosees falso, el descriptor de archivo no se cerrará, incluso si hay un error. Es responsabilidad de la aplicación cerrarla y asegurarse de que no haya fugas en el descriptor de archivo.

Como ReadStream , sifd se especifica, WriteStream ignorará el pathargumento y utilizará el descriptor de archivo especificado. Esto significa que no 'open'se emitirá ningún evento. fddebería estar bloqueando; los no bloqueantes se fddeben pasar a net.Socket .

Si optionses una cadena, entonces especifica la codificación.

Después, leyendo este largo artículo. Debes entender cómo funciona. Entonces, aquí hay un ejemplo decreateWriteStream() .

/* The fs.createWriteStream() returns an (WritableStream {aka} internal.Writeable) and we want the encoding as 'utf'-8 */
/* The WriteableStream has the method write() */
fs.createWriteStream('out.txt', 'utf-8')
.write('hello world');

Puedes usar la biblioteca easy-file-manager

instalar primero desde npm npm install easy-file-manager

Muestra para cargar y eliminar archivos

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

Puede escribir en un archivo con el siguiente ejemplo de código:

var data = [{ 'test': '123', 'test2': 'Lorem Ipsem ' }];
fs.open(datapath + '/data/topplayers.json', 'wx', function (error, fileDescriptor) {
  if (!error && fileDescriptor) {
    var stringData = JSON.stringify(data);
    fs.writeFile(fileDescriptor, stringData, function (error) {
      if (!error) {
        fs.close(fileDescriptor, function (error) {
          if (!error) {
            callback(false);
          } else {
            callback('Error in close file');
          }
        });
      } else {
        callback('Error in writing file.');
      }
    });
  }
});