.map 函数的使用方法

array.map(function(currentValue,index,arr), thisValue)

function(currentValue, index, arr)

必须。函数，数组中的每个元素都会执行这个函数：
函数参数：

currentValue   必须。当前元素值
index  可选。当前元素的索引值
arr    可选。当前元素属于的数组对象

thisValue   可选。对象作为该执行回调使用，传递给函数，用作“this”的值。如果省略了thisValue，或者传入 null、 undefined， 那么回调函数的this 为全局对象

实例
数组中的每个元素乘以输入框指定的值，并返回新数组：

var numbers = [65, 44, 12, 4]
function multiplyArrayElement(num) {
    return num * document.getElemnentById("multiplyWith").value;
}

function myFunction() {
    document.getElementById("demo").innerHTML = numbers.map(multiplyArrayElement);
}

接口映射
从接口得到数据res：

let r = res.map(item => {
    return {
        title: item.name,
        sex: item.sex === 1? '男':item.sex === 0?'女':'保密',
        age: item.age,
        avatar: item.img
    }
})

也可以省略return：

const users=res.items.map(item => ({
    url: item.html_url,      
    img: item.avatar_url,      
    name: item.login,
    })
);

Promise 对象用于表示一个异步操作的最终状态（完成或失败），以及该异步操作的结果值。

var promise1 = new Promise(function(resolve, reject){
    setTimeout(function(){
        resolve('foo')
    }, 300)
})

promise1.then(function(value) {
  console.log(value);
  // expected output: "foo"
});

console.log(promise1);

语法

new Promise( function(resolve, reject) {...} /* executor */ );

executor

executor 是带有 resolve he reject 俩个参数函数。Promise 构造函数执行立即调用executor函数，resolve 和 reject 两个函数作为参数传递给executor （executor 函数在Promise 构造函数返回所建promise 实例对象前被调用）。resolve 和 reject 函数被调用时，分别将promise的状态改为fulfilled（完成）或rejected（失败）。executor 内部通常会执行一些异步操作，一旦异步操作执行完毕（可能成功/失败), 要么调用resolve函数来将promise状态改成fulfilled，要么调用reject函数将promise的状态改为rejected。如果在executor函数中抛出一个错误，那么该promse 状态为 rejected。
executor函数的返回值被忽略。

描述
Promise 对象是一个代理对象（代理一个值），被代理的值在Promise对象创建时可能是未知的。它允许你为异步操作的成功和失败分别绑定相应的处理方法（handlers）。这让异步方法可以像同步方法那样返回值，但并不是立即返回最终执行结果，而是一个能代表未来出现的结果的promise对象。

一个 Promise有以下几种状态:
pending: 初始状态，既不是成功，也不是失败状态。
fulfilled: 意味着操作成功完成。
rejected: 意味着操作失败。

pending 状态的 Promise 对象可能会变为fulfilled 状态并传递一个值给相应的状态处理方法，也可能变为失败状态（rejected）并传递失败信息。当其中任一种情况出现时，Promise 对象的 then 方法绑定的处理方法（handlers）就会被调用（then方法包含两个参数：onfulfilled（未完成） 和 onrejected（已拒绝），它们都是Function类型。当Promise状态为fulfilled时，调用onfulfilled方法，当Promise状态为rejected时，调用then的onrejected 方法，所以在异步操作的完成和绑定处理方法之间不存在竞争）。

MDN 的这张图就很说明了问题。

Promise.all(iterable) iterable: 翻译为可迭代的
这个方法返回一个新的promse对象，该promise对象在iterable参数对象里所有的promise对象都成功的时候才会触发成功，一旦有任何一个iterable 里面的 promise 对象失败则立即触发该promise对象的失败。这个新的promise 对象在触发成功状态以后，会把一个包含iterable里所有promise返回值的数组作为成功回调的返回值，顺序跟iterable的顺序保持一致；如果这个新的promise对象触发了失败状态，它会把iterable里第一个触发失败的promise对象的错误信息作为它的失败错误信息。Promise.all方法常被用于处理多个promise对象的状态集合。

下面这个例子很有意思

var promise1 = Promise.resolve(3);
var promise2 = 42;
var promise3 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then(function(values) {
     console.log(values);
});

我特意去翻了MDN ，说起来搞笑，用了这么久的setTimeout(resolve, 100, 'foo')

一直在用它的 前俩个参数，搞笑事情就来了，

param1, ..., paramN 可选

附加参数，一旦定时器到期，它们会作为参数传递给function

但是看了一眼貌似有浏览器兼容（这种）
备注：需要注意的是，IE9 及更早的 IE 浏览器不支持向回调函数传递额外参数(第一种语法)。如果你想要在IE中达到同样的功能,你必须使用一种兼容代码 (查看 callback arguments 一段).

https://developer.mozilla.org/zh-CN/docs/Web/API/Window/setTimeout

此方法在集合多个promise的返回结果时很有用。

完成 （Fulfillment）：
如果传入的可迭代对象为空，Promise.all 会同步地返回一个已完成（resolved）状态的promise。

也就是说默认为空也是可以进行完成的。

如果所有传入的 promise 都变为完成状态，或者传入的可迭代对象内没有 promise，
Promise.all 返回的 promise 异步地变为完成。
（兼容多条返回属性）

如果所有传入的 promise 都变为完成状态，或者传入的可迭代对象内没有 promise，
Promise.all 返回的 promise 异步地变为完成。
（兼容多条返回属性）

失败/拒绝（Rejection）：
如果传入的 promise 中有一个失败（rejected），Promise.all 异步地将失败的那个结果给失败状态的回调函数，而不管其它 promise 是否完成。

（一个失败其他全失败这么一个结果）

剩下的这个

Promise.race(iterable)

方法返回一个promise，一旦迭代器中的某个promise解决或拒绝，返回的promise 就会解决或者拒绝

例如下面这个MDN 的例子

var promise1 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 500, 'one');
});

var promise2 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 100, 'two');
});

Promise.race([promise1, promise2]).then(function(value) {
  console.log(value);
  // Both resolve, but promise2 is faster
});
// expected output: "two"

有点像连通竞速，哪个速度块，哪个就先连通了。

一个待定的Promise 只要给定的迭代中的一个promise解决或拒绝，就采用第一个promise的值作为它的值，从而异步地解析或拒绝（一旦堆栈为空）。

race 函数返回一个Promise,它将与第一个传递的promise相同的完成方式被完成。它可以是完成（resolves），也可以是失败（rejects），这要取决于第一个完成的方式是两个中的哪个？

如果传的迭代是空的，则返回的promise将永远等待。

如果迭代包含一个或多个非承诺值和/或已解决/拒绝的承诺，则 Promise.race 将解析为迭代中找到的第一个值。

以下是来自于MDN 的示例：

var p1 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 500, "one"); 
});
var p2 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 100, "two"); 
});

Promise.race([p1, p2]).then(function(value) {
  console.log(value); // "two"
  // 两个都完成，但 p2 更快
}).then(function(){
    console.log(222)
    Promise.all([p1, p2])
})

var p3 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 100, "three");
});
var p4 = new Promise(function(resolve, reject) { 
    setTimeout(reject, 500, "four"); 
});

Promise.race([p3, p4]).then(function(value) {
  console.log(value); // "three"
  // p3 更快，所以它完成了              
}, function(reason) {
  // 未被调用
});

var p5 = new Promise(function(resolve, reject) { 
    setTimeout(resolve, 500, "five"); 
});
var p6 = new Promise(function(resolve, reject) { 
    setTimeout(reject, 100, "six");
});

Promise.race([p5, p6]).then(function(value) {
  // 未被调用             
}, function(reason) {
  console.log(reason); // "six"
  // p6 更快，所以它失败了
});