async的基本用法「建议收藏」

//函数声明
async function foo() {}

//函数表达式
const foo = async function () {};

//对象的方法
let obj = { async foo() {} };
obj.foo().then(...)

//Class 的方法
class Storage {
constructor() {
    this.cachePromise = caches.open('avatars');
}
async getAvatar(name) {
    const cache = await this.cachePromise;
    return cache.match(`/avatars/${name}.jpg`);
}
}

const storage = new Storage();
storage.getAvatar('jake').then(…);

//箭头函数
const foo = async () => {};

//正常返回值
async function f(){
    retrun 'hello world';
}

f().then(v => console.log(v));//hello world

//抛出错误
async function f(){
    throw new Error('出错了');
}

f().then(
    v => console.log(v),
    e => console.log(e) //Error: 出错了
)

[rv] = await expression（expression可以是任何值，通常是一个promise）

//generator写法
var gen = function* () {
  var f1 = yield readFile('/etc/fstab');
  var f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

//async写法
var asyncReadFile = async function () {
  var f1 = await readFile('/etc/fstab');
  var f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

let fooPromise = getFoo();
let barPromise = getBar();
let foo = await fooPromise();
let bar = await barPromise();

let [foo,bar] = await Promise.all([getFoo(),getBar()]);

async function dbFuc(db) {
  let docs = [{}, {}, {}];
  // 报错，forEach的function是非async，不能使用await
  docs.forEach(function (doc) {
    await db.post(doc);
  });
}

//这里不需要 async
function dbFuc(db) { 
  let docs = [{}, {}, {}];
  // 可能得到错误结果，这样调用也不能得到正确的结果
  docs.forEach(async function (doc) {
    await db.post(doc);
  });
}

//for of
async function dbFuc(db) {
  let docs = [{}, {}, {}];

  for (let doc of docs) {
    await db.post(doc);
  }
}

//map + Promise.all
async function dbFuc(db) {
  let docs = [{}, {}, {}];
  let promises = docs.map((doc) => db.post(doc));

  let results = await Promise.all(promises);
  console.log(results);
}

//map + for of
async function dbFuc(db) {
  let docs = [{}, {}, {}];
  let promises = docs.map((doc) => db.post(doc));

  let results = [];
  for (let promise of promises) {
    results.push(await promise);
  }
  console.log(results);
}

//for循环中去请求网页，若await操作成功，会break退出；若失败，会catch捕获，进入下一轮循环
const superagent = require('superagent');
const NUM_RETRIES = 3;

async function test() {
  let i;
  for (i = 0; i < NUM_RETRIES; ++i) {
    try {
      await superagent.get('http://google.com/this-throws-an-error');
      break;
    } catch(err) {}
  }
  console.log(i); // 3
}

test();

async function myFunction() {
    try {
        await somethingThatReturnsAPromise();
    } catch (err) {
        console.log(err);
    }
}

async function myFunction() {
    await somethingThatReturnsAPromise().catch((err)=> {
            console.log(err);
    })
}

async function myFunction() {
    try{
        await somethingThatReturnsAPromise();
    }
    catch(e){}
    await somethingElse();
}

// 存值
createData(title, successBack, errorBack) {
    // 使用key保存数据
    storage.save({
        key: title,   
        data: 'true',
    }).then(successBack(), errorBack());
}

//存值
async createData1(title, successBack, errorBack) {
    try {
        // 使用key保存数据
        await storage.save({
            key: title,  
            data: 'true',
        });
        successBack()
    } catch (e) {
        errorBack()
    }
}

async function fn(){}
//等同于
function fn(){
    return spawn(function* (){

    })
}

function spawn(genF) {
    /****
    * 返回的是一个promise
    */
    return new Promise(function(resolve, reject) {
        var gen=genF(); //运行Generator这个方法；
        /***
        * 执行下一步的方法
        * @param fn 一个调用Generator方法的next方法
        */
        function step(fn) {
            //如果有错误，则直接返回，不执行下面的await
            try {
            var next=fn();
            }catch (e){
            return reject(e)
            }
            //如果下面没有yield语句，即Generator的done是true
            if(next.done){
            return resolve(next.value);
            }
            Promise.resolve(next.value).then((val)=>{
                step(function(){ return gen.next(val) } )
            }).catch((e)=>{
                step(function(){ return gen.throw(e) } )
            })
        }
        step(function () {
            return gen.next();
        })
    });
}