ES6常用新特性-Toy模板网

这篇具有很好参考价值的文章主要介绍了ES6常用新特性。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

ES6改动很大，可以简单分为四类
1、解决原有语法的缺陷和不足
例如：let，const
2、对原有语法进行增强
解构、扩展、模板字符串
3、新增对象、全新的方法，全新的功能
Object.assign()、Proxy对象代理、Reflect 等等
4、全新的数据类型和数据结构
set、map、class、迭代器、生成器等等

一、解决原有语法的缺陷和不足

1、let：块级作用域，没有变量提升

用途：for循环的计数器（for循环内部let声明的变量同样拥有块级作用域）；循环事件绑定不必采用闭包形式

for (let i=0; i<3; i++) {
let i = ‘foo’
console.log(i)
}
2、const: 恒量/常量；声明后不能修改内存地址，可修改属性成员

最佳实践：不用var，主用const，配合let

二、对原有语法的增强

1、数组的解构：根据数组对应的位置提取对应的值赋给对应的变量

let arr = [1,2,3]
let [x, y, z] = arr
如果未取到对应的值，赋值“undefined”
可以用…运算符

var [x, …other] = arr
可以设置默认值

var [x=‘0’, y, z] = arr
用途：字符串截取

const str = ‘http://www.baidu.com?titile=article’
var [, strParam] = str.split(‘?’)
2、对象的解构：根据属性名提取

const obj = {name: ‘zdd’, age: 18}
const { name, age } = obj
如果想换一个变量名&添加默认值

const {name: objName=‘www’, age} = obj
应用场景：代码简化

const { log } = console
log(‘hh’)
3、模板字符串：字符串增强

1、可换行
2、可使用插值表达式添加变量，变量也可以替换为可执行的js语句：

let str = 生成一个随机数：${ Math.random() }
标签模板字符串，标签相当于一个自定义函数，自定义函数的第一个参数是被差值表达式截取的数组

// 标签模板字符串
const name = 'www';
const isMan = true
const tagFn = function (strings, name, isMan) {
  let sex = isMan ? 'man' : 'woman';
  return strings[0] + name + strings[1] + sex + strings[2]
}
const result = tagFn`hey, ${name} is a ${isMan}.`

4、字符串的扩展方法

1、includes
2、startWith
3、endsWith

5、函数参数增强：参数默认值

只有当参数为不传或传入undefined时使用默认值

const fn = function (x=1, y) {
  console.log(x)
  console.log(y)
}
fn()

6、…操作符：收起剩余数据、展开数组

收取剩余参数：取代arguments，arguments是一个类数组，…操作符是一个数组类型，可以使用数组方法
6.1、仅使用一次
6.2、放在参数最后

const fn = function (x, ...y) {
  console.log(y.slice(0))
}
fn(1,2,3,4,5)

展开数组

const spredArr = [1,2,3,4]
console.log(...spredArr)
console.log.apply(this, spredArr) //es5代替方案

7、箭头函数：简化写法

箭头函数的this指向上级作用域

const name = 'tony'
const person = {
  name: 'tom',
  say: () => console.log(this.name),
  sayHello: function () {
    console.log(this.name)
  },
  sayHi: function () {
    setTimeout(function () {
      console.log(this.name)
    }, 500)
  },
  asyncSay: function () {
    setTimeout(()=>console.log(this.name), 500)
  }
}
person.say()  //tony
person.sayHello() //tom
person.sayHi() //tony
person.asyncSay()  //tom

8、对象字面量的增强

8.1、如果key与value变量名相同，省略:value
8.2、省略函数：function
8.3、计算属性：[Math.random()]

const bar = ‘bar’
const obj = {
bar,
fn () {
console.log(‘1111’)
},
[Math.random()]: ‘123’
}
console.log(obj)

三、新增对象、全新的方法、全新的功能

1、Object.assign()：合并多个对象，第一个参数就是最终的返回值，如果对象的属性名相同，后面的覆盖前面的

用途：复制对象，给options属性赋默认值

let objA = {
  a: 'aa',
  b: 'bb'
}
let objB = {
  b: 'dd',
  c: 'ee'
}
let result = Object.assign({}, objA, objB)
result.a = 'cc'
console.log(objA, result) //{a: "aa", b: "bb"} {a: "cc", b: "dd", c: "ee"}

2、Object.is()：判断两个值是否相等，返回布尔值

用途：es5中，对于0的判断不区分正负值，-0 == +0返回true，NaN == NaN返回返回false；
Object.is()规避了这些问题

Object.is(+0, -0)//false
Object.is(NaN, NaN) //true

3、Proxy：代理对象

基本用法

const person = {
  name: 'www',
  age: '20'
}
const personProxy = new Proxy(person, {
  get(target, key) {
    return target[key] ? target[key] : 'default'
  },
  set(target, key, value) {
    target[key] = value % 2 ? value : 99
  }
})
console.log(person.xxx) // undefined
console.log(personProxy.xxx) // default
console.log(personProxy.age) //20
personProxy.age = 100
console.log(personProxy) //{name: "www", age: 99}

这里注意的一点是，这里被拦截的是”personProxy“，而不是”person“
与Object.definedProperty()的比较：
1、相比与Object.definedProperty只能监听get,set行为，proxy监听的行为更多一些，has、deleteProperty … 等很多
2、对于数组的push,pop等操作，proxy是监听的整个对象的行为，所以通过set方法能够监听到；而definedProperty需要指定该对象的属性名，对于数组来说，就是指定数组的下标，是监听不到数组的push,pop等操作的

let arr = []
let arrProperty = new Proxy(arr, {
  set (target, key, value) {
    console.log(target, key, value) //[1] "length" 1
    target[key] = value
    return true
  }
})
arrProperty.push(1)
console.log(arrProperty) //[1]

3、proxy以非侵入的方式，监听了对象的读写；definedProperty需要指定具体需要监听对象的属性名，与上面的数组类似，如果想要监听一个含有多个属性的对象的读写行为，definedProperty需要遍历这个对象的所有属性

4、Reflect：封装操作对象的统一API

在之前的es5中，操作对象有很多种方式

const obj = {
  name: '111',
  age: '22'
}
// 判断对象某个属性是否存在
console.log('name' in obj)
// 删除某个属性
console.log(delete obj['name'])
// 获取对象key
console.log(Object.keys(obj))

对于不同的操作行为，使用的方式却不同，Reflect的目的是使用同一套方式去操作对象

const obj = {
  name: '111',
  age: '22'
}
// 判断对象某个属性是否存在
console.log(Reflect.has(obj,'name'))
// 删除某个属性
console.log(Reflect.deleteProperty(obj, 'name'))
// 获取对象key
console.log(Reflect.ownKeys(obj))

5、用于处理异步，解决回调函数的地狱式嵌套问题

四、全新的数据结构和数据类型

1、class 类

es5写法

function People (name) {
  // 设置实例属性
  this.name = name;
}
// 设置实例的共享方法
People.prototype.sayHi = function () {
  console.log(this.name)
}
let p = new People('tom')
p.sayHi()

使用class更易理解，结构清晰

  class Peopel {
    constructor (name) {
      this.name = name
    }
    say () {
      console.log(this.name)
    }
  }
  const p = new Peopel('tony')
  p.say()

类的继承

  class Peopel {
    constructor (name) {
      this.name = name
    }
    say () {
      console.log(this.name)   //tom，在子类的sayAge中调用
    }
  }
  class Worker extends Peopel {
    constructor (name,age) {
      super(name)
      this.age = age
    }
    sayAge () {
      super.say()
      console.log(this)  // Worker {name: "tom", age: 18}
      console.log(this.age) // 18
    }
  }
  const p = new Worker('tom', 18)
  p.sayAge()

类的继承还是通过原型链的方式实现，具体可以看下babel转换后的代码
super可以作为函数调用，也可以作为对象调用
作为函数调用时，只能在子类的constructor中调用，此时执行父类的构造函数constructor，执行父类构造函数时，this指向的是子类Worker，所以实例p会有name属性（对于super理解的还是不够，后面要单独学习下）

2、set数据结构：可以理解为集合，不重复

  const s = new Set()
  s.add(1).add(2).add(3)
  console.log(s) //{1, 2, 3}
  console.log(s.size) // 3
  const arr = [1,2,3,2,4]
  console.log([... new Set(arr)]) //[1,2,3,4]

3、map数据结构

es5中的对象key只能是字符串，map的key可以是任意数据类型, 可以通过get,set,has等操作map

  const m = new Map()
  const tom = {name: '99'}
  m.set(tom, 90)
  console.log(m.get(tom))
  m.forEach((value, key) => {
    console.log(value, key)
  })

4、Symbol新的数据结构，唯一值

用途：防止全局对象中，某个属性名重名，产生冲突；定义私有属性，外部访问不到，且遍历不到

  const s = Symbol('描述')
  console.log(s)  
  const obj = {
    [Symbol('私有属性')]: '11'
  }
  console.log(obj)   //obj对象Symbol('私有属性')这个属性外部访问不到
  console.log(Object.keys(obj)) //[]
  console.log(Object.getOwnPropertySymbols(obj)) //[Symbol(私有属性)]

  const s1 = Symbol.for('111')
  const s2 = Symbol.for('111')
  console.log(s1 === s2) //true

5、for … of 遍历

es5中，使用for … in 遍历键值对结构数据，使用forEach遍历数组
es6中新增了set,map数据结构，for…of是用来统一遍历拥有某一种特性的数据结构（可迭代）

  const arr = [1,2,3] 
  for (const item of arr) {
    // 遍历数组
    console.log(item)
  }
  const s = new Set()
  s.add(1).add(2).add(3)
  for (const item of s) {
    // 遍历set结构
    console.log(item)
  }
  const m = new Map([
    ['name','昵称'],
    ['title', '标题']
  ])
  for (const [key, value] of m) {
    // 遍历map结构
    console.log(key)
    console.log(value)
    console.log(m.get(key))
  }

  const newSet = new Set([
    ['name','昵称'],
    ['title', '标题']
  ])
  const newMap = new Map(newSet)
  for (const [key, val] of newMap) {
    // 遍历set初始化后的map结构
    console.log(key)
    console.log(val)
  }

  const obj = {
    name: 'ttt',
    age: '19'
  }
  for (const [key, val] of obj) {
    // 遍历对象报错 Uncaught TypeError: obj is not iterable
    console.log(key, val)
  }

上面代码中，for…of可以遍历数组，set, map，但是却不能遍历对象，是因为对象没有可迭代接口

6、可迭代接口

在浏览器中打印一个数组，在数组的原型对象上有一个Symbol内置属性Symbol.iterator方法，该方法会返回一个iterator对象，该对象包含一个next()方法，调用iterator.next()会返回一个迭代器结果对象iterationResult，iterationResult对象包含两个值，value为遍历的item，done为当前数据是否遍历完成

  const iterator = arr[Symbol.iterator]()
  console.log(iterator) // Array Iterator {}
  const ite = iterator.next()
  console.log(ite) //{value: 1, done: false} value为迭代器的值，done标识是否遍历完

由于上面代码中obj对象不没有Symbol.iterator的内置方法，所以它不是一个可迭代对象，当使用for…of遍历时就报错了，下面手动实现obj可迭代

  let iteratorObj = {
    //iteratorObj是可迭代对象 iterable
    name: 'ttww',
    age: '18',
    [Symbol.iterator] () {
      let index = 0;
      let arr = []
      for (const key in iteratorObj) {
        arr.push([key, iteratorObj[key]])
      }
      return {
      //返回的对象叫iterator
        next () {
          return {
            //结果对象iterationResult
            value: arr[index],
            done: index++ >= arr.length
          }
        },
      }
    }
  }
  for (const [key, val] of iteratorObj) {
    console.log(key, val)
  }

上面代码中，iteratorObj有了可迭代接口，认为是可迭代对象iterable；Symbol.iterator方法返回的对象是迭代器对象iterator；迭代器对象next方法返回的对象是迭代器结果对象iterationResult

6、生成器 generator

用途：处理异步调用回调嵌套的问题

  function *geFn () {
    console.log('111')
    yield 100
    console.log('222')
    yield 200
    console.log('333')
    yield 300
  }
  let generator = geFn()
 
  console.log(generator.next())  //111 {value: 100, done: false}
  console.log(generator.next())  //222 {value: 200, done: false}
  console.log(generator.next())  //333 {value: 300, done: false}

在函数名前面加一个"*"，函数就变为生成器函数，执行该函数时，里面的函数不会立即执行，而是会返回一个生成器对象，调用生成器对象的.next方法函数开始执行，当遇到”yield“关键字，函数会停止执行，并把yield的值当做next方法返回对象的value; 当下次调用next方法时，函数从当前位置开始继续执行
生成器函数执行后返回的生成器对象generator，内部也是实现了迭代器接口，所以可以使用for…of来遍历

  function *geFn () {
    console.log('111')
    yield 100
    console.log('222')
    yield 200
    console.log('333')
    yield 300
  }
  let generator = geFn()

  for (const item of generator) {
    console.log(item)
  }

可以使用生成器函数改写上面对象的迭代器方法

  let iteratorObj = {
    name: 'ttww',
    age: '18',
    [Symbol.iterator]:function *() {
      let index = 0;
      let arr = []
      for (const key in iteratorObj) {
        arr.push([key, iteratorObj[key]])
      }
      // for (let i =0; i<arr.length; i++) {
      //   console.log(arr[i])
      //   yield arr[i]
      // }
     
      for (const item of arr) {
        yield item
      }
      // arr = ['b',3,4,5]
      // return {
      //   next () {
      //     return {
      //       value: arr[index],
      //       done: index++ >= arr.length
      //     }
      //   },
      // }
    }
  }
  for (const [key, val] of iteratorObj) {
    console.log(key, val)
  }

这里有一个注意的点就是在循环arr数组时，不能是有forEach遍历，是因为forEach里需要传一个回调函数，这个函数不是生成器函数，在非生成器函数里使用yield关键字会报错

ES2016

1、数组新增方法：includes

  const arr = [1,2,3]
  console.log(arr.includes(2))  //true

2、指数运算符

console.log(2 ** 10) //1024
ES2017

1、Object.values()，以数组的形式，返回对象所有的值

  let obj = {
    title: 'wwwww',
    age: 199
  }
  console.log(Object.values(obj)) //["wwwww", 199]

2、Object.entries()，以数组的形式，返回对象的所有键值对

let obj = {
title: ‘wwwww’,
age: 199
}
console.log(Object.entries(obj)) //[[“title”, “wwwww”],[“age”, 199]]
可以将对象转为map数据结构

  let obj = {
    title: 'wwwww',
    age: 199
  }
 
  let m = new Map(Object.entries(obj))
  console.log(m) //{"title" => "wwwww", "age" => 199}

3、Object.getOwnPropertyDescriptor()
获取一个对象的完整描述信息，可用于将一个对象的get，set属性赋值给另一个对象

  let obj = {
    firstName: 'abc',
    lastName: '123',
    get fullName () {
      return this.firstName + this.lastName
    }
  }
  console.log(obj.fullName) //abc123
  const p2 = Object.assign({}, obj)
  // 此时赋值给p2的仅仅是fullName属性的值，并没有fullName属性的getter
  p2.firstName = '456'
  console.log(p2.fullName)  //abc123

  const description = Object.getOwnPropertyDescriptors(obj)
  console.log(description)
  const p3 = Object.defineProperties({}, description);
  p3.firstName = '789'
  console.log(p3.fullName)  //789123

4、字符串的padEnd()、padStart()方法
5、async/await文章来源地址https://www.toymoban.com/news/detail-696598.html

到了这里，关于ES6常用新特性的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！