javascript - Obtener datos de fs.readFile

node.js

Question

var content;
fs.readFile(''./Index.html'', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
});
console.log(content);

Registros undefined , ¿por qué?

Answer 1

Usando Promesas con ES7

Uso asíncrono con mz / fs

El módulo mz proporciona versiones prometidas de la biblioteca de nodos centrales. Usarlos es simple. Primero instala la biblioteca ...

npm install mz

Entonces...

const fs = require(''mz/fs'');
fs.readFile(''./Index.html'').then(contents => console.log(contents))
  .catch(err => console.error(err));

Alternativamente, puede escribirlos en funciones asíncronas:

async function myReadfile () {
  try {
    const file = await fs.readFile(''./Index.html'');
  }
  catch (err) { console.error( err ) }
};

Answer 2

Como se dijo, fs.readFile es una acción asíncrona. Significa que cuando le dices al nodo que lea un archivo, debes considerar que tomará algún tiempo y, mientras tanto, el nodo continuó ejecutando el siguiente código. En su caso es: console.log(content); .

Es como enviar alguna parte de su código para un viaje largo (como leer un archivo grande).

Echa un vistazo a los comentarios que he escrito:

var content;

// node, go fetch this file. when you come back, please run this "read" callback function
fs.readFile(''./Index.html'', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
});

// in the meantime, please continue and run this console.log
console.log(content);

Es por eso que el content todavía está vacío cuando se registra. El nodo aún no ha recuperado el contenido del archivo.

Esto podría resolverse moviendo console.log(content) dentro de la función de devolución de llamada, justo después de content = data; . De esta manera, verá el registro cuando el nodo haya terminado de leer el archivo y después de que el content obtenga un valor.

Answer 3

En realidad, hay una función síncrona para esto:

http://nodejs.org/api/fs.html#fs_fs_readfilesync_filename_encoding

Asincrónico

fs.readFile(filename, [encoding], [callback])

Lee de forma asíncrona todo el contenido de un archivo. Ejemplo:

fs.readFile(''/etc/passwd'', function (err, data) {
  if (err) throw err;
  console.log(data);
});

La devolución de llamada se pasa a dos argumentos (err, datos), donde los datos son los contenidos del archivo.

Si no se especifica ninguna codificación, se devuelve el búfer sin formato.

SINCRÓNICO

fs.readFileSync(filename, [encoding])

Versión síncrona de fs.readFile. Devuelve el contenido del archivo llamado nombre de archivo.

Si se especifica la codificación, esta función devuelve una cadena. De lo contrario, devuelve un búfer.

var text = fs.readFileSync(''test.md'',''utf8'')
console.log (text)

Answer 4

Para decirlo de forma aproximada, se trata de node.js, que es de naturaleza asíncrona.

Cuando hablamos de async, hablamos de hacer o procesar información o datos mientras tratamos con otra cosa. No es paralelo, por favor, recuerde.

Tu codigo:

var content;
fs.readFile(''./Index.html'', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
});
console.log(content);

Con su muestra, básicamente hace la parte de console.log primero, por lo que la variable ''contenido'' no está definida.

Si realmente quieres la salida, haz algo como esto en su lugar:

var content;
fs.readFile(''./Index.html'', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
    console.log(content);
});

Esto es asíncrono. Será difícil acostumbrarse, pero es lo que es. De nuevo, esta es una explicación aproximada pero rápida de lo que es asíncrono.

Answer 5

Para detallar lo que dijo @Raynos, la función que ha definido es una devolución de llamada asíncrona. No se ejecuta de inmediato, sino que se ejecuta cuando la carga del archivo se ha completado. Cuando llama a readFile, el control se devuelve de inmediato y se ejecuta la siguiente línea de código. Por lo tanto, cuando llama a console.log, su devolución de llamada aún no se ha invocado y este contenido aún no se ha establecido. Bienvenidos a la programación asíncrona.

Ejemplo de enfoques

const fs = require(''fs'');
var content;
// First I want to read the file
fs.readFile(''./Index.html'', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;

    // Invoke the next step here however you like
    console.log(content);   // Put all of the code here (not the best solution)
    processFile();          // Or put the next step in a function and invoke it
});

function processFile() {
    console.log(content);
}

O mejor aún, como muestra el ejemplo de Raynos, envuelva su llamada en una función y pase sus propias devoluciones de llamada. (Aparentemente esta es una mejor práctica) Creo que adquirir el hábito de envolver sus llamadas asíncronas en una función que requiere una devolución de llamada le ahorrará muchos problemas y desordenará el código.

function doSomething (callback) {
    // any async callback invokes callback with response
}

doSomething (function doSomethingAfter(err, result) {
    // process the async result
});

Answer 6

Utilice la biblioteca promisify incorporada para hacer que estas antiguas funciones de devolución de llamadas sean más elegantes.

const fs = require(''fs'');
const util = require(''util'');

const readFile = util.promisify(fs.readFile);

async function doStuff() {
  try {
    const content = await readFile(filePath, ''utf8'');
    console.log(content);
  } catch (e) {
    console.error(e);
  }
}

Answer 7

modo de lectura de archivos de sincronización y asíncrono:

//fs module to read file in sync and async way

var fs = require(''fs''),
    filePath = ''./sample_files/sample_css.css'';

// this for async way
/*fs.readFile(filePath, ''utf8'', function (err, data) {
    if (err) throw err;
    console.log(data);
});*/

//this is sync way
var css = fs.readFileSync(filePath, ''utf8'');
console.log(css);

Node Cheat Disponible en read_file .

Answer 8

puedes leer el archivo por

var readMyFile = function(path, cb) {
      fs.readFile(path, ''utf8'', function(err, content) {
        if (err) return cb(err, null);
        cb(null, content);
      });
    };

Agregando puedes escribir en el archivo,

var createMyFile = (path, data, cb) => {
  fs.writeFile(path, data, function(err) {
    if (err) return console.error(err);
    cb();
  });
};

e incluso encadenarlos juntos

var readFileAndConvertToSentence = function(path, callback) {
  readMyFile(path, function(err, content) {
    if (err) {
      callback(err, null);
    } else {
      var sentence = content.split(''/n'').join('' '');
      callback(null, sentence);
    }
  });
};

Answer 9

const fs = require(''fs'')
function readDemo1(file1) {
    return new Promise(function (resolve, reject) {
        fs.readFile(file1, ''utf8'', function (err, dataDemo1) {
            if (err)
                reject(err);
            else
                resolve(dataDemo1);
        });
    });
}
async function copyFile() {

    try {
        let dataDemo1 = await readDemo1(''url'')
        dataDemo1 += ''/n'' +  await readDemo1(''url'')

        await writeDemo2(dataDemo1)
        console.log(dataDemo1)
    } catch (error) {
        console.error(error);
    }
}
copyFile();

function writeDemo2(dataDemo1) {
    return new Promise(function(resolve, reject) {
      fs.writeFile(''text.txt'', dataDemo1, ''utf8'', function(err) {
        if (err)
          reject(err);
        else
          resolve("Promise Success!");
      });
    });
  }

Answer 10

function readContent(callback) {
    fs.readFile("./Index.html", function (err, content) {
        if (err) return callback(err)
        callback(null, content)
    })
}

readContent(function (err, content) {
    console.log(content)
})

Answer 11

var content;
fs.readFile(''./Index.html'', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
});
console.log(content);

Esto se debe a que el nodo es asíncrono y no esperará la función de lectura y, tan pronto como el programa se inicie, consolará el valor como no definido, lo que en realidad es cierto porque no hay un valor asignado a la variable de contenido. Para manejar podemos usar promesas, generadores, etc. Podemos usar promesas de esta manera.

new Promise((resolve,reject)=>{
    fs.readFile(''./index.html'',''utf-8'',(err, data)=>{
        if (err) {
            reject(err); // in the case of error, control flow goes to the catch block with the error occured.
        }
        else{
            resolve(data);  // in the case of success, control flow goes to the then block with the content of the file.
        }
    });
})
.then((data)=>{
    console.log(data); // use your content of the file here (in this then).    
})
.catch((err)=>{
    throw err; //  handle error here.
})

Answer 12

var data = fs.readFileSync(''tmp/reltioconfig.json'',''utf8'');

Utilícelo para llamar a un archivo de forma síncrona, sin codificar su salida como un búfer.

Answer 13

var fs = require(''fs'');
var path = (process.cwd()+"//text.txt");

fs.readFile(path , function(err,data)
{
    if(err)
        console.log(err)
    else
        console.log(data.toString());
});