Logs undefined, waarom?
Antwoord 1, autoriteit 100%
Om uit te leggen wat @Raynos zei: de functie die je hebt gedefinieerd is een asynchrone callback. Het wordt niet meteen uitgevoerd, maar wordt uitgevoerd wanneer het laden van het bestand is voltooid. Wanneer u readFile aanroept, wordt de controle onmiddellijk geretourneerd en wordt de volgende regel code uitgevoerd. Dus als je console.log aanroept, is je callback nog niet aangeroepen en is deze inhoud nog niet ingesteld. Welkom bij asynchrone programmering.
Voorbeelden van benaderingen
const fs = require('fs');
// First I want to read the file
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
const content = data;
// Invoke the next step here however you like
console.log(content); // Put all of the code here (not the best solution)
processFile(content); // Or put the next step in a function and invoke it
});
function processFile(content) {
console.log(content);
}
Of beter nog, zoals Raynos voorbeeld laat zien, stop je oproep in een functie en geef je eigen callbacks door. (Blijkbaar is dit een betere gewoonte) Ik denk dat het je veel moeite en rommelige code zal besparen als je er een gewoonte van maakt om je asynchrone oproepen in een functie in te pakken die een callback nodig heeft.
function doSomething (callback) {
// any async callback invokes callback with response
}
doSomething (function doSomethingAfter(err, result) {
// process the async result
});
Antwoord 2, autoriteit 76%
Hier is eigenlijk een synchrone functie voor:
http://nodejs.org/api/fs.html#fs_fs_readfilesync_filename_encoding
Asynchroon
fs.readFile(filename, [encoding], [callback])
Leest asynchroon de volledige inhoud van een bestand. Voorbeeld:
fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
console.log(data);
});
De callback krijgt twee argumenten (err, data), waarbij data de inhoud van het bestand is.
Als er geen codering is opgegeven, wordt de onbewerkte buffer geretourneerd.
SYNCHROON
fs.readFileSync(filename, [encoding])
Synchrone versie van fs.readFile. Retourneert de inhoud van het bestand met de naam bestandsnaam.
Als codering is opgegeven, retourneert deze functie een tekenreeks. Anders retourneert het een buffer.
var text = fs.readFileSync('test.md','utf8')
console.log (text)
Antwoord 3, autoriteit 33%
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)
})
Antwoord 4, autoriteit 19%
Beloften gebruiken met ES7
Asynchroon gebruik met mz/fs
De mz-module biedt beloofde versies van de kernknooppuntbibliotheek . Het gebruik ervan is eenvoudig. Installeer eerst de bibliotheek…
npm install mz
Dan…
const fs = require('mz/fs');
fs.readFile('./Index.html').then(contents => console.log(contents))
.catch(err => console.error(err));
U kunt ze ook in asynchrone functies schrijven:
async function myReadfile () {
try {
const file = await fs.readFile('./Index.html');
}
catch (err) { console.error( err ) }
};
Antwoord 5, autoriteit 6%
var data = fs.readFileSync('tmp/reltioconfig.json','utf8');
gebruik dit om een bestand synchroon aan te roepen,
zonder te coderen toont de output als een buffer.
Antwoord 6, autoriteit 5%
Deze regel werkt,
const content = fs.readFileSync('./Index.html', 'utf8');
console.log(content);
Antwoord 7, autoriteit 3%
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!");
});
});
}
Antwoord 8, autoriteit 2%
Gebruik de ingebouwde Promisify-bibliotheek (Node 8+) om deze oude callback-functies eleganter te maken.
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);
}
}
Antwoord 9, autoriteit 2%
sync en asynchrone manier om bestanden te lezen:
//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 beschikbaar op read_file.
Antwoord 10, autoriteit 2%
Zoals gezegd, fs.readFileis een asynchrone actie. Het betekent dat wanneer je node vertelt een bestand te lezen, je er rekening mee moet houden dat het enige tijd zal duren, en in de tussentijd bleef node de volgende code uitvoeren. In jouw geval is dat: console.log(content);.
Het is alsof je een deel van je code verzendt voor een lange reis (zoals het lezen van een groot bestand).
Bekijk de opmerkingen die ik heb geschreven:
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);
Daarom is contentnog steeds leeg als je het logt. node heeft de inhoud van het bestand nog niet opgehaald.
Dit kan worden opgelost door console.log(content)binnen de callback-functie te verplaatsen, direct na content = data;. Op deze manier ziet u het logboek wanneer de node klaar is met het lezen van het bestand en nadat contenteen waarde heeft gekregen.
Antwoord 11
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());
});
Antwoord 12
De volgende functie zou werken voor asyncwrap of beloven thenketens
const readFileAsync = async (path) => fs.readFileSync(path, 'utf8');
Antwoord 13
var content;
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
content = data;
});
console.log(content);
Dit is gewoon omdat het knooppunt asynchroon is en niet wacht op de leesfunctie en zodra het programma start, zal het de waarde als undefined troosten, wat eigenlijk waar is omdat er geen waarde is toegewezen aan de inhoudsvariabele.
Om te gaan, kunnen we beloften, generatoren etc. gebruiken
We kunnen op deze manier beloven gebruiken.
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.
})
Antwoord 14
U kunt het bestand lezen door
var readMyFile = function(path, cb) {
fs.readFile(path, 'utf8', function(err, content) {
if (err) return cb(err, null);
cb(null, content);
});
};
Toevoegen aan u kunt schrijven naar het bestand,
var createMyFile = (path, data, cb) => {
fs.writeFile(path, data, function(err) {
if (err) return console.error(err);
cb();
});
};
en zelfs ketting samen
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);
}
});
};
Antwoord 15
Om het ongeveer te doen, heb je te maken met Node.js die asynchroon in de natuur is.
Als we het hebben over asynchrone, hebben we het over het doen of verwerken van informatie of gegevens terwijl we met iets anders te maken hebben. Het is niet synoniem aan parallel, houd er rekening mee.
Uw code:
var content;
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
content = data;
});
console.log(content);
Bij uw voorbeeld doet het in principe eerst het console.log-gedeelte, dus de variabele ‘content’ is niet gedefinieerd.
Als je de uitvoer echt wilt, doe dan iets als dit:
var content;
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
content = data;
console.log(content);
});
Dit is asynchroon. Het zal even wennen zijn, maar het is wat het is.
Nogmaals, dit is een ruwe maar snelle uitleg van wat async is.
Antwoord 16
var path = "index.html"
const readFileAsync = fs.readFileSync(path, 'utf8');
// console.log(readFileAsync)
het gebruik van eenvoudige readFileSyncwerkt voor mij.
Antwoord 17
Ik gebruik graag fs-extraomdat alle functies zijn beloofd, direct uit het vak, zodat u awaitkunt gebruiken. Uw code kan er dus als volgt uitzien:
(async () => {
try {
const content = await fs.readFile('./Index.html');
console.log(content);
} catch (err) {
console.error(err);
}
})();