简答题
一、谈谈你是如何理解 JS 异步编程的，EventLoop、消息队列都是做什么的，什么是宏任务，什么是微任务？
-
JS异步编程JavaScript语言的执行环境是单线程的，一次只能执行一个任务，多任务需要排队等候，这种模式可能会阻塞代码，导致代码执行效率低下。为了避免这个问题，出现了异步编程。一般是通过callback回调函数、事件发布/订阅、Promise等来组织代码，本质都是通过回调函数来实现异步代码的存放与执行 -
EventLoop事件环和消息队列EventLoop是一种循环机制 ，不断去轮询一些队列 ，从中找到需要执行的任务并按顺序执行的一个执行模型。消息队列 是用来存放宏任务的队列， 比如定时器时间到了， 定时间内传入的方法引用会存到该队列，
ajax回调之后的执行方法也会存到该队列。EventLoop.jpg一开始整个脚本作为一个宏任务执行。执行过程中同步代码直接执行，宏任务等待时间到达或者成功后，将方法的回调放入宏任务队列中，微任务进入微任务队列。
当前主线程的宏任务执行完出队，检查并清空微任务队列。接着执行浏览器
UI线程的渲染工作，检查web worker任务，有则执行。然后再取出一个宏任务执行。以此循环...
-
宏任务与微任务
宏任务可以理解为每次执行栈执行的代码就是一个宏任务（包括每次从事件队列中获取一个事件回调并放到执行栈中执行）。
浏览器为了让
JS内部宏任务 与DOM操作能够有序的执行，会在一个宏任务执行结束后，在下一个宏任务执行开始前，对页面进行重新渲染。宏任务包含：
script(整体代码)、setTimeout、setInterval、I/O、UI交互事件、MessageChannel等微任务可以理解是在当前任务执行结束后需要立即执行的任务。也就是说，在当前任务后，在渲染之前，执行清空微任务。
所以它的响应速度相比宏任务会更快，因为无需等待
UI渲染。微任务包含：
Promise.then、MutaionObserver、process.nextTick(Node.js环境)等
代码题
一、将下面异步代码使用 Promise 的方式改进
setTimeout(function () {
var a = 'hello';
setTimeout(function () {
var b = 'lagou';
setTimeout(function () {
var c = 'I ❤ U';
console.log(a + b + c);
}, 10);
}, 10);
}, 10);
参考代码：
// 第一种
new Promise(resolve => {
var a = 'hello'
resolve(a); // 将 pending状态的值改成 成功状态,并且将a传给下一个 promise的resolve作为参数
}).then(resA => {
var b = 'lagou'
return resA + b; // 将resA+b的结果传给下一个 promise的resolve作为参数
}).then(resB => {
var c = 'I ❤ U';
console.log(resB + c);
})
// 第二种
async function showStr() {
let a = await Promise.resolve('hello');
let b = await Promise.resolve('lagou');
let c = await Promise.resolve('I ❤ U')
console.log(a + b + c);
}
showStr();
// 第三种
function promise(str) {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(str);
}, 10);
})
}
async function showStr() {
let a = await promise('hello');
let b = await promise('lagou');
let c = await promise('I ❤ U');
console.log(a + b + c)
}
showStr();
// 第四种
Promise.resolve('hello')
.then((value) => {
return value + 'logou';
})
.then((value) => {
return value + 'I ♥ U';
})
.then((value) => console.log(value));
二、基于以下代码完成下面的四个练习
const fp = require('lodash/fp');
// 数据：horsepower 马力，dollar_value 价格，in_stock 库存
const cars = [
{ name: 'Ferrari FF', horsepower: 660, dollar_value: 700000, in_stock: true },
{ name: 'Spyker C12 Zagato', horsepower: 650, dollar_value: 648000, in_stock: false },
{ name: 'Jaguar XKR-S', horsepower: 550, dollar_value: 132000, in_stock: false },
{ name: 'Audi R8', horsepower: 525, dollar_value: 114200, in_stock: false },
{ name: 'Aston Martin One-77', horsepower: 750, dollar_value: 1850000, in_stock: true },
{ name: 'Pagani Huayra', horsepower: 700, dollar_value: 1300000, in_stock: false }
];
练习1：使用组合函数 fp.flowRight() 重新实现下面这个函数
let isLastInStock = function (cars) {
// 获取最后一条数据
let last_car = fp.last(cars);
// 获取最后一条数据的 in_stock 属性值
return fp.prop('in_stock', last_car);
}
先定义获取最后一条数据的函数，再定义获取某个对象中的 in_stock 属性的函数，再用
fp.flowRight组合函数
let isLastInStock = fp.flowRight(fp.prop('in_stock'), fp.last);
console.log(isLastInStock(cars)); // false
/*
我的写法
flowRight从右向左依次执行函数，并将上一个函数返回的结果当作下一个函数的参数,最后会返回一个函数
*/
let isLastInStock = cars => fp.flowRight(fp.prop('in_stock'), fp.last)(cars);
console.log(isLastInStock(cars)); // false
练习2：使用 fp.flowRight()、fp.prop() 和fp.first() 获取第一个 car 的 name
先定义获取第一条数据的函数，再定义获取某个对象中的
name属性的函数，再用fp.flowRight组合函数
const getFirstName = fp.flowRight(fp.prop("name"), fp.first)
console.log(getFirstName(cars)) // Ferrari FF
// 我的写法
let getFirstName = cars => fp.flowRight(fp.prop('name'), fp.first)(cars);
console.log(getFirstName(cars)) // Ferrari FF
练习3：使用帮助函数_average 重构 averageDollarValue，使用函数组合的方式实现
let _average = function (xs) {
return fp.reduce(fp.add, 0, xs) / xs.length;
} // <-- 无须改动
let averageDollarValue = cars => {
let dollar_values = fp.map(function (car) {
return car.dollar_value;
}, cars);
return _average(dollar_values);
}
先定义获取某个对象中的
dollar_value属性的函数，将该函数作为fp.map的数组元素处理函数，再用fp.flowRight组合函数
let averageDollarValue = fp.flowRight(_average, fp.map('dollar_value'));
console.log(averageDollarValue(cars)); // 790700
/*
我的写法
将fp.map中每个值中的dollar_value组成一个新数组当作参数传给_average这个函数
*/
let averageDollarValue = cars => fp.flowRight(_average, fp.map(car => car.dollar_value))(cars);
console.log(averageDollarValue(cars)); // 790700
练习4：使用 flowRight 写一个 sanitizeNames() 函数，返回一个下划线连续的小写字符串，把数组中的 name 转换为这种形式，例如：sanitizeNames(["Hello World"]) => ["hello_world"])
// 将全局匹配中所有非 数字 字母 下划线的 转换为_
let _underscore = fp.replace(/\W+/g, '_'); // <-- 无须改动，并在 sanitizeNames 中使用它
先定义获取某个对象中的
name属性的函数，再定义转化为小写的函数，再将空格和下划线替换，,再用fp.flowRight组合函数
let sanitizeNames = fp.flowRight(
fp.map(_underscore),
fp.map(fp.toLower),
fp.map(car => car.name)
);
console.log(sanitizeNames(CARS));
/*
[
'ferrari_ff',
'spyker_c12_zagato',
'jaguar_xkr_s',
'audi_r8',
'aston_martin_one_77',
'pagani_huayra'
]
*/
/*
我的写法
这题理解错题意了，我以为是将自己给定的数组里面的值转换
全部转换为小写,然后用replace方法转换为_
*/
let sanitizeNames = array => fp.map(fp.flowRight(_underscore,fp.toLower))(array);
console.log(sanitizeNames(['Hello World']));
三、基于下面提供的代码，完成后续的四个练习
// support.js
class Container {
static of (value) {
return new Container(value);
}
constructor(value) {
this._value = value;
}
map(fn) {
return Container.of(fn(this._value));
}
}
class Maybe {
static of (x) {
return new Maybe(x)
}
isNothing() {
return this._value === null || this._value === undefined;
}
constructor(x) {
this._value = x;
}
map(fn) {
return this.isNothing() ? this : Maybe.of(fn(this._value));
}
}
module.exports = {
Maybe,
Container
};
练习1：使用 fp.add(x, y) 和 fp.map(f,x) 创建一个能让 functor 里的值增加的函数 ex1
const fp = require('lodash/fp')
const { Maybe, Container } = require('./support');
let maybe = Maybe.of([5,6,1])
let ex1 = () => {
// 你需要实现的函数...
}
函子对象的
map方法可以运行一个函数对值进行处理，函数的参数为传入of方法的参数；接着对传入的整个数组进行遍历，并对每一项执行fp.add方法
let ex1 = maybe.map(i => fp.map(fp.add(1), i))
console.log(ex1) // [6, 7, 2]
// 我的方法
let ex1 = (num) => {
// 需要实现的函数
return maybe.map(fp.map(x => fp.add(x,num)))._value;
}
console.log(ex1(1)); // [6, 7, 2]
练习2：实现一个函数 ex2，能够使用 fp.first获取列表的第一个元素
const fp = require('lodash/fp')
const { Maybe, Container } = require('./support')
let xs = Container.of(['do', 'ray', 'me', 'fa', 'so', 'la', 'ti', 'do'])
let ex2 = () => {
// 你需要实现的函数。。。
}
解答如下：
let ex2 = xs.map(i => fp.first(i))
console.log(ex2) // do
// 我的方法
let ex2 = () => xs.map(fp.first)._value;
console.log(ex2()) // do
练习3：实现一个函数 ex3，使用 safeProp 和 fp.first 找到 user 的名字的首字母
const fp = require('lodash/fp')
const { Maybe, Container } = require('./support')
let safeProp = fp.curry(function(x, o){
return Maybe.of(o[x])
})
let user = { id: 2, name: 'Albert' }
let ex3 = () => {
// 你需要实现的函数。。。
}
调用
ex3函数传入user对象，safeProp是经过柯里化处理的，可以先传“属性”参数，后传“对象”参数。safeProp函数处理后返回user的值，再调用fp.first获取首字母
let ex3 = fp.flowRight(fp.map(i => fp.first(i)), safeProp('name'))
console.log(ex3(user)) // A
// 或者 return safeProp("name", user).map(x => fp.first(x));
// 我的方法
let ex3 = (user) => {
// 你需要实现的函数
return fp.first(safeProp('name')(user)._value);
}
console.log(ex3(user)); // A
练习4：使用 Maybe 重写 ex4，不要有 if 语句
const fp = require('lodash/fp')
const { Maybe, Container } = require('./support')
let ex4 = function(n){
if(n){
return parseInt(n)
}
}
MayBe函子用来处理外部的空值情况，防止空值的异常，拿到函子的值之后进行parseInt转化
let ex4 = n => Maybe.of(n).map(parseInt);
console.log(ex4('1')); // 1
// 我的写法
let ex4 = n => fp.flowRight(fp.first,fp.map(parseInt),Maybe.of)(n);
四、手写实现 MyPromise 源码
要求：尽可能还原 Promise 中的每一个 API，并通过注释的方式描述思路和原理
手把手教你实现Promise源码