web-dev-qa-db-de.com

Holen Sie sich Daten von fs.readFile

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

Protokolle undefined, warum?

234
karaxuna

Um zu erläutern, was @Raynos gesagt hat, ist die von Ihnen definierte Funktion ein asynchroner Rückruf. Es wird nicht sofort ausgeführt, sondern ausgeführt, wenn das Laden der Datei abgeschlossen ist. Wenn Sie readFile aufrufen, wird die Kontrolle sofort zurückgegeben und die nächste Codezeile ausgeführt. Beim Aufruf von console.log wurde Ihr Rückruf also noch nicht aufgerufen, und dieser Inhalt wurde noch nicht festgelegt. Willkommen bei der asynchronen Programmierung.

Beispielansätze 

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

Oder noch besser, wie das Raynos-Beispiel zeigt, wickeln Sie Ihren Anruf in eine Funktion ein und übergeben Sie Ihre eigenen Rückrufe. (Anscheinend ist dies die bessere Praxis.) Ich glaube, die Gewohnheit, asynchrone Aufrufe in eine Funktion einzuwickeln, die einen Rückruf übernimmt, erspart Ihnen viel Ärger und unordentlichen Code.

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

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

Hierfür gibt es tatsächlich eine Synchronfunktion:

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

Asynchron

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

Liest asynchron den gesamten Inhalt einer Datei. Beispiel:

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

Dem Rückruf werden zwei Argumente (err, data) übergeben, wobei data der Inhalt der Datei ist.

Wenn keine Codierung angegeben ist, wird der Rohpuffer zurückgegeben.


SYNCHRON

fs.readFileSync(filename, [encoding])

Synchrone Version von fs.readFile. Gibt den Inhalt der Datei mit dem Namen Dateiname zurück.

Wenn die Codierung angegeben ist, gibt diese Funktion eine Zeichenfolge zurück. Andernfalls wird ein Puffer zurückgegeben.

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

Versprechen mit ES7 verwenden

Asynchrone Verwendung mit mz/fs

Das mz -Modul stellt versprechende Versionen der Kernknotenbibliothek bereit. Sie zu benutzen ist einfach. Installieren Sie zuerst die Bibliothek ...

npm install mz

Dann...

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

Alternativ können Sie sie in asynchronen Funktionen schreiben:

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

verwenden Sie diese Option, um eine Datei synchron aufzurufen...., ohne die Anzeige als Ausgabe zu codieren.

11
user2266928

synchronisations- und Asynchron-Lesevorgang für Dateien:

//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 Verfügbar unter read_file .

Wie gesagt ist fs.readFile eine asynchrone Aktion. Wenn Sie dem Knoten mitteilen, dass er eine Datei lesen soll, müssen Sie bedenken, dass dies einige Zeit dauern wird. In der Zwischenzeit hat der Knoten den folgenden Code weiter ausgeführt. In Ihrem Fall ist es: console.log(content);.

Es ist wie das Senden eines Teils Ihres Codes für eine lange Reise (wie das Lesen einer großen Datei).

Schau dir die Kommentare an, die ich geschrieben habe:

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

Deshalb ist content noch leer, wenn Sie es protokollieren. Knoten hat den Inhalt der Datei noch nicht abgerufen.

Dies könnte durch Verschieben von console.log(content) in der Rückruffunktion direkt nach content = data; behoben werden. Auf diese Weise sehen Sie das Protokoll, wenn der Knoten mit dem Lesen der Datei fertig ist und nachdem content einen Wert erhalten hat.

7
Taitu-lism
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!");
      });
    });
  }
6
doctorlee
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());
});
4
Masoud Siahkali

Verwenden Sie die integrierte Promisify-Bibliothek (Node 8+), um diese alten Callback-Funktionen eleganter zu gestalten.

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

Diese Linie wird funktionieren,

const content = fs.readFileSync('./Index.html', 'utf8');
console.log(content);
3
Aravin

sie können die Datei durch lesen

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

Beim Hinzufügen können Sie in eine Datei schreiben,

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

und ketten sie sogar zusammen

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);
    }
  });
};
1
J. Doe

Um es grob auszudrücken: Sie haben es mit node.js zu tun, das von Natur aus asynchron ist.

Wenn wir über asynchron sprechen, sprechen wir davon, Informationen oder Daten zu bearbeiten oder zu bearbeiten, während Sie sich mit etwas anderem befassen. Es geht auch nicht um Parallele, bitte sei daran erinnert.

Dein Code: 

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

Bei Ihrem Beispiel wird im Wesentlichen zuerst der Teil console.log ausgeführt, sodass die Variable 'content' nicht definiert ist.

Wenn Sie die Ausgabe wirklich wollen, machen Sie stattdessen Folgendes:

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

Das ist asynchron. Es wird schwer sein, sich daran zu gewöhnen, aber es ist das, was es ist ... Dies ist eine grobe, aber schnelle Erklärung dessen, was asynchron ist.

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

Dies ist nur deshalb der Fall, weil der Knoten asynchron ist und nicht auf die Lesefunktion wartet. Sobald das Programm startet, wird der Wert als undefined konsolidiert Wir können Versprechen, Generatoren usw. verwenden. Wir können Versprechen auf diese Weise verwenden.

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.
})
0
Nouman Dilshad