var content;
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
content = data;
});
console.log(content);
Journaux undefined
, pourquoi?
Pour préciser ce que @Raynos a dit, la fonction que vous avez définie est un rappel asynchrone. Il ne s'exécute pas tout de suite, il s'exécute lorsque le chargement du fichier est terminé. Lorsque vous appelez readFile, le contrôle est renvoyé immédiatement et la ligne de code suivante est exécutée. Ainsi, lorsque vous appelez console.log, votre rappel n'a pas encore été appelé et ce contenu n'a pas encore été défini. Bienvenue dans la programmation asynchrone.
Exemples d'approches
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);
}
Ou mieux encore, comme le montre l'exemple de Raynos, encapsulez votre appel dans une fonction et transmettez vos propres rappels. (Apparemment, c'est une meilleure pratique) Je pense que prendre l'habitude de mettre vos appels asynchrones dans une fonction qui prend un rappel vous évitera beaucoup d'ennuis et du code compliqué.
function doSomething (callback) {
// any async callback invokes callback with response
}
doSomething (function doSomethingAfter(err, result) {
// process the async result
});
Il existe actuellement une fonction synchrone pour cela:
http://nodejs.org/api/fs.html#fs_fs_readfilesync_filename_encoding
fs.readFile(filename, [encoding], [callback])
Lit de manière asynchrone l'intégralité du contenu d'un fichier. Exemple:
fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
console.log(data);
});
Le callback reçoit deux arguments (err, data), où data correspond au contenu du fichier.
Si aucun codage n'est spécifié, le tampon brut est renvoyé.
fs.readFileSync(filename, [encoding])
Version synchrone de fs.readFile. Renvoie le contenu du fichier nommé nomfichier.
Si le codage est spécifié, cette fonction renvoie une chaîne. Sinon, il retourne un tampon.
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)
})
Le module mz
fournit des versions promisifiées de la bibliothèque de noeuds principaux. Les utiliser est simple. Installez d'abord la bibliothèque ...
npm install mz
Ensuite...
const fs = require('mz/fs');
fs.readFile('./Index.html').then(contents => console.log(contents))
.catch(err => console.error(err));
Sinon, vous pouvez les écrire dans des fonctions asynchrones:
async function myReadfile () {
try {
const file = await fs.readFile('./Index.html');
}
catch (err) { console.error( err ) }
};
var data = fs.readFileSync('tmp/reltioconfig.json','utf8');
utilisez ceci pour appeler un fichier de manière synchrone, sans coder sa sortie affichée sous forme de tampon.
manière de lire le fichier sync et async:
//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 à read_file .
Comme dit, fs.readFile
est une action asynchrone. Cela signifie que lorsque vous indiquez à noeud de lire un fichier, vous devez être conscient du temps nécessaire, et entre-temps, noeud continue à exécuter le code suivant. Dans votre cas, c'est: console.log(content);
.
C'est comme envoyer une partie de votre code pour un long voyage (comme lire un gros fichier).
Regardez les commentaires que j'ai écrits:
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);
C'est pourquoi content
est toujours vide lorsque vous vous enregistrez. Le noeud n'a pas encore récupéré le contenu du fichier.
Cela pourrait être résolu en déplaçant console.log(content)
dans la fonction de rappel, juste après le content = data;
. De cette façon, vous verrez le journal lorsque le noeud aura fini de lire le fichier et obtiendra une valeur après content
.
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 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());
});
Utilisez la bibliothèque Promisify intégrée (Node 8+) pour rendre ces anciennes fonctions de rappel plus élégantes.
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);
}
}
Cette ligne fonctionnera,
const content = fs.readFileSync('./Index.html', 'utf8');
console.log(content);
vous pouvez lire le fichier par
var readMyFile = function(path, cb) {
fs.readFile(path, 'utf8', function(err, content) {
if (err) return cb(err, null);
cb(null, content);
});
};
Ajout sur vous pouvez écrire dans le fichier,
var createMyFile = (path, data, cb) => {
fs.writeFile(path, data, function(err) {
if (err) return console.error(err);
cb();
});
};
et même enchaîner
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);
}
});
};
En gros, vous avez affaire à node.js, qui est de nature asynchrone.
Lorsque nous parlons d'async, nous parlons de traiter ou de traiter des informations ou des données tout en traitant avec autre chose. Ce n'est pas synonyme de parallèle, s'il vous plaît rappelez-vous.
Votre code:
var content;
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
content = data;
});
console.log(content);
Avec votre exemple, il commence par la partie console.log, donc la variable 'contenu' étant indéfinie.
Si vous voulez vraiment la sortie, faites plutôt quelque chose comme ceci:
var content;
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
content = data;
console.log(content);
});
C'est asynchrone. Il sera difficile de s’habituer à, mais c’est ce que c’est… .. Encore une fois, c’est une explication grossière mais rapide de ce qu’est async.
var content;
fs.readFile('./Index.html', function read(err, data) {
if (err) {
throw err;
}
content = data;
});
console.log(content);
Ceci est juste parce que le noeud est asynchrone et qu'il n'attendra pas la fonction de lecture et dès que le programme démarrera, il console la valeur comme indéfinie, ce qui est vrai car aucune variable n'est assignée à la variable de contenu . nous pouvons utiliser des promesses, des générateurs, etc. Nous pouvons utiliser la promesse de cette manière.
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.
})