Summary

Why Promises?

Hadoken code

Compared to callback:

One more reason: Trust

Problems with callbacks

1) Call the callback more than once

2) Call the callback too early

3) Don’t call the callback

4) Errors could create a synchronous reaction whereas nonerrors would be asynchronous

What Is a Promise?

A promise is a future value

Promise states

A Promise is always in one of three mutually exclusive states:

Promise standard

Promises/A+

Famous Promise libraries

Producing a Promise

constp=newPromise(function(resolve,reject){// (A)···if(···){resolve(value);// success}else{reject(reason);// failure}});

Consuming a Promise

Super rough basic usage

constpromise=returnPromise();promise.then(functionfulfilled(result){console.log(result);},functionrejected(){// handle rejected promise});

Instance methods

then()

Instance methods:then()

Always return a promise

constp=Promise.resolve(3).then(x=>{}).then(x=>{console.log(x);});pinstanceofPromise// true

Always return a promise

→ Return an empty resolved promise if there is no return

Promise.resolve(3).then(x=>{}).then(x=>{console.log(x);});

Always return a promise

→ If a normal result is returned, it is returned as a resolved promise

Promise.resolve(3).then(x=>{return4;}).then(x=>{console.log(x);// 4});

// same as code aboveconstp=Promise.resolve(3).then(x=>{return4;});// p contains a resolved promise with the value 4p.then(x=>{console.log(x);// 4});

Always return a promise

→ A fulfilled or rejected promise can be returned as well

Promise.resolve(3).then(x=>{returnPromise.resolve(4);}).then(x=>{console.log(x);});Promise.resolve(3).then(x=>{returnPromise.reject('ooops');}).then(x=>{console.log(x);}).catch(e=>{console.log(e);});

Always return a promise

→ if an exception is thrown returns a rejected promise with the value

Promise.resolve(3).then(x=>{thrownewError(‘omg’);return4;}).then(x=>{console.log(x);},e=>{console.log(e);});

Instance methods:catch()

catch() is simply a more convenient alternative to callingthen()

promise.then(null,error=>{/* rejection */});

promise.catch(error=>{/* rejection */});

Instance methods:done() ?

Static methods:Promise.all()

Promise.all([asyncFunc1(),asyncFunc2()]).then((results)=>{···}).catch(err=>{// Receives first rejection among the Promises···});

constfileUrls=['http://example.com/file1.txt','http://example.com/file2.txt',];constpromisedTexts=fileUrls.map(httpGet);Promise.all(promisedTexts).then(texts=>{for(consttextoftexts){console.log(text);}}).catch(reason=>{// Receives first rejection among the Promises});

Static methods:Promise.race()

Promise.race([httpGet('http://example.com/file.txt'),delay(5000).then(function(){thrownewError('Timed out')});]).then(text=>{  ...}).catch(reason=>{// Receives first rejection among the Promises});

Static methods:Promise.resolve(x)

Returns a Promise that is fulfilled withx.

x can be:

Promise.resolve('abc').then(x=>console.log(x));// abc

constp=newPromise(()=>null);console.log(Promise.resolve(p)===p);// true

Static methods:Promise.reject(err)

constmyError=newError('Problem!');Promise.reject(myError).catch(err=>console.log(err===myError));// true

varp1=newPromise(function(resolve,reject){reject('Oops');});varp2=Promise.reject('Oops');

Promise limitations

Sequence error handling

// `foo(..)`, `STEP2(..)` and `STEP3(..)` are// all promise-aware utilitiesvarp=foo(42).then(STEP2).then(STEP3);p.catch(handleErrors);

Single value

Promise.resolve(3).then(x=>{return[1,2];}).then(function(msgs){constx=msgs[0];consty=msgs[1];console.log(x,y);});

Promise.resolve(3).then(x=>{return{a:1,b:2};}).then(x=>{consta=x.a;constb=x.b;console.log(a,b);});

Promise.resolve(3).then(x=>{return[1,2];}).then(([x,y])=>{console.log(x,y);});

Promise.resolve(3).then(x=>{return{a:1,b:2};}).then(({ a, b})=>{console.log(a,b);});

Promise uncancelable

Compatibility Promises/callbacks in libraries

Many libraries have implemented compatibility with both Promises and callbacks.

Example: Node.js MongoDB Driver API

collection.find().toArray((err,docs)=>{if(err){// err handling}console.log(docs):});

collection.find().toArray().then(docs=>{console.log(docs);},err=>{// err handling});

Quizes

Log Order?

constp=Promise.resolve()p.then(functiona(){p.then(functionc(){console.log('C');});console.log('A');});console.log('D');p.then(functionb(){console.log('B');});console.log('F');

What is logged? (Part 1)

constdoSomethingElse=()=>{returnPromise.resolve('hola');};constfinalHandler=(message)=>{console.log(message);};

Promise.resolve().then(()=>{returndoSomethingElse();}).then(finalHandler);

What is logged? (Part 2)

constdoSomethingElse=()=>{returnPromise.resolve('hola');};constfinalHandler=(message)=>{console.log(message);};

Promise.resolve().then(()=>{doSomethingElse();}).then(finalHandler);

What is logged? (Part 3)

constdoSomethingElse=()=>{returnPromise.resolve('hola');};constfinalHandler=(message)=>{console.log(message);};

Promise.resolve().then(doSomethingElse()).then(finalHandler);

What is logged? (Part 4)

constdoSomethingElse=()=>{returnPromise.resolve('hola');};constfinalHandler=(message)=>{console.log(message);};

Promise.resolve().then(doSomethingElse).then(finalHandler);

What is the difference?

Promise.resolve('hola').then(functionfulfilled(msg){msg.type.error;console.log(msg);},functionrejected(err){console.log('caught error:',err);});

Promise.resolve('hola').then(functionfulfilled(msg){msg.type.error;console.log(msg);}).catch(functionrejected(err){console.log('caught error:',err);});

Sources

>　　　　　Thank you!

>