Comment est une promesse/reporter bibliothèque mises en œuvre?

Je le trouve plus difficile à expliquer que pour montrer un exemple, voici donc une très simple de mise en œuvre de ce qu'un reporter/promesse pourrait être.

Avertissement: Ce n'est pas une fonctionnelle de la mise en œuvre et de certaines parties de la Promesse/Un cahier des charges sont manquants, C'est juste pour expliquer la base de promesses.

tl;dr: Aller à la Créer des classes et des exemple section pour voir la pleine mise en œuvre.

Promesse:

Nous devons d'abord créer un objet promise à un tableau de rappels. Je vais commencer à travailler avec des objets parce que c'est plus clair:

var promise = {
  callbacks: []
}

maintenant ajouter des rappels avec la méthode alors:

var promise = {
  callbacks: [],
  then: function (callback) {
    callbacks.push(callback);
  }
}

Et nous avons besoin de l'erreur rappels trop:

var promise = {
  okCallbacks: [],
  koCallbacks: [],
  then: function (okCallback, koCallback) {
    okCallbacks.push(okCallback);
    if (koCallback) {
      koCallbacks.push(koCallback);
    }
  }
}

Reporter:

Maintenant créer le reporter de l'objet qui aura une promesse:

var defer = {
  promise: promise
};

Le reporter doit être résolu:

var defer = {
  promise: promise,
  resolve: function (data) {
    this.promise.okCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(data)
      }, 0);
    });
  },
};

Et les besoins de rejeter:

var defer = {
  promise: promise,
  resolve: function (data) {
    this.promise.okCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(data)
      }, 0);
    });
  },

  reject: function (error) {
    this.promise.koCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(error)
      }, 0);
    });
  }
};

Noter que les rappels sont appelés dans un délai d'expiration pour permettre que le code sera toujours asynchrone.

Et qu'est ce qu'une base de reporter/promesse de la mise en œuvre des besoins.

Créer des classes et des exemple:

Maintenant permet de convertir à la fois des objets de classes, d'abord la promesse:

var Promise = function () {
  this.okCallbacks = [];
  this.koCallbacks = [];
};

Promise.prototype = {
  okCallbacks: null,
  koCallbacks: null,
  then: function (okCallback, koCallback) {
    okCallbacks.push(okCallback);
    if (koCallback) {
      koCallbacks.push(koCallback);
    }
  }
};

Et maintenant, le reporter:

var Defer = function () {
  this.promise = new Promise();
};

Defer.prototype = {
  promise: null,
  resolve: function (data) {
    this.promise.okCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(data)
      }, 0);
    });
  },

  reject: function (error) {
    this.promise.koCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(error)
      }, 0);
    });
  }
};

Et voici un exemple d'utilisation:

function test() {
  var defer = new Defer();
  //an example of an async call
  serverCall(function (request) {
    if (request.status === 200) {
      defer.resolve(request.responseText);
    } else {
      defer.reject(new Error("Status code was " + request.status));
    }
  });
  return defer.promise;
}

test().then(function (text) {
  alert(text);
}, function (error) {
  alert(error.message);
});

Comme vous pouvez le voir les pièces de base sont simples et petites. Il grandira quand vous ajoutez d'autres options, par exemple les multiples promesses de résolution:

Defer.all(promiseA, promiseB, promiseC).then()

ou de la promesse de chaînage:

getUserById(id).then(getFilesByUser).then(deleteFile).then(promptResult);

Pour en savoir plus sur le cahier des charges: CommonJS Promesse De Spécification. Notez que les principales bibliothèques (Q, when.js, rsvp.js, nœud-promesse, ...) suivre Promesses/A spécification.

Espère que j'ai été assez clair.

Edit:

Comme demandé dans les commentaires, j'ai ajouté deux choses dans cette version:

• La possibilité de faire appel alors d'une promesse, quel que soit le statut qu'il a.
• La possibilité de la chaîne de promesses.

Pour être en mesure d'appeler la promesse lorsque résolu, vous devez ajouter le statut de la promesse, et lorsque le puis est appelé à vérifier le statut. Si le statut est résolu ou rejeté exécutez simplement le rappel de ses données ou erreur.

Pour être en mesure à la chaîne des promesses, vous devez générer un nouveau différer pour chaque appel à then et, lorsque la promesse est résolu/a rejeté, de résoudre ou de rejeter la nouvelle promesse avec le résultat de la fonction de rappel. Ainsi, lorsque la promesse est faite, si le callback retourne une nouvelle promesse, il est lié à la promesse retourné avec la then(). Si non, la promesse est résolu avec le résultat de la fonction de rappel.

Ici, c'est la promesse:

var Promise = function () {
  this.okCallbacks = [];
  this.koCallbacks = [];
};

Promise.prototype = {
  okCallbacks: null,
  koCallbacks: null,
  status: 'pending',
  error: null,

  then: function (okCallback, koCallback) {
    var defer = new Defer();

    //Add callbacks to the arrays with the defer binded to these callbacks
    this.okCallbacks.push({
      func: okCallback,
      defer: defer
    });

    if (koCallback) {
      this.koCallbacks.push({
        func: koCallback,
        defer: defer
      });
    }

    //Check if the promise is not pending. If not call the callback
    if (this.status === 'resolved') {
      this.executeCallback({
        func: okCallback,
        defer: defer
      }, this.data)
    } else if(this.status === 'rejected') {
      this.executeCallback({
        func: koCallback,
        defer: defer
      }, this.error)
    }

    return defer.promise;
  },

  executeCallback: function (callbackData, result) {
    window.setTimeout(function () {
      var res = callbackData.func(result);
      if (res instanceof Promise) {
        callbackData.defer.bind(res);
      } else {
        callbackData.defer.resolve(res);
      }
    }, 0);
  }
};

Et le reporter:

var Defer = function () {
  this.promise = new Promise();
};

Defer.prototype = {
  promise: null,
  resolve: function (data) {
    var promise = this.promise;
    promise.data = data;
    promise.status = 'resolved';
    promise.okCallbacks.forEach(function(callbackData) {
      promise.executeCallback(callbackData, data);
    });
  },

  reject: function (error) {
    var promise = this.promise;
    promise.error = error;
    promise.status = 'rejected';
    promise.koCallbacks.forEach(function(callbackData) {
      promise.executeCallback(callbackData, error);
    });
  },

  //Make this promise behave like another promise:
  //When the other promise is resolved/rejected this is also resolved/rejected
  //with the same data
  bind: function (promise) {
    var that = this;
    promise.then(function (res) {
      that.resolve(res);
    }, function (err) {
      that.reject(err);
    })
  }
};

Comme vous pouvez le voir, il a grandi un peu.

Que Forbes mentionne dans sa réponse, j'ai fait la chronique de nombreuses décisions de conception impliqués dans la réalisation d'une bibliothèque comme Q, ici https://github.com/kriskowal/q/tree/v1/design. Qu'il suffise de dire, il y a des niveaux d'une promesse de la bibliothèque, et beaucoup de bibliothèques qui s'arrêtent à différents niveaux.

Au premier niveau, capturé par les Promesses/A+ spécification, une promesse est un proxy pour un résultat final et est adapté pour la gestion de “local asynchronie”. C'est, il convient de s'assurer que le travail se produit dans le bon ordre, et de s'assurer qu'il est simple et directe pour écouter le résultat d'une opération, indépendamment de savoir si elle est déjà réglée, ou va se produire dans l'avenir. Il rend également qu'il est tout aussi simple pour une ou plusieurs parties à s'abonner à un résultat final.

Q, comme je l'ai mis en œuvre, fournit des promesses que les procurations éventuelles, à distance, ou de l'éventuelle+à distance des résultats. À cette fin, il est de conception est inversé, avec différentes implémentations pour des promesses différée, des promesses, des promesses tenues, rejeté des promesses et des promesses pour les objets distants (le dernier étant mis en œuvre dans Q-Connexion). Ils partagent tous la même interface et le travail en envoyant et en recevant des messages comme "alors" (ce qui est suffisant pour des Promesses/A+), mais aussi "get" et "invoquer". Ainsi, Q est sur “distribué asynchronie”, et existe sur un autre calque.

Cependant, Q a été prise vers le bas à partir d'une couche supérieure, où les promesses sont utilisés pour la gestion distribuée de l'asynchronie entre mutuellement suspect parties comme vous, un commerçant, une banque, Facebook, le gouvernement, pas des ennemis, peut-être même des amis, mais parfois avec des conflits d'intérêts. Le Q que j'ai mis en place est conçu pour être API compatible avec une sécurité renforcée des promesses (qui est la raison de la séparation promise et resolve), avec l'espoir qu'il serait de présenter les gens les promesses, les former à l'utilisation de cette API, et de leur permettre de prendre leur code avec eux s'ils ont besoin d'utiliser des promesses dans la sécurité des applications web hybrides dans l'avenir.

Bien sûr, il existe des échanges que vous vous déplacez les couches, généralement en vitesse. Donc, les promesses implémentations peuvent également être conçu de manière à co-exister. C'est là que le concept de “thenable” entre. Promesse de bibliothèques au niveau de chaque couche peut être conçu pour consommer promet de n'importe quelle autre couche, de sorte que plusieurs implémentations peuvent coexister, et les utilisateurs peuvent acheter uniquement ce dont ils ont besoin.

Tout cela est dit, il n'y a aucune excuse pour être difficile à lire. Dominique et moi-même travaillons sur une version de Q, qui sera plus modulaire et accessible, avec certains de ses distraire des dépendances et des solutions de rechange déplacés dans d'autres modules et packages. Heureusement que des gens comme Forbes, Crockford, et d'autres ont comblé la lacune de l'éducation en rendant plus simple bibliothèques.

Vous pourriez vouloir vérifier la post de blog sur Adehun.

Adehun est extrêmement léger de mise en œuvre (environ 166 LOC) et très utile pour l'apprentissage de la façon de mettre en œuvre la Promesse/A+ spec.

Avertissement: j'ai écrit le post de blog mais le blog ne s'expliquent tout sur Adehun.

La Transition de la fonction de Gardien de l'État de Transition

Gardien de la fonction; s'assure que les transitions d'état de se produire lorsque toutes les conditions requises sont réunies.

Si les conditions sont remplies, cette fonction met à jour la promesse de l'état et de la valeur. Il déclenche alors la fonction de traitement pour un traitement ultérieur.

Le processus de la fonction effectue le droit d'action fondé sur la transition (par exemple, dans l'attente d'accompli) et est expliquée plus tard.

function transition (state, value) {
if (this.state === state ||
this.state !== validStates.PENDING ||
!isValidState(state)) {
return;
}
this.value = value;
this.state = state;
this.process();
}

La fonction

La fonction prend deux arguments optionnels (onFulfill et onReject gestionnaires) et doit retourner une nouvelle promesse. Deux exigences principales:

1. La base de la promesse (celui qui est alors appelé) a besoin de créer une nouvelle promesse en utilisant le passé dans les gestionnaires; la base stocke également une référence interne à créé cette promesse si elle peut être invoquée une fois que la base se réalise la promesse de/rejeté.

2. Si la base promesse est réglé (c'est à dire rempli ou rejetée), puis le gestionnaire approprié doit être appelé immédiatement. Adehun.js les poignées de ce scénario par le processus appelant dans la fonction.

`

function then(onFulfilled, onRejected) {
var queuedPromise = new Adehun();
if (Utils.isFunction(onFulfilled)) {
queuedPromise.handlers.fulfill = onFulfilled;
}
if (Utils.isFunction(onRejected)) {
queuedPromise.handlers.reject = onRejected;
}
this.queue.push(queuedPromise);
this.process();
return queuedPromise;
}`

Le Processus de la fonction de Traitement des Transitions

Ce qui est appelé après que les transitions de l'état ou lorsque la fonction est appelée. Ainsi, il est nécessaire de vérifier pour l'attente des promesses, car il pourrait avoir été appelée à partir de la fonction.

Exécution du processus de la Promesse procédure de Résolution sur tous les internes des promesses (c'est à dire ceux qui étaient attachés à la base de la promesse par le biais de la fonction) et applique les suivantes Promesse/A+ exigences:

1. Invoquant les gestionnaires de manière asynchrone à l'aide de la Utils.runAsync helper (une fine wrapper autour de setTimeout (setImmediate fonctionnera également)).

2. La création de secours des gestionnaires pour les onSuccess et onReject gestionnaires s'ils sont absents.

3. Du choix de la fonction de gestionnaire basé sur la promesse de l'état par exemple remplies ou rejeté.

4. L'application de la gestionnaire de la base de la promesse de valeur. La valeur de cette opération est transmis à la détermination de la fonction à remplir la promesse du cycle de traitement.

5. Si une erreur se produit, alors l'attaché promesse est immédiatement rejeté.

   fonction process() {
   var que = ce,
   fulfillFallBack = function(valeur) {
   valeur de retour;
   },
   rejectFallBack = function(la raison) {
   jeter de la raison;
   };

   if (this.state === validStates.PENDING) {
   return;
   }
   Utils.runAsync(function() {
   while (that.queue.length) {
   var queuedP = that.queue.shift(),
   handler = null,
   value;
   if (that.state === validStates.FULFILLED) {
   handler = queuedP.handlers.fulfill ||
   fulfillFallBack;
   }
   if (that.state === validStates.REJECTED) {
   handler = queuedP.handlers.reject ||
   rejectFallBack;
   }
   try {
   value = handler(that.value);
   } catch (e) {
   queuedP.reject(e);
   continue;
   }
   Resolve(queuedP, value);
   }
   });

   }

La détermination de la fonction de Résolution des Promesses

C'est probablement la partie la plus importante de la promesse de la mise en œuvre puisqu'elle gère la promesse de résolution. Il accepte deux paramètres: la promesse et sa valeur de résolution.

Alors qu'il y a beaucoup de contrôles pour différentes valeurs de résolution; l'intéressant scénarios de résolution sont deux ceux impliquant une promesse d'être passé et d'un thenable (un objet avec une valeur).

1. Passant une Promesse de valeur

Si la valeur de la résolution est une autre promesse, alors, la promesse doit d'adopter cette résolution de la valeur de l'état. Depuis cette valeur de la résolution peut être en attente ou réglé, la meilleure façon de le faire est de fixer un nouveau gestionnaire de la valeur de la résolution et de la poignée de la promesse d'origine qui y est. Chaque fois qu'il s'installe, puis la promesse d'origine sera résolu ou rejeté.

1. Passant dans un thenable valeur

Le hic ici est que le thenable valeur est alors fonction doit être appelée qu'une seule fois (une bonne utilisation pour la une fois wrapper de la programmation fonctionnelle). De même, si la récupération de la fonction lève une Exception, la promesse est pour être immédiatement rejeté.

Comme avant, alors la fonction est appelée avec des fonctions qui, en définitive, de résoudre ou de rejeter la promesse, mais la différence ici est appelé l'indicateur qui est fixé sur le premier appel et transforme les appels ultérieurs sont pas d'ops.

function Resolve(promise, x) {
if (promise === x) {
var msg = "Promise can't be value";
promise.reject(new TypeError(msg));
}
else if (Utils.isPromise(x)) {
if (x.state === validStates.PENDING){
x.then(function (val) {
Resolve(promise, val);
}, function (reason) {
promise.reject(reason);
});
} else {
promise.transition(x.state, x.value);
}
}
else if (Utils.isObject(x) ||
Utils.isFunction(x)) {
var called = false,
thenHandler;
try {
thenHandler = x.then;
if (Utils.isFunction(thenHandler)){
thenHandler.call(x,
function (y) {
if (!called) {
Resolve(promise, y);
called = true;
}
}, function (r) {
if (!called) {
promise.reject(r);
called = true;
}
});
} else {
promise.fulfill(x);
called = true;
}
} catch (e) {
if (!called) {
promise.reject(e);
called = true;
}
}
}
else {
promise.fulfill(x);
}
}

La Promesse Du Constructeur

Et c'est celui qui met tout cela ensemble. Le remplir et de rejeter les fonctions sont sucre syntaxique qui passent no-op fonctions à résoudre et de les rejeter.

var Adehun = function (fn) {
var that = this;
this.value = null;
this.state = validStates.PENDING;
this.queue = [];
this.handlers = {
fulfill : null,
reject : null
};
if (fn) {
fn(function (value) {
Resolve(that, value);
}, function (reason) {
that.reject(reason);
});
}
};

J'espère que cela a aidé à jeter plus de lumière dans la façon dont les promesses de travail.