ES6新语法特性

一、symbol类型

symbol是一个原始数据类型，不是对象。可以接受一个字符串作为参数，为新创建的symbol提供描述，用来显示在控制台或者字符串的时候使用，便于区分

let sy = Symbol('kk')

console.log(sy)

typeof(sy)

let sy1 = Symbol("kk")

sy === sy1  //false

用途：

1、由于每一个Symbol的值都是不相等的，所以Symbol作为对象的属性名，可以保证属性不重名

let sy = Symbol('key1')

let syObject = {}

Object.defineProperty(syObject,sy, {value: 'kk'})

console.log(syObject)

Object.getOwnPropertySymbols(syObject)   // [symbol(key1)]

Reflect.ownKeys(syObject)  // [symbol(key1)]

2、想定义的内容不重复，那么就一定要用上symbol类型

二、map对象

1、map和objects的区别

1）、一个object的键只能是字符串或者symbols，但一个map的键可以是任意类型

2）、map中的键值是有序的（FIFO原则）,而添加到对象中的键则不是

3）、Map的键值对个数可以从size属性获取，而object的键值对个数只能手动计算

4）、object都有自己的原型，原型链上的额键名有可能和你自己在对象上设置的键名产生冲突

2、map的迭代：

1)、for...of

2）、forEach()

var myMap = new Map()

myMap.set(0, 'Zero')

myMap.forEach(function(value, key) {

　　console.log(key + '=' + value)

})

3、map和array的转换

var kvArray = [['key1', 'value1'], ['key2', 'value2']]

var myMap = new Map(kvArray)

var outArray = Array.from(myMap)

三、set对象

1、set对象允许你存储任何类型的唯一值，无论是原始值或者对象引用，set对象存储的值总是唯一的

转换：

array转set

var myset = new Set(['value1', 'value2', 'value3'])

set转array

var myArray = [...mySet]

作用：

1、数组去重

var mySet =  new Set([1,2,3,4,4])

[...mySet]  //[1,2,3,4]

2、并集：

var a  =  new  Set([1,2,3])

var b = new Set([4,3,2])

var union = new Set(...a,...b) //{1,2,3,4}

3、交集

var a  =  new  Set([1,2,3])

var b = new Set([4,3,2])

var intersect =  new Set([...a].fillter(x => b.has(x)))  // {2,3}

4、差集

var a  =  new  Set([1,2,3])

var b = new Set([4,3,2])

var difference =  new Set([...a].filter(x => !b.has(x))) // {1}

四、proxy对象和apply

proxy对象由target和handler这两个部分组成，target即为目标对象，handler是一个对象，声明了代理target的指定行为

let target  = {name: 'Tom', age: 24}

let handler = {

　　get: function(target, key) {

　　　　console.log('getting' +  key)

　　　　return target[key]

　　},

　　set: function(target, key, value) {

　　　　console.log('setting' +  key)

　　　　target[key] = value

　　}

}

let proxy = new Proxy(target, handler)

proxy.name    //实际执行的是handler.get

proxy.age = 25  //实际执行的是handler.set

apply：用于拦截函数的调用，call和reply操作。target表示目标对象，ctx表示目标对象的上下文，args表示目标对象的参数数组

function sub(a, b) {

　　return a - b

}

let handler = {

　　apply: function(target, ctx, args) {

　　　　console.log('handle apply')

　　　　return Reflect.apply(...arguments)

　　}

}

let proxy = new Proxy(sub, handler)

proxy(2,1)

//handle apply

//1

has(target, propKey)

用于拦截HasProperty操作，即在判断target对象是否存在propkey属性时，会被这个方法拦截。此方法不判断一个属性是对象自身的属性，还是继承的属性

let handler = {

　　has: function(target, propKey) {

　　　　console.log("handle has")

　　　　return propKey in target

　　}

}

let exam = {name: "Tom"}

let proxy = new Proxy(exam, handler)

'name' in proxy

construct(target, args)

用于拦截new命令，返回值必须为对象

let handler = {

　　construct:  function(target, args,  newTarget) {

　　　　console.log('handle construct')

　　　　return Reflect.construct(target, args, newTarget)

　　}

}

class Exam {

　　constructor(name) {

　　　　this.name = name

　　}

}

let ExamProxy = new Proxy(Exam, handler)

let proxyObj = new ExamProxy('Tom')

console.log(proxyObj) 

//handle construct

//exam {name: 'Tom'}

defineProperty(target, propKey, propDesc)

用于拦截Object.definePro,若目标对象不可扩展，增加目标对象上不存在的属性会报错，若属性不可写或不可配置，则不能改变这些属性

let handler = {

　　defineProperty: function(target, propKey, propDesc) {

　　　　console.log('handle defineProperty')

　　　　return true

　　}

}

let   target = {}

let  proxy = new Proxy(target, handler)

proxy.name = 'Tom'

//handle defineProperty

target

//{name: 'Tom'}

 

//defineProperty返回值为false，那么添加属性操作无效

let handler1 = {

　　definePropeerty: function(target, propKey, propDesc) {

　　　　console.log("handle defineProperty")

　　　　return false

　　}

}

let target1 ={}

let proxy1 = new Proxy(target1,handler1)

proxy1.name - 'Jim'

target1

//添加属性无效 {}

Reflect

ES6中将object的一些明显属于语言内部的方法移植到了Reflect对象上（当前某些方法会同时存在object和reflect对象上），未来的新方法只部署在Reflect对象上

Reflect对象对某些方法的返回结果进行了修改，使其更加的合理

Reflect对象使用函数的方式实现了Object的命令式操作

let exam = {name: 'Tom', age: 24, get info() {return this.name + this.age}}

Reflect.get(exam,  'name') ;  //Tom

当target对象中存在name属性的getter方法，getter方法的this会绑定 //receiver

let receiver = {name: 'Jerry', age: 20}

Reflect.get(exam, 'info', receiver)  //Jerry 20

查看对象中是否有name这个属性： Reflect.has(exam, name) //true

删除对象中的name这个属性： Reflect.deleteProperty(exam, 'name')  //true

添加某个属性：Reflect.defineProperty(student, 'name', {value: 'Mike'})  student.name //Mike

 

字符串的方法、Number

string:

1、includes

2、startsWith

3. endsWith

4、repeat(2)

5、padStart

6、padEnd

number:

1、Number.parseInt()

2、Number.parseFloat()

4、Number.isInteger(1.1)

5、Math.trunc(12.3) //12   取整数部分

6、Math.sign(-2)  //判断正负或者0

判断浮点数是否相等：Math.abs(0.1 - 0.3 +  0.2)  <  Number.EPSION