javascript - read - require('fs')




Escribiendo archivos en Node.js (8)

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 escribe en el disco. No está amortiguado.

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

    Todos los datos deben ser almacenados 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 una vez más, no está amortiguado.

Un WriteStream , como su nombre lo indica, es una secuencia. 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 es necesariamente "buffered". Una secuencia se “almacena en búfer” cuando se escribe n veces, y en el momento n+1 , la secuencia envía el búfer al kernel (porque está lleno y se debe vaciar).

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

Si observa el código, WriteStream hereda de un objeto Stream grabable. Si prestas atención, verás cómo descargan 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 se almacenan en búfer. Un flujo 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 02/06/2015) ahora admite dos funciones: cork() y uncork() . Parece que estas funciones finalmente le permitirán amortiguar / vaciar las llamadas de escritura.

Por ejemplo, en Java hay algunas clases que proporcionan secuencias 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 estoy descubriendo nada, solo recuerdo cómo se debe hacer un acceso al disco.

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


Aquí está la muestra de cómo leer el archivo csv desde el archivo local y escribir el archivo csv en el 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()

Hay muchos detalles en la API del sistema de archivos . La forma más común (que yo sepa) 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!");
}); 

Me gustó el índice de ./articles/file-system .

Funcionó para mí.

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!

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


Puede escribir en un archivo utilizando 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 la llamada utilizando las promesas y async / await sentencias. Esto hará que la estructura de código asíncrono sea mucho más plana. Para hacer eso hay una función util.promisify(original) útil que podría ser utilizada. Nos permite cambiar de devoluciones de llamada a promesas. Eche un vistazo al ejemplo con las funciones fs 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);
}


Puede utilizar la biblioteca de easy-file-manager

instale primero desde npm npm install easy-file-manager

Muestra para subir 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);
});

Escritura sincrónica

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

fs = require('fs');

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

Escritura asincrona

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 los documentos oficiales del sistema de archivos (fs).


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

Por ejemplo: leer 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");
                            });
                        }
                });




fs