ES6 面试题

新增了哪些属性？

• 新增块级作用域：let、const
• 新增数据类型：Symbol 表示独一无二的值
• 新增数据结构：
• Set，类似数组，所有数据是唯一的；
• Map，键值对的结合，传统的 Object 只能使用字符串作为键，Map 可以使用任何类型的值作为键值
• 新增箭头函数：let func = () => {}
• 新增模板字符串：用反引号表示（`）
• 新增结构赋值：按照一定模式，从数组、对象中取值，对变量进行赋值
• 新增 Promise、Async/Await 异步编程解决方案
• 新增展开运算符：...
• 模块开发：export、import
• 新增 class 类
• 新增 for...of...循环，可以遍历数组、Set、Map 结构

let、const、var 的区别？

• let 和 const 声明变量不会有变量提升，var 会出现变量提升（另外一种说法：let 变量也会提升，只不过因为暂时性的限制，不能再 let 声明变量之前使用）
• let 和 const 是块级作用于，var 是函数级作用域
• let 和 const 不允许重复声明（会抛出错误）
• let 和 const 声明变量之前使用，会抛出错误（暂时性死区）
• const 声明的是只读的常量，声明之后不可改变

你是怎么理解 Set、Map 两种数据结构的？

Set 是一种集合的数据结构，（集合：由无序且不重复的元素组成，）

Map 是一种字典的数据结构，（字典：由一些元素组成，每个元素都是[键，值]的形式）

1、Set

Set 是一种集合的数据结构，类似于数组，但是成员的值都是唯一的，没有重复的值（一般称为集合）

Set 本身是一个构造函数，用来生成 Set 数据结构

const s = new Set()

实例方法：

• add()

添加某个值，可采用链式写法

返回 Set 结构本身

s.add(1).add(2)

• delete()

删除某个值，返回一个布尔值，表示删除是否成功

s.delete(1)

• has()

检测某个元素是否存在，返回一个布尔值

s.has(1)

• clear()

清空所有元素，没有返回值

s.clear()

• size

获取集合中元素的个数

s.size

注意：基本类型的值不能重复，复杂类型的是可以重复的

let arr = [1, 2, 2, 1, { a: 1 }, { a: 1 }]
const res = [...new Set(arr)]
console.log(res)
// [1, 2, {a: 1}, {a: 1}]

2、Map

Map 是键值对的列表，键和值可以是任意类型

Map 本身是一个构造函数，用来生成 Map 数据结构

const map = new Map()

• set()

设置键值，可采用链式写法，返回整个 Map 结构

如果 key 已经有值，则键值会被更新，否则就新生成键

map.set(undefined, 'und')
map.set(1, 'a').set(2, 'b')

• get()

get 方法读取 key 对应的键值，如果找不到 key，返回 undefined

map.get(1)

• has()

has 方法监测 Map 中是否存在某个键，返回一个布尔值

map.has(1)

• delete()

delete 方法删除某个键。删除成功返回 true，失败返回 false

map.delte(1)

• clear()

clear 方法清空所有成员，没有返回值

map.clear()

• size

size 属性返回 Map 结构的成员总数

map.size

谈谈你对 Promise 的理解？

定义：

Promise 是异步编程的一种解决方案

Promise 本身是同步立即执行函数，.then是异步的

特点

• 对象的状态不受外界影响
• 一旦状态改变就不会再变

三个状态

pending（等待）、fulfilled（成功）、rejected（失败）

两个过程

resolve 函数执行时，会从 pending 变成 fulfilled

rejecte 函数执行时，会从 pending 变成 rejected

Promise 的静态方法都有哪些？

• Promise.resolve() 抛出一个成功回调，.then 捕获
• Promise.reject() 抛出一个异常回调，.catch 用于捕获处理异常
• Promise.all([promise1, promise2, promise3]) 接收一个 promise 数组，是在所有 promise 都完成后执行。可以用于处理一些并发的任务
• Promise.race([promise1, promise2, promise3]) 接受一个 promise 数组，里面哪个结果快，就返回哪个结果，不管结果本身是成功状态还是失败状态
• Promise.allSettled([promise1, promise2, promise3 ])接受一个 promise 数组，会返回一个对象数组，每个对象表示对应的 promise 结果，适用于彼此不依赖的异步任务或者想知道每个 promise 的结果时
• Promise.any([promise1, promise2, promise3]) 主要用于返回第一个成功的 promise 。只要有一个 promise 成功此方法就会终止，它不会等待其他的 promise 全部完成。

ES6新增哪些属性？

• 新增块级作用域：let、const
• 新增数据类型：Symbol 表示独一无二的值
• 新增数据结构：
• Set，类似数组，所有数据是唯一的；
• Map，键值对的结合，传统的Object只能使用字符串作为键，Map可以使用任何类型的值作为键值
• 新增箭头函数：let func = () => {}
• 新增模板字符串：用反引号表示（`）
• 新增结构赋值：按照一定模式，从数组、对象中取值，对变量进行赋值
• 新增Promise、Async/Await 异步编程解决方案
• 新增展开运算符：...
• 模块开发：export、import
• 新增class类
• 新增for...of...循环，可以遍历数组、Set、Map结构

let、const、var的区别？

• let 和 const声明的变量不会出现提升，var声明的变量会出现提升（另外一种说法：let变量也会提升，只不过因为暂时性的限制，不能再let声明变量之前使用）
• let 和 const是块级作用域，var是函数级作用域
• let 和 const不允许重复声明（会抛出错误）
• let 和 const声明变量之前使用，会抛出错误（暂时性死区）
• const 声明一个只读的常量，一旦声明，不可以改变

Symbol

表示独一无二的值

let a = Symbol(1)
let b = Symbol(1)
console.log(a === b)
// false

使用场景1

let obj = {
    // ...
}
let sym = Symbol('name')
obj[sym] = 'ada'
console.log(obj[sym])
//ada

使用场景2

let info = [
    {'小明': 50},
    {'小明': 44},
    {'阿达': 33},
]
let obj = {}
info.forEach(item => {
    let key = Object.keys(item)[0]
    let value = item[key]
    obj[Symbol(key)] = value
})
console.log(obj)
// {Symbol(小明): 50, Symbol(小明): 44, Symbol(阿达): 33}

Set 

集合里面的基本类型的值不能重复，复杂类型的值可以重复

let arr = [1, 2, 2, 1, {a: 1}, {a: 1}]
const res = [...new Set(arr)]
console.log(res)
// [1, 2, {a: 1}, {a: 1}]

静态方法：

• 添加元素：s.add() 返回值是Set结构本身
• 删除元素：s.delete() 返回一个布尔值，true删除成功，false删除失败
• 检测是否存在某个元素：s.has() 返回一个布尔值，true代表存在，false不存在
• 清除集合的元素：s.clear()
• 获取元素的个数：s.size

Promise是什么？

定义：

Promise 是异步编程的一种解决方案

Promise 本身是同步立即执行函数，.then 是异步的

特点：

1. 对象的状态不受外界影响
2. 一旦状态改变就不会再变

三个状态：

pending（等待）、fulfilled（成功）、rejected（失败）

两个过程：

resolve 函数被执行时，会从pending 变成 fulfilled 成功

rejecte 函数被执行时，会从pending 变成 rejected 失败

Promise的静态方法？

• Promise.resolve()
• Promise.reject() 抛出一个异常，.catch用于捕获处理异常
• Promise.all([promise1, promise2, promise3]) 接收一个promise数组，是在所有promise都完成后执行。可以用于处理一些并发的任务
• Promise.race([promise1, promise2, promise3]) 接受一个promise数组，里面哪个结果快，就返回哪个结果，不管结果本身是成功状态还是失败状态
• Promise.allSettled([promise1, promise2, promise3 ])接受一个promise数组，会返回一个对象数组，每个对象表示对应的promise结果，适用于彼此不依赖的异步任务或者想知道每个promise的结果时
• Promise.any([promise1, promise2, promise3]) 主要用于返回第一个成功的 promise 。只要有一个 promise 成功此方法就会终止，它不会等待其他的 promise 全部完成。

async / await 是什么？

从内部实现来说其实就是Generator的语法糖，基于Promise，并于所有现存的基于Promise的API兼容

async关键字

• async 关键字用于声明一个异步函数（如 async function test(){...}）
• async 会自动将常规函数转换成Promise，返回值也是一个Promise对象

await 关键字

• await 用于等待异步功能执行完毕 （如 let res = await test()）
• await 只能再 async 函数内部使用
• await 只能用与Promise 一起调用，await放置在Promise调用之前，会强制async函数中其他异步代码等待，直到Promise完成并返回结果

相较于Promise，async / await有何优势？

• 代码清晰，提升了代码的阅读体验 （promise虽然摆脱了回调地狱，但then链式调用的阅读负担还是存在的）
• 可以使用try / catch 进行错误处理（async / await 可以用成熟的try / catch做处理）
• 调式时的阅读性，也相对更友好（调用多个Promise，Promise链中某个地方抛出错误，不会给出错误发生的位置，不能在.then代码块中设置断点）

缺点：try..catch内部的变量无法传递给下一个try...catch

箭头函数和普通函数的区别？

• 箭头函数作为匿名函数，不能使用new 关键字
• 箭头函数不绑定this ，会捕获上下文this，作为自己的this值，任何方法都改变不了this指向，（call()，bind()，apply()）
• 箭头函数不绑定arguments，用rest参数替代

普通函数：可以使用arguments，也可以使用rest

function showArgs(a,b,c){
　　console.log(arguments[2]) // 3
}
showArgs(1,2,3)

箭头函数：不绑定arguments，es6引入rest参数（形式为...变量名）

let showArgs = (...args) => {
　　console.log(args)
}
showArgs(1,2,3,4,5)

exports, module.exports, export defaul 区别？

• exports：导出的是模块函数本身，可以有多个

  exports.func = function () {}

  引入（需要加括号）：import {func} from './test'

• module.exports：导出的是模块对象本身，当文件中出现多个，后面的module.exports会覆盖以前的

  module.exports = { func: function () {} }

  引入（可加可不加，不加就是引入模块对象本身）：import module from './test'

• export default：只能有一个

  export default function func() {console.log(1)}

  引入（不用加括号）：import func from './test'