JS中的Promise 使用

回调函数真正的问题在于他剥夺了我们使用 return 和 throw 这些关键字的能力。而 Promise 很好地解决了这一切。

简介：

ES6 原生提供了 Promise 对象。

所谓 Promise，就是一个对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的事件（通常是一个异步操作），并且这个事件提供统一的 API，可供进一步处理。

Promise 对象有以下两个特点：

（1）对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态：Pending（进行中）、Resolved（已完成，又称 Fulfilled）和 Rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来，它的英语意思就是「承诺」，表示其他手段无法改变。

（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise 对象的状态改变，只有两种可能：从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对 Promise 对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。

有了 Promise 对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise 对象提供统一的接口，使得控制异步操作更加容易。

Promise 也有一些缺点。首先，无法取消 Promise，一旦新建它就会立即执行，无法中途取消。其次，如果不设置回调函数，Promise 内部抛出的错误，不会反应到外部。第三，当处于 Pending 状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。

Promise 构造函数接受一个函数作为参数，该函数的两个参数分别是 resolve 方法和 reject 方法。

如果异步操作成功，则用 resolve 方法将 Promise 对象的状态，从「未完成」变为「成功」（即从 pending 变为 resolved）；

如果异步操作失败，则用 reject 方法将 Promise 对象的状态，从「未完成」变为「失败」（即从 pending 变为 rejected）。
模板

```
new Promise(function (resolve, reject) {
 resolve(someValue);
 });

写成

Promise.resolve(someValue);

例：

export async function getNick(obj) {
    return new Promise(async(resolve, reject) => {
        let nickpy = '';
        let nick = '';
        let gnick = '';
        if (obj.groupUserNick && obj.groupUserNick !== '') {
            nickpy = pinyin(obj.groupUserNick, {
                style: pinyin.STYLE_NORMAL
            });
            nick = obj.groupUserNick;
            gnick = obj.groupUserNick;
        } else {
            let info = await UserInfo.getInfo(obj.uid, false, false);
            if(info && info.baseInfo && info.baseInfo.nick){
                nickpy = pinyin(info.baseInfo.nick, {
                    style: pinyin.STYLE_NORMAL
                });
                nick = info.baseInfo.nick;
                gnick = '';
            }
        }
        resolve({
            uid: obj.uid,
            nickpy: nickpy.join(''),
            nick: nick,
            gnick: gnick,
            position: obj.position,
            join: obj.join,
            silentState: obj.silentState
        });
    });
}

进阶：

promise.all()的使用
注：处理一个 promise 的 map 集合。只有有一个失败，所有的执行都结束

  let infos = await Promise.all(group_list.map((v) => {
        return getNick(v);
    }));

export async function sortGroupMembersByAlphabet(group_list, filter) {
    filter = filter.toUpperCase();

    let infos = await Promise.all(group_list.map((v) => {
        return getNick(v);
    }));
    infos.sort((a, b) => {
        let pa = a && a.nickpy || '';
        let pb = b && b.nickpy || '';

        return pa.toUpperCase() > pb.toUpperCase();
    });

    let list = {};

    infos.forEach((v) => {
        let skip = (v === undefined);
        let py = v && v.nickpy || '';
        let nick = v && v.nick || '';
        if (!skip && filter !== '') {
            if (py.toUpperCase().indexOf(filter) === -1 && nick.toUpperCase().indexOf(filter) === -1) {
                skip = true;
            }
        }

        if (!skip) {
            let index = '#';

            if (py[0]) {
                index = py[0].toUpperCase();
                if (index < 'A' || index > 'Z') {
                    index = '#';
                }
            }

            if (list[index] === undefined) {
                list[index] = [v];
            } else {
                list[index].push(v);
            }
        }
    });

    return list;
}

总结：当需要取大量用户数据的时候，使用promise.all()来处理的时候，相当于同时去取这些数据，如果里面有一条出问题，则全部不返回。