es6 --- > promise和async/await的区别

首先需要了解async函数:

async是Generator函数的语法糖:

// 使用Generator依次读取两个文件
var fs = require('fs');
var readFile = function (fileName) {
    return new Promise(function (resolve, reject) {
        fs.readFile(filename, function(error, data) {
            if (error) return reject(error)
            resolve(data);
        });
    });
};

// Generator
var gen = function* () {
    var f1 = yield readFile('/etc/fatab');
    var f2 = yield readFile('/etc/shells');
    console.log(f1.toString());
    console.log(f2.toString());
};

// async
var ayncReadFile = async function () {
    var f1 = await readFile('/etc/fatab');
    var f2 = await readFile('/etc/shells');
    console.log(f1.toString());
    console.log(f2.toString());
};

// async对Generator函数做了以下4点改变:
// 1. 内置执行器:async函数自带执行器,使用方法为 asyncReadFile()
// 2. 更好的语义: async表示函数里有异步操作,await表示紧跟再后面的表达式需要等待结果
// 3. 更广的适用性:yield命令后,只能是Thunk函数或Promise对象,而async函数的await命令后面,可以是Promise对象和原始类型的值
// 4.返回值是Promise对象,可以使用then方法指定下一步操作.

// 注:async函数完全可以看作由多个异步操作包装成的一个Promise,而await命令就是内部then命令的语法糖.

async函数的用法:

// 输入name返回股票的价格
async function getStockPriceByName(name) {
    var symbol = await getStockSymbol(name);
    var stockPrice = await getStockPrice(symbol);
    return stockPrice;
}
getStockPriceByName('goog').then(function (result) {
    console.log(result);
});
// 非常同步的写法!
// 从宏观上来讲,执行getStockPriceByName后,输入名字,会得到一个stockPrice,而stockPrice是一个Promise数据结构,
// 其可以使用.then方法调用.

// async封装接口.
function timeout(ms) {
    return new Promise((resolve) => {
        setTimeout(resolve, ms);
    });
}
async function asyncPrint(value, ms) {
    await timeout(ms);
    console.log(value);
}

asyncPrint("Hello", 50);

async的语法:

// async函数返回一个Promise对象
async function f() {
    return 'hello world';
}
fn().then(v => console.log(v))

// async函数内部抛出的错误会导致返回的Promise对象变为reject状态,
async function f(){
    throw new Error('出错了');
}
f().then(
    v => console.log(v),
    e => console.log(e)
)

async的错误处理:

// 如果await后面的异步操作出错,那么等同于async函数返回的Promise对象被reject.
async function f() {
    await new Promise(function (resolve, reject) {
        throw new Error('出错了');
    });
}
f()
.then( v => console.log(v))
.catch( e => console.log(e))

// async置于try...catch代码块中
async function f() {
    try{
        await new Promise(function (resolve, reject) {
            throw new Error('出错了');
        });
    } catch (e) {
    }
    return await('hello world');
}

// 多个await命令,同一放入try...catch结构中
async function main() {
    try {
        var val1 = await firstStep();
        var val2 = await secondStep(val1);
        var val3 = await thirdStep(val1, val2);
         
        console.log('Final: ', val3);
    }
    catch (err) {
        console.error(err);
    }
}

// 使用try...catch结构,多次尝试连接获取某个url下的数据
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) {}
    }
    cosnole.log(i);    // 3
}
test();

async使用注意点:

// 1.await命令后面的Promise对象的运行结果可能是rejected,所以最好把await命令放在try...catch代码块中
// 写法一
async function myFunction() {
    try{
        await somethingThatReturnsAPromise();
    } catch (err) {
        console.log(err);
    }
}
// 写法二
async function myFunction() {
    try{
        await somethingThatReturnsAPromise()
        .catch(function(err){
            console.log(err);
        });
    }
}

// 2.多个await命令后面的异步操作如果不存在继发关系,最好让它们同时触发
// 写法一
let [foo, bar] = await Promise.all([getFoo(), getBar()]);

// 写法二
// let fooPromise = getFoo();
// let barPromise = getBar();
// let foo = await fooPromise;
// let bar = await barPromise;

// 3.await命令只能用在async函数之中,如果用在普通函数中就会报错
async function dbFunc(db) {
    let docs = [ {}, {}, {] ];
     
    // 报错
    docs.forEach(function (doc) {
        await db.post(doc);
    });
}
// 报错的原因在于,async用在普通函数function(doc)之中.
// 考虑forEach的参数改为async 函数,
function dbFunc(db) {
    let docs = [ {}, {}, {} ];
     
    docs.forEach(async function(doc) {
        await db.post(doc);
    });
}
// 注:forEach是并发执行的,因此以上还是会报错.

// 如果想继发的将doc推入db.post,可以采用for...of...
function dbFunc(db) {
    let docs = [ {}, {}, {} ];
     
    for (let doc of docs) {
        await db.post(doc);
    }
}

// 使用Promise.all 执行并发
function dbFunc(db) {
    let docs = [ {}, {}, {} ];
    let promises = docs.map( (doc) => db.post(doc));
     
    let results = Promise.all(promises);
    console.log(results);
}

// 使用for...of的 并发执行
function dbFunc(db) {
    let docs = [ {}, {}, {} ];
    let promises = docs.map( (doc) => db.post(doc));
     
    let results = [];
    for (let promise of promises) {
        results.push(promise);
    }
    console.log(results);
}

promise与async/await的区别:

// 1.错误处理:Async/await使得处理同步 + 异步成为了现实
//           在try/catch中,难以处理JSON.parse抛出的错误,原因在于,这个错误发生在Promise内部.
//           要处理以上错误,只能在Promise外面套上一层try...catch
//           async/await,后面的异步操作若出错,那么等同于async函数返回的Promise对象被reject

// Promise   try...catch
const makeRequest = () => {
    try {
         getJSON()
         .then(result => {
             const data = JSON.parse(result);
             console.log(data);
         })
    } catch (err) {
         console.log(err)
    }
}
// 使用async/await
const makeRequest = () => {
    try {
        const data =JSON.parse(await getJSON())
        console.log(data)
    } catch (err) {
        console.log(err)
    }
}	
 
// 2.条件判别 (Conditionals):根据得到的数据决定下一步操作
const makeRequest = () => {
    return getJSON()
        .then(data => {
            if ( data.needsAnotherRequest) {
                return makeAnoterReuqest(data)
                    .then(moreData => {
                        console.log(moreData)
                        return  moreData
                    })
            } else {
                console.log(data);
                return data;
            }
        })
}
// 以上就2次就嵌套得如此深,要是10次...100次......
// 使用async可以很好的写出可维护性代码
const makeRequest = () => {
    const data = await getJSON();
    if( data.needsAnotherRequest) {
        const moreData = await makeAnotherRequest(data);
        console.log(moreData)
        return moreData
    } else {
        console.log(data);
        return data;
    }
}
// 可读性和可维护性更强!

// 3.对中间的值的使用更简单]
// promise
const makeRequest = () => {
    return promise1()
        .then (value1 => {
            return promise2(value1)
                .then( value2 => {
                    return promise3 (value1, value2)
                })
        })
}

// async
const makeRequest  = () => {
    const value1 = await promise1()
    const value2 = await promise2(value1)
    const value3 = await promise3(value1, value2)
    return value3
}
// 我天,,,同步的写法,,!! 简单明了,好维护!

参考《ES6标准入门》(第3版) P375~P385
参考 ES6 Async/Await与Promise区别

es6 --- > promise和async/await的区别

猜你喜欢