Ottieni dati da fs.readFile

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

I registri sono undefined , perché?

Per approfondire ciò che @Raynos ha detto, la funzione che hai definito è un callback asincrono. Non viene eseguito immediatamente, ma viene eseguito al termine del caricamento del file. Quando si chiama readFile, il controllo viene restituito immediatamente e viene eseguita la riga di codice successiva. Pertanto, quando si chiama console.log, la richiamata non è stata ancora richiamata e questo contenuto non è stato ancora impostato. Benvenuto nella programmazione asincrona.

Approcci di esempio

 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, meglio ancora, come mostra l’esempio di Raynos, avvolgere la chiamata in una funzione e inoltrare le proprie richiamate. (Apparentemente questa è una pratica migliore) Penso che prendere l’abitudine di avvolgere le tue chiamate asincrone in una funzione che richiede una richiamata ti farà risparmiare un sacco di problemi e di codice disordinato.

 function doSomething (callback) { // any async callback invokes callback with response } doSomething (function doSomethingAfter(err, result) { // process the async result }); 

In realtà esiste una funzione sincrona per questo:

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

asincrono

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

Legge in modo asincrono l’intero contenuto di un file. Esempio:

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

Il callback riceve due argomenti (err, data), in cui i dati sono i contenuti del file.

Se non viene specificata alcuna codifica, viene restituito il buffer raw.


SINCRONO

fs.readFileSync(filename, [encoding])

Versione sincrona di fs.readFile. Restituisce il contenuto del file denominato nomefile.

Se viene specificata la codifica, questa funzione restituisce una stringa. Altrimenti restituisce un buffer.

 var text = fs.readFileSync('test.md','utf8') console.log (text) 
 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) }) 

Utilizzare Promises con ES7

Uso asincrono con mz / fs

Il modulo mz fornisce versioni promesse della libreria del nodo principale. Usarli è semplice. Prima installa la libreria …

 npm install mz 

Poi…

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

In alternativa puoi scriverli in funzioni asincrone:

 async function myReadfile () { try { const file = await fs.readFile('./Index.html'); } catch (err) { console.error( err ) } }; 
 var data = fs.readFileSync('tmp/reltioconfig.json','utf8'); 

usa questo per chiamare un file in modo sincrono, senza codificarne l’output di visualizzazione come buffer.

modo di lettura dei file di sincronizzazione e asincrono:

 //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 Disponibile su read_file .

Come detto, fs.readFile è un’azione asincrona. Significa che quando si dice al nodo di leggere un file, è necessario considerare che ci vorrà del tempo e, nel frattempo, il nodo continua a eseguire il seguente codice. Nel tuo caso è: console.log(content); .

È come mandare parte del tuo codice per un lungo viaggio (come leggere un grande file).

Dai un’occhiata ai commenti che ho scritto:

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

Ecco perché il content è ancora vuoto quando lo si registra. il nodo non ha ancora recuperato il contenuto del file.

Questo potrebbe essere risolto spostando console.log(content) all’interno della funzione di callback, subito dopo content = data; . In questo modo vedrai il log quando il nodo ha finito di leggere il file e dopo che il content ottenuto un valore.

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

puoi leggere il file con

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

Aggiungendo puoi scrivere su file,

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

e anche a catena insieme

 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); } }); }; 
 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!"); }); }); } 
 var content; fs.readFile('./Index.html', function read(err, data) { if (err) { throw err; } content = data; }); console.log(content); 

Ciò è dovuto al fatto che il nodo è asincrono e non attenderà la funzione di lettura e non appena il programma viene avviato, consoliderà il valore come non definito, il che è effettivamente vero perché non è stato assegnato alcun valore alla variabile di contenuto. Per gestire possiamo usare promesse, generatori ecc. Possiamo usare la promise in questo modo.

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

Per dirla in modo approssimativo, hai a che fare con node.js che è di natura asincrona.

Quando parliamo di async, stiamo parlando di elaborare o elaborare informazioni o dati mentre gestiamo qualcos’altro. Non è sinonimo di parallelo, si prega di essere ricordato.

Il tuo codice:

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

Con il vostro campione, fondamentalmente fa la parte console.log prima, quindi la variabile ‘content’ non è definita.

Se vuoi davvero l’output, fai qualcosa come questo:

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

Questo è asincrono. Sarà difficile abituarsi, ma è quello che è. Di nuovo, questa è una spiegazione approssimativa ma veloce di cosa sia Async.