Escritura de archivos en Node.js

Question

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

Answer 1

Hay una gran cantidad de datos en el sistema de archivos API . 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!");
}); 

Answer 2

En la actualidad hay tres formas de escribir un archivo:

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

   Es necesario esperar para la devolución de llamada para asegurarse de que el búfer se escribe en el disco. No es amortiguada.

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

   Todos los datos deben ser almacenados al mismo tiempo; no se puede realizar escrituras secuenciales.

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

   Crea una WriteStream , lo cual es conveniente porque no es necesario esperar a una devolución de llamada. Pero, de nuevo, no es amortiguada.

WriteStream , como su nombre lo dice, es una corriente. Una corriente por definición es “un tampón” que contiene los datos que se mueve en una dirección (fuente ► destino). Pero una corriente grabable no es necesariamente “amortiguada”. Una secuencia es “amortiguada” cuando se escribe n veces, y al n+1 tiempo, la corriente envía el búfer en el núcleo (porque está lleno y necesita ser enrojecida).

En otras palabras: “Un buffer” es el objeto. Si es o no “es amortiguada” es una propiedad de ese objeto.

Si nos fijamos en el código, los hereda WriteStream de un objeto Stream escritura. Si se presta atención, verá cómo echar el contenido; que no tienen ningún sistema de almacenamiento temporal.

Si se escribe una cadena, se convierte en un búfer y, a continuación, enviado a la capa nativa y escrito en el disco. Al escribir las cadenas, no están llenando cualquier tampón. Así que, si lo hace:

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

Lo 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 eres el uso de “buffers”, los datos no se amortigua. Una corriente tamponada haría:. fs.write(new Buffer ("abc")), una llamada a la capa I / O

A partir de ahora, en Node.js v0.12 (versión estable anunció 02/06/2015) ahora soporta dos funciones: cork() uncork() . Parece que estas funciones serán finalmente permitirá Buffer / vaciar las llamadas de escritura.

Por ejemplo, en Java hay algunas clases que proporcionan flujos de búfer (BufferedOutputStream, BufferedWriter ...). Si escribe tres bytes, estos bytes se almacenan en la memoria intermedia (memoria) en lugar de hacer una llamada de E / S sólo 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 estoy descubriendo nada, sólo recordar cómo un acceso al disco se debe hacer.

Answer 3

Por supuesto puede hacer que sea un poco más avanzado. Sin bloqueo, escribiendo partes y piezas, no 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();
});

Answer 4

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

Answer 5

Escribir síncrono

  

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

fs = require('fs');

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

Escribir asíncrono

  

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

Donde

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

Vale la pena leer los archivos del sistema oficial (FS) docs .

Answer 6

Me gustaba Índice de ./articles/file-system .

Se trabajó para mí.

Ver también Cómo hacer yo archivos de escritura 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');
});

El contenido de helloworld.txt:

Hello World!

Actualización:
Al igual que en Linux nodo de escritura en el directorio actual, parece que en algunos otros no, por lo que añado este comentario por si acaso:
El uso de este ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); llegar a donde el archivo se escribe.

Answer 7

Sé que la pregunta era acerca de "escritura", pero en un sentido más general "append" podría ser útil en algunos casos, ya que es fácil de usar en un bucle para añadir texto a un archivo (si existe el archivo o no) . Use 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");
}

Answer 8

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

Por ejemplo: archivos de lectura y escritura a 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");
                            });
                        }
                });

Answer 9

Las respuestas proporcionadas son anticuadas y una nueva manera de hacer esto es:

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

ver documentos aquí para obtener más información

Answer 10

De acuerdo, es bastante simple como nodo tiene una funcionalidad integrada para esto, se llama fs cual significa Sistema y, básicamente, el módulo Archivo NodeJS de archivos del sistema ...

Así requerir por primera vez en su server.js archivo de la siguiente manera:

var fs = require('fs');

fs tiene algunos métodos para hacer escribir en el archivo, pero mi forma preferida está utilizando appendFile, esto añadirá el material para el archivo y si no existe el archivo, se creará uno, el código podría ser como la siguiente:

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

Answer 11

Se puede escribir en un archivo usando módulo fs (sistema de archivos).

Este es un ejemplo de cómo puede 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 puede ser que desee deshacerse de esta estructura de código de llamada de retorno dentro de devolución de llamada-useing Promises declaraciones y async / await. Esto hará que la estructura del código asíncrono mucho más plana. Por haciendo que hay una mano util.promisify (original) función podría ser utilizado. Nos permite cambiar de devoluciones de llamada a las promesas. Echar un vistazo al ejemplo con funciones fs 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);
}

Answer 12

Aquí utilizamos w + para la lectura / escritura de ambas acciones y si la ruta del archivo no se encuentra el que se crearía 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');
            })
        });
    }
});

hace referencia al contenido de lo que tiene que escribir en el fichero y su longitud, 'content.length'.

Answer 13

Esto es el ejemplo de cómo leer el archivo CSV desde un archivo CSV local y escritura a 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()

Answer 14

fs.createWriteStream(path[,options])

options también puede incluir una start opción para permitir la escritura de datos en alguna posición más allá del principio del archivo.La modificación de un archivo en lugar de reemplazarlo, puede requerir una flags modo de r+ en lugar de la predeterminada del modo de w.La codificación puede ser cualquiera de las aceptadas por Búfer.

Si autoClose se establece en true (comportamiento predeterminado) en 'error' o 'finish' el descriptor de archivo se cierra automáticamente.Si autoClose es falso, entonces el descriptor de archivo no se puede cerrar, incluso si hay un error.Es responsabilidad de la aplicación para cerrarla y asegúrese de que no hay ningún archivo descriptor de la fuga.

Como ReadStream, si fd se especifica, WriteStream se ignora la path argumento y utilizar el archivo especificado en el descriptor.Esto significa que no 'open' evento será emitido. fd debe ser el bloqueo;sin bloqueo fds se debe pasar a net.Zócalo.

Si options es una cadena, a continuación, se especifica la codificación.

Después, la lectura de este largo artículo.Usted debe entender cómo funciona.Así que, he aquí un ejemplo de createWriteStream().

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

Answer 15

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

Answer 16

Puede utilizar easy-file-manager biblioteca

instalar por primera vez de la NGP npm install easy-file-manager

Muestra para cargar y archivos Eliminar

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

Answer 17

Trate lo siguiente:

fs.readFile(`${__dirname}/fileName`, 'utf-8',(err, contents) => {
    if (err) throw Error(err){
        console.log(contents)
    }
});