let const

  1. 暂存死区：在当前作用域内定义了变量，同名变量则不会去外层查找

    1. let a = 1
    2. {
    3. console.log('a', a) // 报错
    4. let a = 2
    5. }

    解构赋值

  2. 解构对象中的关键字时需要定义别名，否则会报错

    1. let { default: d } = { default: 1 }

    模板字符串 ```javascript const name = ‘jack’ const age = ‘27’ let str = ‘hello-${name}, you are${age}years old’; // 原生实现 str = str.replace(/\${([^}]*)}/g, function() { return eval(arguments[1]) })

// 自定义模板 const name = ‘jack’ const age = ‘27’ function ja() { let strs = arguments[0] // 字符串合集 let vars = [].slice.call(arguments, 1) // 变量合集 let str = ‘’ vars.forEach((v, i) => { str += ${strs[i]}*${vars[i]}* }) str += strs[strs.length - 1] return str } let str = jahello-${name}, you are${age}years old; console.log(‘str’, str) // hello-jack, you are27years old

  1. 箭头函数
  3. 1. 箭头函数简化了函数写法，没有function关键字
  4. 1. 箭头函数没有this，也没有arguments
  5. 1. 解决this的问题，this由作用域向上查找
  6.    1. var that = this
  7.    1. bind(this)、call、apply会执行
  8. ```javascript
  9. // 取剩余参数
  10. function fn() {
  11.   // return [].slice.call(arguments, 1)
  12.   return Array.prototype.slice.call(arguments, 1)
  13. }
  14. let fn2 = (...arguments) => {
  15.   return arguments.slice(1)
  16. }
  17. console.log(fn('x',1,2,3,4))

数组方法

  1. reduce

    1. // 求和
    2. let res = [1,2,3,4].reduce((perv, next, currIndex, arr) => {
    3. return perv + next
    4. })
    5. let res_two = [{num: 10}, {num:20}, {num: 30}].reduce((perv, next, currIndex, arr) => {
    6. return perv + next.num
    7. }, 0)

  2. from：将类数组转换为数组

    1. htmlCollection、arguments、{ 0：1，1：2，2：3，length:3 }

对象方法

  1. assign：也是浅拷贝
  2. setPrototypeOf(obj1, obj2)：设置obj1的原型为obj2
    1. 等同于ES5的 obj1.proto = obj2
  3. getPrototypeOf(obj1)：获取原型
    1. 等同于ES5的 obj1.proto

  4. super关键字获取到父属性

    1. let obj2 = { name: 'jack' }
    2. let obj1 = {
    3. name: 'rose',
    4. getPName() {
    5.  return super.name // super关键字指代原型
    6. },
    7. __proto__: obj2
    8. }
    9. console.log(obj1.getPName()) // jack

    Promise

  5. 异步流程控制手段，解决异步流程问题

  6. generator aysnc await都是基于Promise
  7. koa axios redux-saga fetch都是基于Promise

  8. Promise相关方法

    1. Promise只有一个参数：excutor执行器，默认new时就会调用
    2. Promise对象一共有三个状态：pending,fulfilled,rejected，从pending状态到任何一种状态则不会再发生改变
    3. Promise catch：捕获三种异常：其对象的错误具有冒泡性质，会一直向后传递，直到catch捕获
      1. Promise 状态未固定时，执行期间的错误
      2. Promise reject 所抛出的错误
      3. Promise 成功回调执行中的错误
    4. Promise.then：异步调用，指定对象状态变为 fulfilled 时的回调，then 的第二个参数也可以为捕获错误的函数，一个Promise可以then多次
    5. Promise finally：不取决于对象的状态，只要实例的成功或错误回调执行，则会执行finally
    6. Promise all：将多个Promise实例，包装返回成一个新的Promise实例，只有全部完成，或有一个发生错误时才会调用
    7. Promise race：与 all 类似，接收一个对象集，只返回最快成功的结果
    8. Promise resolve：将非对象转换为 Promise 对象，参数接收：字符串，对象，空，Promise
    9. Promise reject：将非对象转换为 Promise 对象，返回reject的状态
    10. Promise中返回的是一个普通值就会走到then中的成功回调，函数默认返回undefined，有错误就会走失败的回调 ```javascript class Promise { constructor(executor) { this.status = ‘pending’ this.value = undefined this.reson = undefined let resolve = value => { if (this.status === ‘pending’) { this.status = ‘resolved’ this.value = value } } let reject = reason => { if (this.status === ‘pending’) { this.status = ‘rejected’ this.reason = reason } } executor(resolve, reject) }

    then(onFulfilled, onRejected) { if (this.status === ‘resolved’) { onFulfilled(this.value) } if (this.status === ‘rejected’) { onRejected(this.reason) } } }

module.exports = Promise

  1. <a name="CLq81"></a>
  2. ## Object.defineProperty
  3. ```javascript
  4. let obj = { a: 1 }
  5. Object.defineProperty(obj, 'b', {
  6.   value: 2,
  7.   configurable: false, // 是否可以修改属性配置
  8.   writable: false,     // 配置属性值才能更改
  9.   enumerable: false,   // 属性是否可枚举
  10.   get: undefined,
  11.   set: undefined,
  12. })
  13. for (const key in obj) {
  14.   console.log('key: ', key) // a
  15. }
  16. obj.b = 3 // obj.b => 2