JavaScript Promise API

虽然同步的法典更容易遵循和缩减,但整体而言,业绩和灵活性较好。 当你能够一劳永逸地提出许多要求,然后在每一件事准备就绪时处理这些请求时,为什么会“搁置”? 允诺正在成为Script大世界的一大部分,许多新诺言正在以许诺的哲学实施。 让我们看一看诺言、诺言、它如何使用!

Promises in the Wild

XMLHttpRequest AP是同仁,但not则使用Promises AP。 然而,现在有几个本土的亚普森使用许诺:

Battery API

fetch API (XHR s replacement)

ServiceWorker API (post coming soon!)

特许权只会变得更加普遍,因此,所有前线开发商都必须利用这些机会。 值得注意的是,Node.js是另一个论坛(显然,由于Promise是核心语言特征)。

试验承诺可能比你认为容易,因为<条码> 准时 可用作你的“任务”!

Basic Promise Usage

。 新的《指南》(<>新) 关键词和允诺提供<代码>resolve和reject功能,以补充:

var p = new Promise(function(resolve, reject) {
	
	// Do an async task async task and then...

	if(/* good condition */) {
		resolve( Success! );
	}
	else {
		reject( Failure! );
	}
});

p.then(function(result) { 
	/* do something with the result */
}).catch(function() {
	/* error :( */
}).finally(function() {
   /* executes regardless or success for failure */ 
});

它要求开发商根据各自任务的结果,在背书的体内人工打电话resolve或reject。 一个现实的例子就是将XMLHttpRequest转化为基于承诺的任务:

// From Jake Archibald s Promises and Back:
// http://www.html5rocks.com/en/tutorials/es6/promises/#toc-promisifying-xmlhttprequest

function get(url) {
  // Return a new promise.
  return new Promise(function(resolve, reject) {
    // Do the usual XHR stuff
    var req = new XMLHttpRequest();
    req.open( GET , url);

    req.onload = function() {
      // This is called even on 404 etc
      // so check the status
      if (req.status == 200) {
        // Resolve the promise with the response text
        resolve(req.response);
      }
      else {
        // Otherwise reject with the status text
        // which will hopefully be a meaningful error
        reject(Error(req.statusText));
      }
    };

    // Handle network errors
    req.onerror = function() {
      reject(Error("Network Error"));
    };

    // Make the request
    req.send();
  });
}

// Use it!
get( story.json ).then(function(response) {
  console.log("Success!", response);
}, function(error) {
  console.error("Failed!", error);
});

有时,在承诺范围内完成一项共同任务——如果是possible,那么,如果将采取联合行动,那么,回报承诺将最为有利,以便你能够始终根据某项职能作出的承诺。 在这种情况下,你只能使用<条码>新或<条码>查询。 例如:

var userCache = {};

function getUserDetail(username) {
  // In both cases, cached or not, a promise will be returned

  if (userCache[username]) {
  	// Return a promise without the "new" keyword
    return Promise.resolve(userCache[username]);
  }

  // Use the fetch API to get the information
  // fetch returns a promise
  return fetch( users/  + username +  .json )
    .then(function(result) {
      userCache[username] = result;
      return result;
    })
    .catch(function() {
      throw new Error( Could not find user:   + username);
    });
}

由于允诺总是回来,你可以始终使用<代码>then <>/code>和 副渔获物/代码>。 返回价值的方法!

new Promise(function(resolve, reject) {
	// A mock async action using setTimeout
	setTimeout(function() { resolve(10); }, 3000);
})
.then(function(result) {
	console.log(result);
});

// From the console:
// 10

<代码>then 呼应可在允诺解决时启动。 也可使用链条<代码>then方法反馈:

new Promise(function(resolve, reject) { 
	// A mock async action using setTimeout
	setTimeout(function() { resolve(10); }, 3000);
})
.then(function(num) { console.log( first then:  , num); return num * 2; })
.then(function(num) { console.log( second then:  , num); return num * 2; })
.then(function(num) { console.log( last then:  , num);});

// From the console:
// first then:  10
// second then:  20
// last then:  40

每一条<代码>then/code>均收到以前的<代码>then收益值。

如果允诺已经解决,但<代码>then则再次被点击。 如果允诺被拒,在被拒后请上<代码>then,则从不要求退约。

catch

承诺被拒时,可执行<条码>。

new Promise(function(resolve, reject) {
	// A mock async action using setTimeout
	setTimeout(function() { reject( Done! ); }, 3000);
})
.then(function(e) { console.log( done , e); })
.catch(function(e) { console.log( catch:  , e); });

// From the console:
//  catch: Done! 

页: 1 方法由您负责。 经常采用的一种方式是向<条码>发送<>/条码>。

reject(Error( Data could not be found ));

finally

新引入的<条码>明确呼应,不论成功与否:

(new Promise((resolve, reject) => { reject("Nope"); }))
    .then(() => { console.log("success") })
    .catch(() => { console.log("fail") })
    .finally(res => { console.log("finally") });

// >> fail
// >> finally

Promise.all

想一下 Java的装货机:在什么时候,你会引发多种星际互动,但只有在所有这些星体都填满时才会作出反应——<代码>Promise.all。 <代码>Promise.all 方法在各种承诺和火灾一经解决后即发生:

Promise.all([promise1, promise2]).then(function(results) {
	// Both promises resolved
})
.catch(function(error) {
	// One or more promises was rejected
});

关于<代码>Promise.all的完美思维方式是一次性向美国宇宙航空研究开发机构(通过<代码>fetch)申请发射:

var request1 = fetch( /users.json );
var request2 = fetch( /articles.json );

Promise.all([request1, request2]).then(function(results) {
	// Both promises done!
});

您可以把诸如<代码>fetch和“电池标书”等的APICA与“电池组”,因为它们都承诺:

Promise.all([fetch( /users.json ), navigator.getBattery()]).then(function(results) {
	// Both promises done!
});

处理拒绝当然是困难的。 如果任何允诺都被否决,则首先予以拒绝的<编码> 渔获火灾:

var req1 = new Promise(function(resolve, reject) { 
	// A mock async action using setTimeout
	setTimeout(function() { resolve( First! ); }, 4000);
});
var req2 = new Promise(function(resolve, reject) { 
	// A mock async action using setTimeout
	setTimeout(function() { reject( Second! ); }, 3000);
});
Promise.all([req1, req2]).then(function(results) {
	console.log( Then:  , results);
}).catch(function(err) {
	console.log( Catch:  , err);
});

// From the console:
// Catch: Second!

<代码>Promise.all将发挥超级作用,因为更多的APIC实现承诺。

Promise.race

<>Promise.race是一个有趣的职能,而不是等待所有要解决或否决的承诺,Promise.race<>/code>。 一旦阵列中的任何承诺得到解决或否决,即立即启动:

var req1 = new Promise(function(resolve, reject) { 
	// A mock async action using setTimeout
	setTimeout(function() { resolve( First! ); }, 8000);
});
var req2 = new Promise(function(resolve, reject) { 
	// A mock async action using setTimeout
	setTimeout(function() { resolve( Second! ); }, 3000);
});
Promise.race([req1, req2]).then(function(one) {
	console.log( Then:  , one);
}).catch(function(one, two) {
	console.log( Catch:  , one);
});

// From the console:
// Then: Second!

使用案例可能会引发向主要来源和次要来源提出请求(如果没有初级或中级来源)。

Get Used to Promises

过去几年来,房地一直是热门话题(如果是Dojo工具kit用户的话,则过去10年),从贾瓦文框架模式到语言主。 假定你会看到大多数新的贾瓦·普兰斯塔文正在以许诺为基础的模式实施,这或许是明智的。

......,这 thing! 开发商能够避免背心,并且可以像任何其他变量一样,通过合成互动。 允诺需要一些时间才能成为工具(原称)在那里,现在是学习这些工具的时候了!