La compréhension function (err, données) rappels

Donc je suis confus au sujet de l'utilisation de la fonction(err, données) rappel des œuvres, est le premier argument toujours un gestionnaire d'erreur?

Que sur les autres arguments si vous aviez quelque chose comme la fonction (x, y, z, a, b, c)?

Comment les données de fs.readFile passer de la première ligne de code à la dernière ligne de code? Ou en d'autres termes, comment la sortie de fs.readFile se mettre dans les données d'argument?

fs.readFile(pathToFile, function (err, **data**) {
    bufferString = **data**.toString();

Je pourrais remplacer function (err, données) en fonction de (x, y) et la fonction (x, y, z, a, b, c)

Mais seulement le deuxième argument de travaux (données et y), est-ce juste la syntaxe de javascript rappels?

Par exemple, c'est du code qui fonctionne de manière asynchrone lire un fichier et imprimer le nombre de lignes données d'un fichier:

var fs = require('fs');
var pathToFile = process.argv[2];
var bufferString, bufferStringSplit;

function counter(callback) {
  fs.readFile(pathToFile, function (err, data) {
    bufferString = data.toString();
    bufferStringSplit = bufferString.split('\n');
    callback();
  });
}

function logMyNumber() {
  console.log(bufferStringSplit.length-1);
}

counter(logMyNumber);
  • La signature de rappel est déterminé par l'appel de la fonction -- readFile dicte un 2 paramètre de rappel. Pas de magie ici.
  • Merci Joe! Je pense que je overanalyzed cela, mais il m'a vraiment aidé à comprendre!
InformationsquelleAutor enducat | 2013-12-18
  1. 4

    L'appelant de la fonction de rappel (qui est le readFile méthode dans ce cas) décide quels sont les arguments sont passés à la fonction de rappel. Vous devez déclarer votre rappel pour correspondre à ce readFile dit qu'il va passer à la fonction de rappel. Vous pouvez nommer les arguments tout ce que vous voulez (les noms que vous utilisez n'a pas d'importance), mais ils vont obtenir les valeurs dans l'ordre que readFile décide.

    Dans ce cas, fs.readFile() appelle la fonction de rappel avec les deux arguments que vous avez dans votre code comme dans callback(err, data).

    Voici un exemple de l'node.js docs:

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

    Facile à comprendre avec un exemple... vous pouvez écrire votre propre version d'une fonction qui utilise une fonction de callback, tout simplement:

    function getTwoStringsAsync(callback) {
    setTimeout(function() {
        callback("foo", "bar");
    }, 1000);
}

    Ici, la fonction getTwoStringsAsync est pré-supposant que le "rappel" est une fonction, et elle implique la signature de deux paramètres sont des chaînes de caractères). La consommation de votre méthode est libre d'adhérer à l'implicite de la signature ou non. Il peut utiliser l'un ou les deux de ces valeurs, ou aucun des deux. Mais si on suppose de plus que les deux paramètres, ceux-ci apparaissent comme indéfini.

    getTwoStringsAsync(function() { console.log("done!"); });
getTwoStringsAsync(function(first, second) { console.log("got " + first + ", " + second); });
getTwoStringsAsync(function(first, second, third) { console.log(third); });   //"undefined"

    C'est sans doute une limitation ou d'une force, ou faiblement typé langages comme Javascript, que les signatures de la fonction ne sera pas vérifiée. Un typage fort la langue peut générer une erreur du compilateur ou de l'avertissement à la première ou à la troisième utilisations mentionnées ci-dessus.

    InformationsquelleAutor McGarnagle
  3. 1

    Les arguments de la fonction de rappel dépendent de la façon dont la fonction de rappel est appelée. Par exemple:

    var map = function(xs, f) {
  var result = [];
  for (var i=0; i<xs.length; i++) {
    //Here we call the callback function
    //with the element as context, the element as first param
    //and the index as second param.
    //Extra parameters are `undefined`
    result.push(f.call(xs[i], xs[i], i));
  }
  return result;
};

    Alors que vous souhaitez utiliser comme:

    var addIdx = function(x,i){ return x+i };
map([1,2,3], addIdx); //=> [1,3,5]
    InformationsquelleAutor elclanrs
  4. 0

    Lorsque vous appelez une fonction peut renvoyer une unique valeur ou de jeter un unique erreur.

    De sorte que le "équivalent" de ce code synchrone:

    try {
    var data = functionCall();
    //Use data
}
catch(err) {
    console.log(err);
}

    Est ce rappel asynchrone:

    functionCallAsync(function(err, data) {
    if (err) {
         console.log(err);
    }
    else {
         //Use data
    }

});

    Vous pouvez maintenant voir pourquoi il n'a pas de sens d'utiliser plusieurs valeurs dans la fonction de rappel. En fait, un tel modèle est activement nuisibles.

    Par exemple lors de l'utilisation de générateurs, vous êtes de retour seulement avoir la possibilité d'utiliser une seule valeur de retour. Mais si certains ignorants de la bibliothèque de l'auteur est allé de l'avant et battu le rappel de la convention et ont utilisé plusieurs, ce serait impossible.

    async(function* () {
    try {
        //What if `functionCallAsync` was called back with multiple values?
        var data = yield functionCallAsync();
        //Use data
    }
    catch(e) {
        console.log(e);
    }
});
    InformationsquelleAutor Esailija