Penso di essere finalmente riuscito a piegare la mente alle promesse di javascript/ES6, per la maggior parte. Non è stato facile! Ma c'è qualcosa che mi sconcerta del design.L'API di javascript Promise è più complicata di quanto dovrebbe essere?
Perché il costruttore Promise effettua una richiamata? Dato che il callback è chiamato immediatamente, non è possibile che il chiamante esegua quel codice, evitando così un livello non necessario di piegamento mentale "non chiamarmi, ti chiamo"?
Ecco quello che penso come l'esempio prototipo di utilizzo Promise, copiato dal tutorial di Jake Archibald Javascript Promises http://www.html5rocks.com/en/tutorials/es6/promises/#toc-promisifying-xmlhttprequest, con i commenti spogliati.
Si tratta di un wrapper promessa-based per una richiesta di XMLHttpRequest GET:
function get(url) {
return new Promise(function(resolve, reject) {
var req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
if (req.status == 200) {
resolve(req.response);
}
else {
reject(Error(req.statusText));
}
};
req.onerror = function() {
reject(Error("Network Error"));
};
req.send();
});
}
Per me, il codice di cui sopra sarebbe molto più facile da capire se fosse riscritta come segue, con un po 'diverso tipo di promessa che sto immaginando, avendo un costruttore no-arg e risolvere/rifiutare metodi:
function get(url) {
var promise = new MyEasierToUnderstandPromise();
var req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
if (req.status == 200) {
promise.resolve(req.response);
}
else {
promise.reject(Error(req.statusText));
}
};
req.onerror = function() {
promise.reject(Error("Network Error"));
};
req.send();
return promise;
}
MyEasierToUnderstandPromise non è troppo difficile da attuare in termini di promessa. All'inizio ho provato a farne una vera e propria sottoclasse di Promise, ma per qualche motivo non ho potuto farlo funzionare; così invece ho implementato come una semplice funzione di fabbrica, che restituisce un oggetto semplice promessa vecchia con un paio di funzioni extra attaccato che si comportano come funzioni membro:
function NewMyEasierToUnderstandPromise() {
var resolveVar;
var rejectVar;
var promise = new Promise(function(resolveParam, rejectParam) {
resolveVar = resolveParam;
rejectVar = rejectParam;
});
promise.resolve = resolveVar;
promise.reject = rejectVar;
return promise;
};
Quindi, perché non è promessa progettato come questo? Penso che se lo fosse, mi avrebbe aiutato a capire Promises molto più velocemente ... Scommetto che avrebbe ridotto il mio tempo di apprendimento a metà.
So che molte persone intelligenti hanno contribuito all'API Promise, e tutti sembrano essere generalmente felici e orgogliosi di ciò, quindi mi sto chiedendo cosa stessero pensando.
vostro "easierToUnderstandPromise" è come jQuery.Deferred in un certo senso. Con il tuo progetto, la promessa restituita espone necessariamente i metodi di risoluzione/rifiuto. Ho letto da qualche parte perché questa è una "brutta cosa", ma non riesco a trovare quella risorsa (sono passati anni da quando l'ho letta) –
Leggi informazioni su [ES7 async/await] (https://jakearchibald.com/2014/ES7-asincroni funzioni /). –
C'è anche lo schema differito, ma [è deprecato per una buona ragione] (http://stackoverflow.com/q/28687566/1048572) – Bergi