什么是并行?什么是并发?
比如有多个任务需要处理
- 并发:一个处理器,允许交替执行任务,但是只能同时执行一个任务。
- 并行:多个处理器,同时执行多个任务
什么是generator?
可以控制函数的执行
function *foo(x) {
let y = 2 * (yield (x + 1))
let z = yield (y / 3)
return (x + y + z)
}
let it = foo(5)
console.log(it.next()) // => {value: 6, done: false}
console.log(it.next(12)) // => {value: 8, done: false}
console.log(it.next(13)) // => {value: 42, done: true}
- 当执行.next()的时候,会把yield右侧的值返回
- 当执行.next(x)的时候,会将上一个yield的值替换成x。第一个.next()不会替换(没有yeild)
- 当执行到最后一个yield或者是return时,返回的{ value: x, done: true } 表示函数执行结束
Promise
特点
- 一旦从等待状态变为其他状态后,就不能再次改变。
- Promise 是立刻执行的
new Promise((resolve, reject) => {
console.log('立刻')
resolve('成功')
})
console.log('嗯嗯')
// 输出
立刻
嗯嗯
- 链式调用
Promise.resolve(2)
.then(res => {
// 2 + 1
return res + 1
})
.then(res => return res + 4)
优点
解决回调地狱问题
await
特点
- 函数加上async后,被调用后会返回一个promise
let aa = async function A() {
}
aa()
// Promise {: undefined}
优点
- 算是解决了Promise中的各种then
- 异步函数用同步函数的写法,逻辑清晰
缺点
- 因为是将异步代码改造成同步代码,所以会造成代码冗余,性能降低(当然,忽略不计吧)
- 当多个异步代码没有前后依赖时,建议用Promise.all()
题目
第一题
let a = 0
let b = async () => {
a = a + await 10
console.log('2', a) // -> '2' 10
}
b()
a++
console.log('1', a) // -> '1' 1
- 执行b(),遇到await(await内部实现generator,generator会保存堆栈)会将堆栈保存起来,此时a = 0。
- 执行函数外的代码,a++
- 执行异步代码,a = 0 + 10
第二题(刷完宏任务微任务后再看)
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);
链接:https://juejin.im/post/5af800fe518825429c594f92
- 第一轮事件循环
先执行宏任务,主script ,new Promise立即执行,输出【3】,执行p这个new Promise 操作,输出【7】,发现setTimeout,将回调放入下一轮任务队列(Event Queue),p的then,姑且叫做then1,放入微任务队列,发现first的then,叫then2,放入微任务队列。执行console.log(4),输出【4】,宏任务执行结束。
再执行微任务,执行then1,输出【1】,执行then2,输出【2】。到此为止,第一轮事件循环结束。开始执行第二轮。 - 第二轮事件循环
先执行宏任务里面的,也就是setTimeout的回调,输出【5】。resovle不会生效,因为p这个Promise的状态一旦改变就不会在改变了。 所以最终的输出顺序是3、7、4、1、2、5。
第三题
const promise = new Promise((resolve, reject) => {
console.log(1);
resolve();
console.log(2);
})
promise.then(() => {
console.log(3);
})
console.log(4);
链接:https://juejin.im/post/5bd697cfe51d454c791cd1d5
- Promise是立刻执行函数,所以直接输出1、2(resolve并不是一个异步函数,所以这里不会等待)
- 执行同步代码,输出4
- 执行微任务、输出3
第四题
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);
})
https://juejin.im/post/5bd697cfe51d454c791cd1d5
- 状态一旦改变了,就不会再次改变
第五题
Promise.resolve(1)
.then(2)
.then(Promise.resolve(3))
.then(console.log)
- then()的参数是一个函数,如果传递的不是一个函数,则会被当成为null,然后直接穿透。知道遇到了cosole.log这个函数
- 1被当成参数传递给console.log,并执行。
第六题(没思路)
红灯三秒亮一次,绿灯一秒亮一次,黄灯2秒亮一次,意思就是3秒,执行一次 red 函数,2秒执行一次 green 函数,1秒执行一次 yellow 函数,不断交替重复亮灯,意思就是按照这个顺序一直执行这3个函数,这步可以就利用递归来实现。
function red() {
console.log('red');
}
function green() {
console.log('green');
}
function yellow() {
console.log('yellow');
}
var light = function (timmer, cb) {
return new Promise(function (resolve, reject) {
setTimeout(function () {
cb();
resolve();
}, timmer);
});
};
var step = function () {
Promise.resolve().then(function () {
return light(3000, red);
}).then(function () {
return light(2000, green);
}).then(function () {
return light(1000, yellow);
}).then(function () {
step();
});
}
step();
第七题(写的太Low,写出来的不是考察的点。)
(考点:异步函数按顺序循环)
实现 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]
链接:https://juejin.im/post/5bd697cfe51d454c791cd1d5
自己写的Low逼答案
let data = []
return new Promise(resolve => {
// 在这里实现你的代码
let [a, b, c] = ajaxArray
a()
.then(res => {
data.push(res)
return b()
})
.then(res => {
data.push(res)
return c()
})
.then(res => {
data.push(res)
resolve(data)
})
})
高玩答案
// 保存数组中的函数执行后的结果
var data = [];
// Promise.resolve方法调用时不带参数,直接返回一个resolved状态的 Promise 对象。
var sequence = Promise.resolve();
ajaxArray.forEach(function (item) {
// 第一次的 then 方法用来执行数组中的每个函数,
// 第二次的 then 方法接受数组中的函数执行后返回的结果,
// 并把结果添加到 data 中,然后把 data 返回。
// 这里对 sequence 的重新赋值,其实是相当于延长了 Promise 链
sequence = sequence.then(item).then(function (res) {
data.push(res);
return data;
});
})
// 遍历结束后,返回一个 Promise,也就是 sequence, 他的 [[PromiseValue]] 值就是 data,
// 而 data(保存数组中的函数执行后的结果) 也会作为参数,传入下次调用的 then 方法中。
return sequence;
我的总结:
整个思路应该就是,如何把then拉成一条链,比如,利用在then返回一个数值,相当于返回一个Promise,这个Promise在下一个循环时,又在后面继续添加各种then
第八题
有 8 个图片资源的 url,已经存储在数组 urls 中(即urls = ['http://example.com/1.jpg', ...., 'http://example.com/8.jpg']),而且已经有一个函数 function loadImg,输入一个 url 链接,返回一个 Promise,该 Promise 在图片下载完成的时候 resolve,下载失败则 reject。
但是我们要求,任意时刻,同时下载的链接数量不可以超过 3 个。
请写一段代码实现这个需求,要求尽可能快速地将所有图片下载完成。
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
})
};
链接:https://juejin.im/post/5bd697cfe51d454c791cd1d5
答案
题目的意思是需要我们这么做,先并发请求 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);
})
*/