1.ES6 对于数组,字符串的扩展

（1）字符串：

模板字符串 [ `${变量}` ]
字符串复制 [‘abc’.repeat(2) // abcabc ]
查找返回布尔值 [‘smile’.includes(‘sm’) // true]
判断开头位置，返回布尔值 [ ‘smile’.startWith(‘s’) // true ]
判断结尾的位置，返回布尔值 [ ‘smile’.startWith(‘e’) // true ]

（2）数组：

Array.of() 创建数组
Array.from() 将类数组和iterable对象转换成数组
array.find(cakkback) 返回符合的元素，没有就返回undefined
array.findIndex(callback) 返回元素下标,没有返回 -1
array.fill(value, start, end) 将一个固定值替换数组的元素
array.filter(function(currentValue,index,arr), thisValue) 创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素

 

2. 箭头函数使用需要注意的地方

（1）在使用=>定义函数的时候，this的指向是定义时所在的对象，而不是使用时所在的对象
（2）不能够用作构造函数，这就是说，不能够使用new命令，否则就会抛出一个错误；
（3）不能够使用arguments对象
（4）不能使用yield命令

 

3. 以下代码依次输出的内容是？

setTimeout(function () {console.log(1)
}, 0);
new Promise(function executor(resolve) {console.log(2);for (var i = 0; i < 10000; i++) {i == 9999 && resolve();}console.log(3);
}).then(function () {console.log(4);
});
console.log(5);// 答案：2 3 5 4 1

4. 分析下列程序代码，得出运行结果，解释其原因

const promise = new Promise((resolve, reject) => {console.log(1)resolve()console.log(2)
})
promise.then(() => {console.log(3)
})
console.log(4)// 答案： 1 2 4 3

 

5. 分析下列程序代码，得出运行结果，解释其原因

const promise1 = new Promise((resolve, reject) => {setTimeout(() => {resolve('success')}, 1000)
})
const promise2 = promise1.then(() => {throw new Error('error!!!')
})console.log('promise1', promise1)  
console.log('promise2', promise2) setTimeout(() => {console.log('promise1', promise1)console.log('promise2', promise2)
}, 2000)// promise1 promise2 error promise1 promise2

6. 分析一下代码，并得出运行结果，解释其原因：

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)
})// 答案：then：success1

原因：构造函数中的 resolve 或 reject 只有第一次执行有效，多次调用没有任何作用，promise 状态一旦改变则不能再变。

 

7.分析一下代码，并得出运行结果，解释其原因：

Promise.resolve(1).then((res) => {console.log(res)return 2
}).catch((err) => {return 3
}).then((res) => {console.log(res)return 5;
}).then(res=>{console.log(res);
});// 答案： 1  2  5

原因：promise 可以链式调用。提起链式调用我们通常会想到通过 return this 实现，不过 Promise 并不是这样实现的。promise 每次调用 .then 或者 .catch 都会返回一个新的 promise，从而实现了链式调用。

8.分析一下代码，并得出运行结果，解释其原因：

const promise = new Promise((resolve, reject) => {setTimeout(() => {console.log('once')resolve('success')}, 1000)
})const start = Date.now()
promise.then((res) => {console.log(res, Date.now() - start)
})
promise.then((res) => {console.log(res, Date.now() - start)
})// 答案：once  success 1003   success 1003

原因：promise 的 .then 或者 .catch 可以被调用多次，但这里 Promise 构造函数只执行一次。或者说 promise 内部状态一经改变，并且有了一个值，那么后续每次调用 .then 或者 .catch 都会直接拿到该值。

9.分析一下代码，并得出运行结果，解释其原因：

Promise.resolve().then(() => {return new Error('error!!!')
}).then((res) => {console.log('then: ', res)
}).catch((err) => {console.log('catch: ', err)
})// 答案：then: Error: error!!!

原因：.then 或者 .catch 中 return 一个 error 对象并不会抛出错误，所以不会被后续的 .catch 捕获，需要改成其中一种：
return Promise.reject(new Error('error!!!'))
throw new Error('error!!!')

 

10.分析一下代码，并得出运行结果，解释其原因：

const promise = Promise.resolve().then(() => {return promise
})
promise.catch(console.error)// 答案： TypeError: Chaining cycle detected for promise #<Promise>

原因：.then 或 .catch 返回的值不能是 promise 本身，否则会造成死循环。

 

11.分析一下代码，并得出运行结果，解释其原因：

Promise.resolve(1).then(2).then(Promise.resolve(3)).then(console.log);// 答案：1 

原因：.then 或者 .catch 的参数期望是函数，传入非函数则会发生值穿透。

 

12.分析一下代码，并得出运行结果，解释其原因：

Promise.resolve().then(function success (res) {throw new Error('error')
}, function fail1 (e) {console.error('fail1: ', e)
}).catch(function fail2 (e) {console.error('fail2: ', e)
});// 答案：fail2:  Error: error

原因：.then 可以接收两个参数，第一个是处理成功的函数，第二个是处理错误的函数。.catch 是 .then 第二个参数的简便写法，但是它们用法上有一点需要注意：.then 的第二个处理错误的函数捕获不了第一个处理成功的函数抛出的错误，而后续的 .catch 可以捕获之前的错误。

 

13.分析一下代码，并得出运行结果，解释其原因：（node启动）

process.nextTick(() => {console.log('nextTick')
})
Promise.resolve().then(() => {console.log('then')
})
setImmediate(() => {console.log('setImmediate')
})
setTimeout(()=>{console.log('setTimeout')
});
console.log('end')// 答案：end  nextTick  then  setImmediate  setTimeout

原因：process.nextTick 和 promise.then 都属于 microtask，而 setImmediate 属于 macrotask，在事件循环的 check 阶段执行。事件循环的每个阶段（macrotask）之间都会执行 microtask，事件循环的开始会先执行一次 microtask。

注：

• setImmediate()

setImmediate()是将事件插入到事件队列尾部，主线程和事件队列的函数执行完成之后立即执行setImmediate指定的回调函数，和setTimeout(fn,0)的效果差不多，但是当他们同时在同一个事件循环中时，执行顺序是不定的。

• process.nextTick()

process.nextTick()方法可以在当前"执行栈"的尾部-->下一次Event Loop（主线程读取"任务队列"）之前-->触发process指定的回调函数。也就是说，它指定的任务总是发生在所有异步任务之前，当前主线程的末尾。
process.nextTick()中的回调函数执行的优先级要高于setImmediate().这里的原因在于事件循环对观察者的检查是有先后顺序的，process.nextTick()属于idle观察者，setImmediate()属于check观察者。在每一个轮循环检查中，idle观察者先于I/O观察者，I/O观察者先于check观察者。　

• 案例分析1：

process.nextTick(function A() {console.log(1);process.nextTick(function B(){console.log(2);});
});setTimeout(function C() {console.log(3');
}, 0)// 1  2  3

• 案例分析2：

setTimeout(function C() {console.log(3');
}, 0)
process.nextTick(function A() {console.log(1);process.nextTick(function B(){console.log(2);});
});// 1  2  3

• 案例分析3：

setTimeout(function C() {console.log(3');
}, 0)
process.nextTick(function A() {process.nextTick(function B(){console.log(2);});console.log(1);
});// 1  2  3

• 案例分析4：

//加入两个nextTick()的回调函数
process.nextTick(function () {console.log('nextTick延迟执行1');
});
process.nextTick(function () {console.log('nextTick延迟执行2');
})
//加入两个setImmediate()的回调函数
setImmediate(function () {console.log('setImmediate延迟执行1');//进入下次循环process.nextTick(function () {console.log("强势插入！！");});
});
setImmediate(function () {console.log("setImmediate延迟执行2");
});
console.log("正常执行");/*答案：正常执行
nextTick延迟执行1
nextTick延迟执行2
setImmediate延迟执行1
setImmediate延迟执行2
强势插入！！*/

setImmediate、process.nextTick参考文档：https://www.cnblogs.com/cdwp8/p/4065846.html