Exemple simple de rappels de nodeJs
quelqu'un peut-il me donner un exemple simple des rappels de nodeJs, j'ai déjà recherché la même chose sur de nombreux sites Web mais je ne suis pas capable de le comprendre correctement, donnez-moi un exemple simple.
getDbFiles(store, function(files){
getCdnFiles(store, function(files){
})
})
Je veux faire quelque chose comme ça...
var myCallback = function(data) {
console.log('got data: '+data);
};
var usingItNow = function(callback) {
callback('get it?');
};
Ouvrez maintenant la console de nœud ou de navigateur et collez les définitions ci-dessus.
Enfin utilisez-le avec cette ligne suivante:
usingItNow(myCallback);
en ce qui concerne les conventions d'erreur de style de nœud
Costa a demandé à quoi cela ressemblerait si nous respections les conventions de rappel d'erreur de noeud.
Dans cette convention, le rappel devrait s'attendre à recevoir au moins un argument, le premier, sous forme d'erreur. Nous aurons éventuellement un ou plusieurs arguments supplémentaires, en fonction du contexte. Dans ce cas, le contexte est notre exemple ci-dessus.
Ici, je réécris notre exemple dans cette convention.
var myCallback = function(err, data) {
if (err) throw err; // Check for the error and throw if it exists.
console.log('got data: '+data); // Otherwise proceed as usual.
};
var usingItNow = function(callback) {
callback(null, 'get it?'); // I dont want to throw an error, so I pass null for the error argument
};
Si nous voulons simuler un cas d'erreur, nous pouvons définir usingItNow comme ceci
var usingItNow = function(callback) {
var myError = new Error('My custom error!');
callback(myError, 'get it?'); // I send my error as the first argument.
};
L'utilisation finale est exactement la même que ci-dessus:
usingItNow(myCallback);
La seule différence de comportement dépend de la version de usingItNow que vous avez définie: celle qui alimente une "valeur de vérité" (un objet Error) dans le rappel du premier argument ou celle qui l'alimente. NULL pour l'argument d'erreur.
Une fonction de rappel est simplement une fonction que vous passez à une autre afin que cette fonction puisse l'appeler ultérieurement. Cela se voit couramment en asynchrone API s; l'appel d'API est renvoyé immédiatement car il est asynchrone. Vous lui transmettez donc une fonction que l'API peut appeler lorsqu'elle a terminé l'exécution de sa tâche asynchrone.
L'exemple le plus simple auquel je puisse penser en JavaScript est la fonction setTimeout(). C'est une fonction globale qui accepte deux arguments. Le premier argument est la fonction de rappel et le second argument est un délai en millisecondes. La fonction est conçue pour attendre la durée appropriée, puis appeler votre fonction de rappel.
setTimeout(function () {
console.log("10 seconds later...");
}, 10000);
Vous avez peut-être déjà vu le code ci-dessus, mais vous n'avez pas réalisé que la fonction que vous transmettiez était appelée fonction de rappel. Nous pourrions réécrire le code ci-dessus pour le rendre plus évident.
var callback = function () {
console.log("10 seconds later...");
};
setTimeout(callback, 10000);
Les rappels sont utilisés partout dans Node parce que Node est construit à partir de la base pour être asynchrone dans tout ce qu'il fait. Même en parlant au système de fichiers. C'est pourquoi une tonne d'API internes Node acceptent les fonctions de rappel comme arguments plutôt que de renvoyer des données que vous pouvez affecter à une variable. Au lieu de cela, il invoquera votre fonction de rappel en transmettant les données que vous vouliez sous forme d'argument. Par exemple, vous pouvez utiliser la bibliothèque fs du nœud pour lire un fichier. Le module fs expose deux fonctions API uniques: readFile et readFileSync.
La fonction readFile est asynchrone alors que readFileSync ne l’est évidemment pas. Vous pouvez voir qu'ils ont l'intention d'utiliser les appels asynchrones autant que possible, puisqu'ils les ont appelés readFile et readFileSync au lieu de readFile et readFileAsync. Voici un exemple d'utilisation des deux fonctions.
Synchrone:
var data = fs.readFileSync('test.txt');
console.log(data);
Le code ci-dessus bloque l'exécution du thread jusqu'à ce que tout le contenu de test.txt soit lu en mémoire et stocké dans la variable data. En nœud, cela est généralement considéré comme une mauvaise pratique. Parfois, cependant, lorsque cela est utile, par exemple lorsque vous écrivez un petit script rapide pour faire quelque chose de simple mais fastidieux et que vous ne vous souciez pas de gagner du temps, chaque nanoseconde.
Asynchrone (avec rappel):
var callback = function (err, data) {
if (err) return console.error(err);
console.log(data);
};
fs.readFile('test.txt', callback);
Premièrement, nous créons une fonction de rappel qui accepte deux arguments err et data. Un problème avec les fonctions asynchrones est qu’il devient plus difficile de capturer les erreurs. Par conséquent, de nombreuses API de style callback transmettent les erreurs comme premier argument de la fonction de rappel. Il est recommandé de vérifier si err a une valeur avant de faire autre chose. Si tel est le cas, arrêtez l'exécution du rappel et enregistrez l'erreur.
Les appels synchrones ont un avantage lorsqu'il y a des exceptions levées, car vous pouvez simplement les attraper avec un bloc try/catch.
try {
var data = fs.readFileSync('test.txt');
console.log(data);
} catch (err) {
console.error(err);
}
Dans les fonctions asynchrones, cela ne fonctionne pas ainsi. L'appel d'API retourne immédiatement et il n'y a rien à intercepter avec le try/catch. Les API asynchrones appropriées qui utilisent des rappels capturent toujours leurs propres erreurs, puis les transmettent au rappel où vous pouvez les gérer comme bon vous semble.
En plus des rappels, il existe un autre style d'API populaire, couramment utilisé, appelé promesse. Si vous souhaitez en savoir plus à ce sujet, vous pouvez lire l'intégralité de l'article que j'ai écrit sur le blog et basé sur cette réponse ici .
Voici un exemple de copie de fichier texte avec fs.readFile et fs.writeFile:
var fs = require('fs');
var copyFile = function(source, destination, next) {
// we should read source file first
fs.readFile(source, function(err, data) {
if (err) return next(err); // error occurred
// now we can write data to destination file
fs.writeFile(destination, data, next);
});
};
Et voici un exemple d'utilisation de la fonction copyFile:
copyFile('foo.txt', 'bar.txt', function(err) {
if (err) {
// either fs.readFile or fs.writeFile returned an error
console.log(err.stack || err);
} else {
console.log('Success!');
}
});
Le modèle node.js commun suggère que le premier argument de la fonction de rappel est une erreur. Vous devez utiliser ce modèle car tous les modules de flux de contrôle y ont recours:
next(new Error('I cannot do it!')); // error
next(null, results); // no error occurred, return result
Essayez cet exemple aussi simple que vous pouvez le lire, copiez simplement save newfile.js do node newfile pour exécuter l'application.
function myNew(next){
console.log("Im the one who initates callback");
next("nope", "success");
}
myNew(function(err, res){
console.log("I got back from callback",err, res);
});
nous créons une fonction simple comme
callBackFunction (data, function ( err, response ){
console.log(response)
})
// callbackfunction
function callBackFuntion (data, callback){
//write your logic and return your result as
callback("",result) //if not error
callback(error, "") //if error
}
const fs = require('fs');
fs.stat('input.txt', function (err, stats) {
if(err){
console.log(err);
} else {
console.log(stats);
console.log('Completed Reading File');
}
});
'fs' est un module de noeud qui vous aide à lire le fichier. La fonction de rappel veillera à ce que votre fichier nommé 'input.txt' soit complètement lu avant d'être exécuté. La fonction fs.stat () permet d’obtenir des informations sur le fichier telles que la taille du fichier, la date de création et la date de modification.
Une callback est une fonction passée en paramètre à un Higher Order Function ( wikipedia ). Une implémentation simple d'un rappel serait:
const func = callback => callback('Hello World!');
Pour appeler la fonction, il suffit de passer une autre fonction en tant qu'argument à la fonction définie.
func(string => console.log(string));