javascript require('fs') - Escribiendo archivos en Node.js




delete create (11)

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?


Sé que la pregunta sobre "escribir", pero en un sentido más general, "añadir" 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). 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");
}

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

Aquí utilizamos 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 tienes que escribir en el archivo y su longitud, 'content.length'.


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

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.


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

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

Por supuesto, puedes hacerlo un poco más avanzado. No bloquear, escribir bits 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();
});

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


Yo uso la siguiente función para probar si el archivo existe. Atrapa también otras excepciones. Entonces, en caso de que haya problemas de derechos, por ejemplo, chmod ugo-rwx filename o en Windows, Right Click -> Properties -> Security -> Advanced -> Permission entries: empty list .. chmod ugo-rwx filename Right Click -> Properties -> Security -> Advanced -> Permission entries: empty list .. función devuelve la excepción como debería. El archivo existe pero no tenemos derechos de acceso. Sería un error ignorar este tipo de excepciones.

function fileExists(path) {

  try  {
    return fs.statSync(path).isFile();
  }
  catch (e) {

    if (e.code == 'ENOENT') { // no such file or directory. File really does not exist
      console.log("File does not exist.");
      return false;
    }

    console.log("Exception fs.statSync (" + path + "): " + e);
    throw e; // something else went wrong, we don't have rights, ...
  }
}

Salida de excepción, documentación de errores de nodejs en caso de que el archivo no exista:

{
  [Error: ENOENT: no such file or directory, stat 'X:\\delsdfsdf.txt']
  errno: -4058,
  code: 'ENOENT',
  syscall: 'stat',
  path: 'X:\\delsdfsdf.txt'
}

Excepción en caso de que no tengamos derechos sobre el archivo, pero existe:

{
  [Error: EPERM: operation not permitted, stat 'X:\file.txt']
  errno: -4048,
  code: 'EPERM',
  syscall: 'stat',
  path: 'X:\\file.txt'
}




javascript node.js file express fs