Promise彩民之家高手论坛

2019-10-11 12:57 来源:未知

异步函数和生成器相比较

这有个利用生成器举办异步编制程序的实例,用的是 Q 库:

var doAsyncOp = Q.async(function* () {   var val = yield asynchronousOperation();   console.log(val);   return val; });

1
2
3
4
5
var doAsyncOp = Q.async(function* () {
  var val = yield asynchronousOperation();
  console.log(val);
  return val;
});

Q.async 是个封装函数,管理场景后的业务。个中 * 表示作为三个生成器函数的遵循,yield 表示结束函数,并用封装函数代替。Q.async 将会回来三个函数,你可对它赋值,就疑似赋值 doAsyncOp 一样,随后再调用。

ES7 中的新语法更简明,操作示比方下:

async function doAsyncOp () {   var val = await asynchronousOperation();        console.log(val);   return val; };

1
2
3
4
5
async function doAsyncOp () {
  var val = await asynchronousOperation();     
  console.log(val);
  return val;
};

出入非常的小,我们删除了一个打包的函数和 * 符号,转而用 async 关键字取代。yield 关键字也被 await 代替。那三个例证事实上做的事是一律的:在 asynchronousOperation 完结现在,赋值给 val,然后开展输出并回到结果。

用以拍卖贰个数组,可能 promise 数组,

所谓 Promise,正是一个对象,用来传递异步操作的消息。它意味着了有个别以后才会掌握结果的风云(平常是贰个异步操作),并且那么些事件提供联合的 API,可供进一步管理。

用 Async 函数简化异步代码

2017/04/08 · JavaScript · 异步

原稿出处: Joe Zimmerman , Nilson Jacques   译文出处:oschina   

Promise 在 JavaScript 上宣布之初就在互连网络风行了起来 — 它们帮开辟人士摆脱了回调鬼世界,化解了在广大地点忧虑 JavaScript 开采者的异步难点。但 Promises 也尚无完美。它们平素呼吁回调,在局地繁缛的主题素材上仍会有一点点糊涂和局地狐疑的冗余。

随着 ES6 的赶来(以后被称作 ES二零一四),除了引进 Promise 的标准,不供给乞请那多少个成千上万的库之外,我们还会有了生成器。生成器可在函数内部甘休执行,那象征可把它们封装在八个多用途的函数中,大家可在代码移动到下一行在此之前等待异步操作实现。忽然你的异步代码也许就从头看起来共同了。

那只是首先步。异步函数因今年投入 ES2017,已拓宽标准,本地支持也更是优化。异步函数的见解是选拔生成器进行异步编制程序,并付诸他们友善的语义和语法。因而,你不要使用库来获得封装的实用函数,因为这个都会在后台管理。

运营小说中的 async/await 实例,你须求三个能协作的浏览器。

概念

  1. any 、some、race

链式操作

Promise 之所以能受到大家追捧,当中四个地点是因为它能以链式调用的法子把五个异步操作连接起来,幸免了放置方式的回调。可是async 函数在这里个地点如故比 Promise 做得万幸。

上边演示了什么样运用 Promise 来开展链式操作(我们只是简短的频仍运维 asynchronousOperation 来张开身先士卒)。

function doAsyncOp() {   return asynchronousOperation()     .then(function(val) {       return asynchronousOperation(val);     })     .then(function(val) {       return asynchronousOperation(val);     })     .then(function(val) {       return asynchronousOperation(val);     }); }

1
2
3
4
5
6
7
8
9
10
11
12
function doAsyncOp() {
  return asynchronousOperation()
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .then(function(val) {
      return asynchronousOperation(val);
    });
}

选取 async 函数,只须求像编写同步代码那样调用 asynchronousOperation:

async function doAsyncOp () {   var val = await asynchronousOperation();   val = await asynchronousOperation(val);   val = await asynchronousOperation(val);   return await asynchronousOperation(val); };

1
2
3
4
5
6
async function doAsyncOp () {
  var val = await asynchronousOperation();
  val = await asynchronousOperation(val);
  val = await asynchronousOperation(val);
  return await asynchronousOperation(val);
};

依旧最终的 return 语句中都无需动用 await,因为用或不用,它都回到了含蓄了可处理终值的 Promise。

(1)对象的动静不受外部影响。Promise 对象表示二个异步操作,有两种情状:Pending(实行中)、Resolved(已产生,又称 Fulfilled)和 Rejected(已破产)。独有异步操作的结果,能够调节当前是哪个种类情景,任何其余操作都力所不如转移这么些情况。那也是 Promise 这一个名字的案由,它的希伯来语意思便是「承诺」,表示别的花招不可能改变。

  1. bind

运营特别

在客商端,Chrome、Firefox 和 Opera 能很好地扶植异步函数。

彩民之家高手论坛 1

(点击图片张开页面跳转)

从 7.6 版本开端,Node.js 私下认可启用 async/await。

进阶

//Total is 30

出现操作

Promise 还应该有另三个宏大的特色,它们得以同偶尔间开展多少个异步操作,等他们全体到位现在再持续张开别的事件。ES二零一四标准中提供了 Promise.all(),正是用来干这一个事情的。

此处有一个示范:

function doAsyncOp() {   return Promise.all([     asynchronousOperation(),     asynchronousOperation()   ]).then(function(vals) {     vals.forEach(console.log);     return vals;   }); }

1
2
3
4
5
6
7
8
9
function doAsyncOp() {
  return Promise.all([
    asynchronousOperation(),
    asynchronousOperation()
  ]).then(function(vals) {
    vals.forEach(console.log);
    return vals;
  });
}

Promise.all() 也足以作为 async 函数使用:

async function doAsyncOp() {   var vals = await Promise.all([     asynchronousOperation(),     asynchronousOperation()   ]);   vals.forEach(console.log.bind(console));   return vals; }

1
2
3
4
5
6
7
8
async function doAsyncOp() {
  var vals = await Promise.all([
    asynchronousOperation(),
    asynchronousOperation()
  ]);
  vals.forEach(console.log.bind(console));
  return vals;
}

这里就是使用了 Promise.all,代码仍旧很明亮。

Promise.reject()

  1. all。非常用于于管理一个动态大小均匀的 Promise 列表

  2. join。非常适用于管理多少个分别的 Promise

今昔,越来越好的异步代码!

即便你作者不可能利用异步代码,你也足以实行编辑或利用工具将其编写翻译为 ES5。 异步函数能让代码更便于阅读,更易于维护。 只要我们有 source maps,大家得以每天使用更干净的 ES2017 代码。

有点不清能够将异步功能(和任何 ES二〇一六 成效)编写翻译成 ES5 代码的工具。 假如你使用的是 Babel,那只是设置 ES2017 preset 的例子。

1 赞 1 收藏 评论

彩民之家高手论坛 2

结果

co

问题

假让你刚开首使用 async 函数,须要小心嵌套函数的题目。比方,纵然您的 async 函数中有另贰个函数(常常是回调),你或许以为能够在中间使用 await ,但实在无法。你不得不平素在 async 函数中央银行使 await 。

举个例子说,这段代码不能够运营:

async function getAllFiles(fileNames) {   return Promise.all(     fileNames.map(function(fileName) {       var file = await getFileAsync(fileName);       return parse(file);     })   ); }

1
2
3
4
5
6
7
8
async function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(function(fileName) {
      var file = await getFileAsync(fileName);
      return parse(file);
    })
  );
}

第 4 行的 await 无效,因为它是在二个平常函数中选拔的。可是能够由此为回调函数增添 async 关键字来消除那么些标题。

async function getAllFiles(fileNames) {   return Promise.all(     fileNames.map(async function(fileName) {       var file = await getFileAsync(fileName);       return parse(file);     })   ); }

1
2
3
4
5
6
7
8
async function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(async function(fileName) {
      var file = await getFileAsync(fileName);
      return parse(file);
    })
  );
}

您见到它的时候会感到道理当然是那样的,即使如此,还是需求小心这种情形。

恐怕你还想知道等价的行使 Promise 的代码:

function getAllFiles(fileNames) {   return Promise.all(     fileNames.map(function(fileName) {       return getFileAsync(fileName).then(function(file) {         return parse(file);       });     })   ); }

1
2
3
4
5
6
7
8
9
function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(function(fileName) {
      return getFileAsync(fileName).then(function(file) {
        return parse(file);
      });
    })
  );
}

接下去的难点是有关把 async 函数看作同步函数。需求记住的是,async 函数内部的的代码是手拉手运营的,不过它会应声赶回一个Promise,并传承运营外面包车型大巴代码,比方:

var a = doAsyncOp(); // one of the working ones from earlier console.log(a); a.then(function() {   console.log("`a` finished"); }); console.log("hello"); /* -- will output -- */ Promise Object hello `a` finished

1
2
3
4
5
6
7
8
9
10
11
var a = doAsyncOp(); // one of the working ones from earlier
console.log(a);
a.then(function() {
  console.log("`a` finished");
});
console.log("hello");
 
/* -- will output -- */
Promise Object
hello
`a` finished

您拜候到 async 函数实际接纳了安置的 Promise。那让大家思想 async 函数中的同步行为,此外人能够经过常备的 Promise API 调用大家的 async 函数,也能够动用它们本身的 async 函数来调用。

return fs.readFileAsync(fileName, "utf8").then(function(contents) {

console.log(result.tweets, result.pictures, result.comments);

将 Promises 转变来异步函数

假使我们使用 Vanilla Promises 的话前边的以身作则将会是哪些?

function doAsyncOp () {   return asynchronousOperation().then(function(val) {     console.log(val);     return val;   }); };

1
2
3
4
5
6
function doAsyncOp () {
  return asynchronousOperation().then(function(val) {
    console.log(val);
    return val;
  });
};

此地有平等的代码行数,但那是因为 then 和给它传递的回调函数扩展了众多的额外代码。另二个令人深恶痛绝的是七个 return 关键字。那直接不怎么事苦恼着自己,因为它很难弄掌握使用 promises 的函数确切的回到是怎样。

就如您看见的,这一个函数再次来到一个promises,将会赋值给 val,猜一下生成器和异步函数示例做了哪些!无论你在这里个函数重回了什么样,你其实是暗地里再次回到贰个promise 深入分析到非常值。假若您根本就不曾回来任何值,你暗地里重返的 promise 深入分析为 undefined。

err.forEach(function(e) {

});

中断 Promise

闭门羹原生的 Promise,只必要选拔 Promise 创设函数中的 reject 就好,当然也能够一向抛出荒唐——在 Promise 的构造函数中,在 then 或 catch 的回调中抛出都足以。假诺是在任哪个地方方抛出荒谬,Promise 就管不了了。

此间有一对驳回 Promise 的示范:

function doAsyncOp() {   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       reject("something is bad");     }     resolve("nothing is bad");   }); } /*-- or --*/ function doAsyncOp() {   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       reject(new Error("something is bad"));     }     resolve("nothing is bad");   }); } /*-- or --*/ function doAsyncOp() {   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       throw new Error("something is bad");     }     resolve("nothing is bad");   }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      reject("something is bad");
    }
    resolve("nothing is bad");
  });
}
 
/*-- or --*/
 
function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      reject(new Error("something is bad"));
    }
    resolve("nothing is bad");
  });
}
 
/*-- or --*/
 
function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      throw new Error("something is bad");
    }
    resolve("nothing is bad");
  });
}

诚如的话,最棒使用 new Error,因为它会蕴藏错误相关的别的音讯,举例抛出地方的行号,以致或者会使得的调用栈。

此地有一部分抛出 Promise 不能够捕捉的谬误的亲自去做:

function doAsyncOp() {   // the next line will kill execution   throw new Error("something is bad");   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       throw new Error("something is bad");     }     resolve("nothing is bad");   }); } // assume `doAsyncOp` does not have the killing error function x() {   var val = doAsyncOp().then(function() {     // this one will work just fine     throw new Error("I just think an error should be here");   });   // this one will kill execution   throw new Error("The more errors, the merrier");   return val; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function doAsyncOp() {
  // the next line will kill execution
  throw new Error("something is bad");
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      throw new Error("something is bad");
    }
    resolve("nothing is bad");
  });
}
 
// assume `doAsyncOp` does not have the killing error
function x() {
  var val = doAsyncOp().then(function() {
    // this one will work just fine
    throw new Error("I just think an error should be here");
  });
  // this one will kill execution
  throw new Error("The more errors, the merrier");
  return val;
}

在 async 函数的 Promise 中抛出荒谬就不会生出关于范围的主题素材——你能够在 async 函数中时时到处抛出荒唐,它总会被 Promise 抓住:

async function doAsyncOp() {   // the next line is fine   throw new Error("something is bad");   if (somethingIsBad) {     // this one is good too     throw new Error("something is bad");   }   return "nothing is bad"; }  // assume `doAsyncOp` does not have the killing error async function x() {   var val = await doAsyncOp();   // this one will work just fine   throw new Error("I just think an error should be here");   return val; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
async function doAsyncOp() {
  // the next line is fine
  throw new Error("something is bad");
  if (somethingIsBad) {
    // this one is good too
    throw new Error("something is bad");
  }
  return "nothing is bad";
 
// assume `doAsyncOp` does not have the killing error
async function x() {
  var val = await doAsyncOp();
  // this one will work just fine
  throw new Error("I just think an error should be here");
  return val;
}

理之当然,大家永恒不会运营到 doAsyncOp 中的第二个错误,也不会运作到 return 语句,因为在这里从前抛出的荒唐已经暂停了函数运转。

resolve(value);

回调函数真正的主题素材在于她剥夺了大家应用 return 和 throw 那些主要字的力量。而 Promise 很好地消除了那整个。

拍卖拒绝

Promises 能够被接受(resovled)也得以被拒绝(rejected)。被驳回的 Promise 能够经过三个函数来拍卖,那几个管理函数要传递给 then,作为其第三个参数,只怕传递给 catch 方法。今后大家未有运用 Promise API 中的方法,应该怎么管理拒绝?可以经过 try 和 catch 来拍卖。使用 async 函数的时候,拒绝被用作错误来传递,这样它们就足以由此 JavaScript 自个儿帮忙的错误管理代码来拍卖。

function doAsyncOp() {   return asynchronousOperation()     .then(function(val) {       return asynchronousOperation(val);     })     .then(function(val) {       return asynchronousOperation(val);     })     .catch(function(err) {       console.error(err);     }); }

1
2
3
4
5
6
7
8
9
10
11
12
function doAsyncOp() {
  return asynchronousOperation()
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .catch(function(err) {
      console.error(err);
    });
}

那与大家链式管理的亲自过问非常相似,只是把它的终极一环改成了调用 catch。假如用 async 函数来写,会像上面那样。

async function doAsyncOp () {   try {     var val = await asynchronousOperation();     val = await asynchronousOperation(val);     return await asynchronousOperation(val);   } catch (err) {     console.err(err);   } };

1
2
3
4
5
6
7
8
9
async function doAsyncOp () {
  try {
    var val = await asynchronousOperation();
    val = await asynchronousOperation(val);
    return await asynchronousOperation(val);
  } catch (err) {
    console.err(err);
  }
};

它不像任何往 async 函数的转移那样轻便,不过确实跟写同步代码同样。如若你在这里处不捕捉错误,它会延着调用链一贯发展抛出,直到在某处被捕捉管理。假如它直接未被捕捉,它谈到底会搁浅程序并抛出一个运行时不当。Promise 以同等的措施运维,只是拒绝不作为错误来拍卖;它们也许只是三个证明错误情形的字符串。借使您不捕捉被创设为错误的不容,你会看到一个运营时不当,然而假诺你只是使用一个字符串,会战败却不会有出口。

}

somethingAsync()

【嵌牛鼻子】:Promise

reject(error);

resolve(someValue);

return fs.readFileAsync(fileName, "utf8").then(function(contents) {

console.error(e.stack);

ping("ns3.example.com"),

promises 的魔幻在于给予大家在此以前的 return 与 throw,每一种 Promise 都会提供一个 then() 函数,和二个 catch(),实际上是 then(null, ...) 函数,

this.aValue = aValue;

ping("ns2.example.com"),

throw e;

scope.bValue = bValue;

});;

//Will end up here if a wasn't defined at all

.then(function (cValue) {

【嵌牛正文】:

//it is a type error to reference property of undefined

.then(function (cValue) {

reading files: 9ms

})

无法用来放在贰个表达式的光景文中

有望,退步的 promise 相当多,导致,Promsie 永世不会 fulfilled

bluebird

co

Promise.reduce(["file1.txt", "file2.txt", "file3.txt"], function(total, fileName) {

somethingAsync().bind({})

  1. .map(Function mapper [, Object options])

], 2).spread(function(first, second) {

设假如一同代码,能够写成

  1. .map(Function mapper [, Object options])

}).catch(AggregateError, function(err) {

//If a is defined, will end up here because

}).catch(function(e) {

Option: concurrency 并发现

return scope.aValue scope.bValue cValue;

//ReferenceError

console.log(err);

.delay(int ms) -> Promise

.then(JSON.parse)

//it is a type error to reference property of undefined

```

```

e.fileName = fileName;

var join = Promise.join;

Promise.props({

}).catch(function(e) {

Promise.reject(new Error("什么鬼"));

});

$ sync && echo 3 > /proc/sys/vm/drop_caches

.then(function (cValue) {

  1. .reduce(Function reducer [, dynamic initialValue]) -> Promise

});

用于拍卖二个数组,也许 promise 数组,

e.fileName = fileName;

// do something

Promise.race()      // 竞速,达成贰个就可以

}, function(value) {

  1. 抓获同步卓殊
  1. 几个可怜捕获,越来越精准的破获

})

//ReferenceError

var scope = {};

ping("ns1.example.com"),

Promise.resolve()

});

不过,那有相当多的区分,

somePromise.then(function() {

Promise in js

new Promise(function (resolve, reject) {

this.aValue = aValue;

//Will end up here if a wasn't defined at all

somePromise().then(functoin(){

你必得先表明,有浪费能源和内部存款和储蓄器走漏的高风险

throw e;

}, 0).then(function(total) {

}).catch(function(err){

when

});

```

Promise.prototype.then()

}).catch(function(err){

别的情状下都会实行的,日常写在 catch 之后

})

.spread(function (aValue, bValue) {

comments: getComments(),

```

}).catch(TypeError, function(e) {

var concurrency = parseFloat(process.argv[2] || "Infinity");

throw new Error('悲剧了,又出 bug 了');

});

var Promise = require("bluebird");

  1. 三个极其捕获,更精准的抓获

//Generic catch-the rest, error wasn't TypeError nor

Promise 对象有以下二日性状。

Promise 也许有一点点欠缺。首先,不能够撤除Promise,一旦新建它就能立刻推行,不能中途撤废。其次,假诺不安装回调函数,Promise 内部抛出的谬误,不会影响到表面。第三,当远在 Pending 状态时,无法获悉这段日子拓宽到哪多少个等级(刚刚发轫照旧将在实现)。

});

scope.bValue = bValue;

.catch(SyntaxError, function(e) {

Promise 构造函数接受三个函数作为参数,该函数的多个参数分别是 resolve 方法和 reject 方法。

回调函数真正的标题在于他剥夺了笔者们利用 return 和 throw 这么些重大字的力量。而 Promise 很好地化解了那整个。

} else {

```

链接:

promise.then(function(value) {

$ node test.js Infinity

写成

});

console.log(first, second);

reading files 35ms

  1. Time

(1)对象的景观不受外部影响。Promise 对象表示贰个异步操作,有三种处境:Pending(举办中)、Resolved(已成功,又称 Fulfilled)和 Rejected(已停业)。独有异步操作的结果,能够操纵当前是哪一种状态,任何另外操作都无法儿退换这些状态。那也是 Promise 这几个名字的原因,它的法语意思就是「承诺」,表示其他手腕不恐怕改观。

}, 0).then(function(total) {

有极大也许,战败的 promise 相当多,导致,Promsie 永久不会 fulfilled

q

Promise.resolve(someValue);

要是是一道代码,能够写成

return a.b.c.d();

或许 你也足以如此

somePromise().then(functoin(){

```

```

ping("ns4.example.com")

以下为不限量并发数量,读书文件音讯

}).catch(TypeError, function(e) {

  1. props。管理五个 promise 的 map 集合。唯有有贰个未果,全数的施行都停止

}, function(value) {

var join = Promise.join;

});;

console.log("Invalid JSON in file " e.fileName ": " e.message);

你不能够不先证明,有浪费能源和内部存款和储蓄器败露的高危害

.delay(int ms) -> Promise

Promise 构造函数接受三个函数作为参数,该函数的五个参数分别是 resolve 方法和 reject 方法。

Promise.prototype.then()

(2)一旦状态改换,就不会再变,任何时候都得以赢得这几个结果。Promise 对象的图景改换,唯有三种恐怕:从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要那二种情景时有爆发,状态就扎实了,不会再变了,会直接维系那几个结果。尽管更改一度产生了,你再对 Promise 对象加多回调函数,也会即时收获那几个结果。那与事件(Event)完全分歧,事件的性状是,要是您错过了它,再去监听,是得不到结果的。

});

}, {concurrency: concurrency}).then(function(parsedJSONs) {

进阶

频率更低

若果异步操作成功,则用 resolve 方法将 Promise 对象的意况,从「未到位」变为「成功」(即从 pending 变为 resolved);

throw new Error('悲剧了,又出 bug 了');

我们能够做三件事,

```

pictures: getPictures(),

Promise.some([

promises 的光怪陆离在于给予我们从前的 return 与 throw,每种 Promise 都会提供叁个 then() 函数,和三个 catch(),实际上是 then(null, ...) 函数,

$ sync && echo 3 > /proc/sys/vm/drop_caches

Promise in js

console.log("Invalid JSON in file " e.fileName ": " e.message);

// failure

}).catch(AggregateError, function(err) {

}, {concurrency: concurrency}).then(function(parsedJSONs) {

reading files 35ms

ping("ns4.example.com")

});

console.log("in total: " pictures.length comments.length tweets.length);

new Promise(function (resolve, reject) {

Option: concurrency 并发现

var promise = new Promise(function(resolve, reject) {

});

.timeout(int ms [, String message]) -> Promise

console.log(first, second);

// failure

$ node test.js 1

Promise 的实现

});

bluebird

2015 年 6 月,ECMAScript 6 的正式版好不轻易发表了。

console.log("in total: " pictures.length comments.length tweets.length);

});

});

  1. 收获多少个 Promise 的再次回到值

  2. .then 方式顺序调用

  3. 设定更加高层的作用域

  4. spread

  5. finally

var join = Promise.join;

.spread(function (aValue, bValue) {

无法用于放在叁个表达式的前后文中

// success

});

Promise.map(fileNames, function(fileName) {

map(..., {concurrency: 1});

即使异步操作失利,则用 reject 方法将 Promise 对象的事态,从「未到位」变为「退步」(即从 pending 变为 rejected)。

var fs = Promise.promisifyAll(require("fs"));

somethingAsync().bind({})

});

});

有了 Promise 对象,就足以将异步操作以同步操作的流水生产线表达出来,幸免了稀有嵌套的回调函数。其余,Promise 对象提供联合的接口,使得调整异步操作越发轻易。

tweets: getTweets()

```

```

return somethingElseAsync(aValue, bValue);

写成

咱俩得以做三件事,

参照他事他说加以考察文献(说是抄也能够的):

var Promise = require("bluebird");

结果

new Promise(function (resolve, reject) {

  1. return 另一个 promise

  2. return 三个合伙的值 (恐怕 undefined)

  3. throw 三个齐声非凡 ` throw new Eror('');`

  4. 装进同步与异步代码

return somethingElseAsync(aValue, bValue);

this.bValue = bValue;

var p = Promise.all([p1,p2,p3]);

})

  1. all。特别用于于管理二个动态大小均匀的 Promise 列表

  2. join。特别适用于管理多个分别的 Promise

Promise 对象有以下两个特色。

$ node test.js Infinity

});

}).catch(ReferenceError, function(e) {

console.error(e.stack);

this.bValue = bValue;

  1. 抓获同步分外

ping("ns3.example.com"),

});

});

resolve(value);

//Generic catch-the rest, error wasn't TypeError nor

return somethingElseAsync(aValue, bValue);

return fs.readFileAsync(fileName)

scope.aValue = aValue;

when

Promise.reject()

Promise.all()    // 全数的到位

```

});

Promise彩民之家高手论坛。});

$ node test.js 1

return this.aValue this.bValue cValue;

return this.aValue this.bValue cValue;

基本的 api

.spread(function (aValue, bValue) {

], 2).spread(function(first, second) {

// do something

Promise.some([

//Total is 30

}).catch(SyntaxError, function(e) {

Promise彩民之家高手论坛。以下为不限量并发数量,读书文件音讯

var fileNames = ["file1.json", "file2.json"];

scope.aValue = aValue;

promise.then(function(value) {

```

//If a is defined, will end up here because

  1. any 、some、race

});

```

ping("ns2.example.com"),

Promise.props({

});

Promise 也是有部分弱点。首先,无法取消Promise,一旦新建它就能够立马施行,不可能中途打消。其次,假若不安装回调函数,Promise 内部抛出的错误,不会影响到表面。第三,当处于 Pending 状态时,不能得到消息前段时间进展到哪贰个等第(刚刚开始依然将在完毕)。

小说权归我全部。商业转发请联系小编获得授权,非商业转发请表明出处。

转载自:

Promise.race()        // 竞速,完毕二个就能够

}).catch(SyntaxError, function(e) {

概念

姓名:岳沁

.catch(SyntaxError, function(e) {

function(pictures, comments, tweets) {

resolve(someValue);

学号:17101223458

var p = Promise.all([p1,p2,p3]);

reject(error);

  1. Time

设若异步操作成功,则用 resolve 方法将 Promise 对象的情景,从「未产生」变为「成功」(即从 pending 变为 resolved);

})

reading files: 9ms

function(pictures, comments, tweets) {

ASYNC

q

  1. return 另一个 promise

  2. return 一个联机的值 (或然 undefined)

  3. throw 多个体协会同至极throw new Eror('');

  4. 卷入同步与异步代码

.then(function (cValue) {

基本的 api

别的意况下都会进行的,日常写在 catch 之后

if (/* 异步操作成功 */){

}).catch(ReferenceError, function(e) {

somethingAsync()

var fs = Promise.promisifyAll(require("fs"));

somePromise.then(function() {

ECMAScript 是 JavaScript 语言的国际标准,JavaScript 是 ECMAScript 的贯彻。ES6 的靶子,是驱动 JavaScript 语言能够用来编排大型的复杂的应用程序,成为厂商级开辟语言。

```

}).then(function(result) {

所谓 Promise,就是叁个对象,用来传递异步操作的音信。它意味着了有些现在才会清楚结果的平地风波(平日是贰个异步操作),并且那些事件提供联合的 API,可供进一步管理。

Promise.all()    // 全数的达成

});

async 函数与 Promise、Generator 函数同样,是用来代表回调函数、化解异步操作的一种艺术。它实质上是 Generator 函数的语法糖。async 函数并不属于 ES6,而是被列入了 ES7。

})

ES6 原生提供了 Promise 对象。

// success

Promise 的实现

所谓 Promise,正是三个目的,用来传递异步操作的音讯。它表示了某些今后才会知晓结果的平地风波(平时是一个异步操作),而且那几个事件提供联合的 API,可供进一步管理。

err.forEach(function(e) {

  1. 获取三个 Promise 的重临值

  2. .then 格局顺序调用

  3. 设定越来越高层的成效域

  4. spread

  5. finally

return total parseInt(contents, 10);

ping("ns1.example.com"),

只怕 你也足以如此

return a.b.c.d();

$ sync && echo 3 > /proc/sys/vm/drop_caches

ECMAScript 是 JavaScript 语言的国际规范,JavaScript 是 ECMAScript 的兑现。ES6 的对象,是驱动 JavaScript 语言能够用来编排大型的头眼昏花的应用程序,成为集团级开拓语言。

join(getPictures(), getComments(), getTweets(),

return total parseInt(contents, 10);

return somethingElseAsync(aValue, bValue);

ES6 原生提供了 Promise 对象。

var join = Promise.join;

});

(2)一旦状态更换,就不会再变,随时都得以收获这么些结果。Promise 对象的情事改换,独有三种也许:从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要那三种情形时有产生,状态就扎实了,不会再变了,会直接保持那么些结果。固然改变一度爆发了,你再对 Promise 对象增添回调函数,也会及时获得这几个结果。那与事件(Event)完全不一致,事件的特色是,假如您错失了它,再去监听,是得不到结果的。

```

.spread(function (aValue, bValue) {

【嵌牛导读】:ES6 原生提供了 Promise 对象。

频率更低

Promise.resolve(someValue);

new Promise(function (resolve, reject) {

  1. props。管理二个 promise 的 map 集结。独有有二个受挫,全数的实施都终止

return fs.readFileAsync(fileName)

倘诺异步操作失利,则用 reject 方法将 Promise 对象的图景,从「未成功」变为「失利」(即从 pending 变为 rejected)。

Promise.resolve()

return scope.aValue scope.bValue cValue;

var concurrency = parseFloat(process.argv[2] || "Infinity");

Promise.prototype.catch()

if (/* 异步操作成功 */){

join(getPictures(), getComments(), getTweets(),

```

} else {

來源:简书

console.log(err);

Promise.prototype.catch()

console.log(result.tweets, result.pictures, result.comments);

console.log(parsedJSONs);

Promise彩民之家高手论坛。【嵌牛提问】:怎样巩固Promise作用?

```

console.log(parsedJSONs);

}

pictures: getPictures(),

小编:扫帚星狂飙

async 函数与 Promise、Generator 函数同样,是用来取代回调函数、化解异步操作的一种办法。它实质上是 Generator 函数的语法糖。async 函数并不属于 ES6,而是被列入了 ES7。

```

.then(JSON.parse)

.timeout(int ms [, String message]) -> Promise

  1. bind

});

Promise.map(fileNames, function(fileName) {

有了 Promise 对象,就足以将异步操作以同步操作的流程说明出来,防止了少有嵌套的回调函数。另外,Promise 对象提供联合的接口,使得调控异步操作更是轻便。

}).then(function(result) {

map(..., {concurrency: 1});

$ sync && echo 3 > /proc/sys/vm/drop_caches

然则,那有相当多的分化,

Promise.reject(new Error("什么鬼"));

var scope = {};

  1. .reduce(Function reducer [, dynamic initialValue]) -> Promise

```

Promise.reduce(["file1.txt", "file2.txt", "file3.txt"], function(total, fileName) {

ASYNC

tweets: getTweets()

var promise = new Promise(function(resolve, reject) {

comments: getComments(),

```

var fileNames = ["file1.json", "file2.json"];

2015 年 6 月,ECMAScript 6 的正规版到底发布了。

});

版权声明:本文由彩民之家高手论坛发布于前端知识,转载请注明出处:Promise彩民之家高手论坛