每日JavaScript - 5

上文的GitHub仓库所有简单题目已经做完，余下的数据结构题目等我有时间再整理写出来。
今天在掘金看到FEWT的文章 https://juejin.im/post/5bd697cfe51d454c791cd1d5
这些题目都是关于Promise的知识，其中一道红绿灯在我之前博文有提到。
题1

const promise = new Promise((resolve, reject) => {
    console.log(1);
    resolve();
    console.log(2);
})

promise.then(() => {
    console.log(3);
})

console.log(4);

思路：Promise会顺序执行console.log(1);和console.log(2);，因为then()是异步执行（microtask)，所以先console.log(4);最后才console.log(3);。
题2

const promise = new Promise((resolve, reject) => {
    resolve('success1');
    reject('error');
    resolve('success2');
});

promise.then((res) => {
    console.log('then:', res);
}).catch((err) => {
    console.log('catch:', err);
})

首先坦言， 我做错这题，没理解到Promise的状态转换。下面先贴出原题解释
解析
resolve 函数将 Promise 对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；
reject 函数将 Promise 对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
而一旦状态改变，就不会再变。
所以 代码中的reject(‘error’); 不会有作用。
Promise 只能 resolve 一次，剩下的调用都会被忽略。
所以 第二次的 resolve(‘success2’); 也不会有作用。
总结：状态只能单向改变而且只从改变一次，所以resolve函数一次或者reject函数一次。
题3

Promise.resolve(1)
  .then(2)
  .then(Promise.resolve(3))
  .then(console.log)

Promise.resolve 方法的参数如果是一个原始值，或者是一个不具有 then 方法的对象，则 Promise.resolve 方法返回一个新的 Promise 对象，状态为resolved，Promise.resolve 方法的参数，会同时传给回调函数。
then 方法接受的参数是函数，而如果传递的并非是一个函数，它实际上会将其解释为 then(null)，这就会导致前一个 Promise 的结果会穿透下面。
总结：上面解析很详细，耐心看几遍应该会懂。
题4

const first = () => (new Promise((resolve, reject) => {
    console.log(3);
    let p = new Promise((resolve, reject) => {
        console.log(7);
        setTimeout(() => {
            console.log(5);
            resolve(6);
        }, 0)
        resolve(1);
    });
    resolve(2);
    p.then((arg) => {
        console.log(arg);
    });

}));

first().then((arg) => {
    console.log(arg);
});
console.log(4);

首先顺序执行console.log(3);，console.log(7)。遇到 resolve(1);，添加进micro task。然后遇到定时器中的console.log(5)和resolve(6)，将其添加进macro task,添加进遇到 resolve(2);再添加进 resolve(2）;再执行console.log(4)。
首先micro task先执行resolve(1)，再执行resolve(2).
最后macro task执行console.log(5),但resolve(6)不会再执行，因为Promise状态已经改变。
题5
实现 mergePromise 函数，把传进去的数组按顺序先后执行，并且把返回的数据先后放到数组 data 中。

const timeout = ms => new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve();
    }, ms);
});

const ajax1 = () => timeout(2000).then(() => {
    console.log('1');
    return 1;
});

const ajax2 = () => timeout(1000).then(() => {
    console.log('2');
    return 2;
});

const ajax3 = () => timeout(2000).then(() => {
    console.log('3');
    return 3;
});

const mergePromise = ajaxArray => {
    // 在这里实现你的代码

};

mergePromise([ajax1, ajax2, ajax3]).then(data => {
    console.log('done');
    console.log(data); // data 为 [1, 2, 3]
});

// 要求分别输出
// 1
// 2
// 3
// done
// [1, 2, 3]

若是简单的顺序执行ajax1，ajax2，ajax3，并不会按顺序输出，如下代码

function A() {
    setTimeout(function () {
        console.log('a');
    }, 3000);
}

function B() {
    setTimeout(function () {
        console.log('b');
    }, 1000);
}

A();
B();

// b
// a

这应该实际到macro task里面的setTimeout执行机制，为了和我们想象中的顺序输出，可以使用Promise进行控制。
下面是原作者的代码：

// 保存数组中的函数执行后的结果
var data = [];

// Promise.resolve方法调用时不带参数，直接返回一个resolved状态的 Promise 对象。
var sequence = Promise.resolve();

ajaxArray.forEach(function (item) {
    // 第一次的 then 方法用来执行数组中的每个函数，
    // 第二次的 then 方法接受数组中的函数执行后返回的结果，
    // 并把结果添加到 data 中，然后把 data 返回。
    sequence = sequence.then(item).then(function (res) {
        data.push(res);
        return data;
    });
})

// 遍历结束后，返回一个 Promise，也就是 sequence， 他的 [[PromiseValue]] 值就是 data，
// 而 data（保存数组中的函数执行后的结果） 也会作为参数，传入下次调用的 then 方法中。
return sequence;

这题答案有点儿巧妙，首先是

// Promise.resolve方法调用时不带参数，直接返回一个resolved状态的 Promise 对象。
var sequence = Promise.resolve();

上面代码就是我们要控制流程的Promise

  sequence = sequence.then(item).then(function (res) {
        data.push(res);
        return data;
  }

第二次的 then 方法接受数组中的函数执行后返回的结果，并把结果都添加进data数组，并返回这个数组。
注意mergePromise函数返回的sequence，也是一个Promise，他的 [[PromiseValue]] 值就是 data。所以

mergePromise([ajax1, ajax2, ajax3]).then(data => {
    console.log('done');
    console.log(data); // data 为 [1, 2, 3]
});
``
就会输出done和[1, 2 ,3]`

然后
**附加题**
哈哈，这题太难了，留给高手解答。我记录一下方便日后自己再来思考。
有 8 个图片资源的 url，已经存储在数组 urls 中（即urls = ['http://example.com/1.jpg', ...., 'http://example.com/8.jpg']），而且已经有一个函数 function loadImg，输入一个 url 链接，返回一个 Promise，该 Promise 在图片下载完成的时候 resolve，下载失败则 reject。
但是我们要求，任意时刻，同时下载的链接数量不可以超过 3 个。
请写一段代码实现这个需求，要求尽可能快速地将所有图片下载完成。

解析
题目的意思是需要我们这么做，先并发请求 3 张图片，当一张图片加载完成后，又会继续发起一张图片的请求，让并发数保持在 3 个，直到需要加载的图片都全部发起请求。
用 Promise 来实现就是，先并发请求3个图片资源，这样可以得到 3 个 Promise，组成一个数组，就叫promises 吧，然后不断的调用 Promise.race 来返回最快改变状态的 Promise，然后从数组（promises）中删掉这个 Promise 对象，再加入一个新的 Promise，直到全部的 url 被取完，最后再使用 Promise.all 来处理一遍数组（promises）中没有改变状态的 Promise。

var urls = [‘https://www.kkkk1000.com/images/getImgData/getImgDatadata.jpg’, ‘https://www.kkkk1000.com/images/getImgData/gray.gif’, ‘https://www.kkkk1000.com/images/getImgData/Particle.gif’, ‘https://www.kkkk1000.com/images/getImgData/arithmetic.png’, ‘https://www.kkkk1000.com/images/getImgData/arithmetic2.gif’, ‘https://www.kkkk1000.com/images/getImgData/getImgDataError.jpg’, ‘https://www.kkkk1000.com/images/getImgData/arithmetic.gif’, ‘https://user-gold-cdn.xitu.io/2018/10/29/166be40ccc434be0?w=600&h=342&f=png&s=122185’];
function loadImg(url) {
return new Promise((resolve, reject) => {
const img = new Image()
img.onload = function () {
console.log(‘一张图片加载完成’);
resolve();
}
img.onerror = reject
img.src = url
})
};

function limitLoad(urls, handler, limit) {
// 对数组做一个拷贝
const sequence = [].concat(urls)
let promises = [];

//并发请求到最大数
promises = sequence.splice(0, limit).map((url, index) => {
    // 这里返回的 index 是任务在 promises 的脚标，用于在 Promise.race 之后找到完成的任务脚标
    return handler(url).then(() => {
        return index
    }); 
});

// 利用数组的 reduce 方法来以队列的形式执行
return sequence.reduce((last, url, currentIndex) => {
    return last.then(() => {
        // 返回最快改变状态的 Promise
        return Promise.race(promises)
    }).catch(err => {
        // 这里的 catch 不仅用来捕获 前面 then 方法抛出的错误
        // 更重要的是防止中断整个链式调用
        console.error(err)
    }).then((res) => {
        // 用新的 Promise 替换掉最快改变状态的 Promise
        promises[res] = handler(sequence[currentIndex]).then(() => { return res });
    })
}, Promise.resolve()).then(() => {
    return Promise.all(promises)
})

}
limitLoad(urls, loadImg, 3)

/*
因为 limitLoad 函数也返回一个 Promise，所以当 所有图片加载完成后，可以继续链式调用

limitLoad(urls, loadImg, 3).then(() => {
console.log(‘所有图片加载完成’);
}).catch(err => {
console.error(err);
})
*/