ES6总结

Object.create(prototype, {descriptors})

作用：以指定对象为原型创建新的对象

value: 指定值

writable:当前属性值是否是可修改的，默认false

configurable: 当前属性是否可以被删除， 默认false

enumerable:当前属性是否能用for in 枚举，默认false

const obj = { username: '页面仔小杨', age: 18 }
let obj1 = Object.create(obj, {
  sex: {
    value: 1,
    writable: true,
    configurable: true,
    enumerable: true
  }
})

Object.defineProperties(object, descriptors)

作用：为指定对象定义扩展多个属性

get: 用来获取当前属性值的回调函数

set: 修改当前属性值的触发的回调函数，并且实参即为修改后的值

let obj2 = { firstName: '页面仔', lastName: '小杨' }
Object.defineProperties(obj2, {
  fullName: {
    get: function() {
      console.log('==========')
      return `${this.firstName} ${this.lastName}`
    },
    set: function(data) {
      console.log(data)
      const names = data.split(' ')
      this.firstName = names[0]
      this.lastName = names[1]
    }
  }
})
obj2.fullName = "ha ha"
console.log(obj2.fullName)

let const

let代替了var,具有块级作用域

解构赋值

let [a, b, c] = arr
const { body: { name, description }, url } = req

模版字符串

const name = '页面仔小杨'
console.log(`hello ${name}`)

箭头函数

1.函数体只有一条语句或者表达式的时候 {} 可以省略， 自动返回语句执行的结果或者表达式的结果

2.没有自己的this，定义的时候处在的对象就是它的this

三点运算符

function(...value) {
  console.log(value)
}
const arr = [3,4]
const arr1 = [1, 2, ...arr, 5]

in的用法

in是用来判断对象或者数组中是否存在某个值的。我们先来看一下用in如何判断对象里是否有某个值

let obj={
    a:'js',
    b:'页面仔小杨'
}
console.log('a' in obj)  // true

Promise/await

promise三个状态: pending fullfilled rejected

Symbol

let symbol1 = Symbol("hello")
console.log(symbol1)   // Symbol(KK)
typeof(symbol1)        // "symbol"
 
// 相同参数 Symbol() 返回的值不相等
let symbol2 = Symbol("hello")
console.log(symbol1 === symbol2)       // false

let syObject = {};
syObject[symbol1] = "hello";
console.log(syObject);    // {Symbol(hello): "hello"}

Symbol 值作为属性名时，该属性是公有属性不是私有属性，可以在类的外部访问。但是不会出现在 for…in 、 for…of 的循环中，也不会被 Object.keys() 、 Object.getOwnPropertyNames() 返回。如果要读取到一个对象的 Symbol 属性，可以通过 Object.getOwnPropertySymbols() 和 Reflect.ownKeys() 取到

Iterator

const items = [1, 2, 3, 4, 5]
const it = items[Symbol.iterator]()
console.log(it.next()) // { value: 1, done: false }
console.log(it.next()) // { value: 2, done: false }
console.log(it.next()) // { value: 3, done: false }
console.log(it.next()) // { value: 4, done: false }
console.log(it.next()) // { value: 5, done: false }
console.log(it.next()) // { value: undefined, done: true }

迭代器是协议,可迭代的数据结构：Array String Map Set

Generator

在 function 后面，函数名之前有个 *

函数内部有 yield 表达式

function* foo(){
    let x = yield 1;
    console.log(x)
    yield 2;
    yield 3;
}
let f = foo();
f.next();  // {value: 1, done: false}
f.next(10)
// 10
// {value: 2, done: false}
f.return("foo");  // {value: "foo", done: true}
f.next();  // {value: undefined, done: true}

Async

async取代了Generator函数的*，await取代了Generator的yield

Map、Set

Map与Object的区别

不同点	Map	Object
键	任意值	只能是字符串/Symbol
键值的有序性	有序的	无序的
获取键值对的个数	myMap.size	自己手动计算
	覆盖原来的值	Object基于原型链，键名产生冲突

Set 对象存储任何类型的唯一值，无论是原始值或者是对象引用

//  数组去重
let arr = [1,1,2,2,3,3,4,5]
console.log([...new Set(arr)])
console.log(Array.from(new Set(arr)));

Proxy

可进行预处理

let pro = new Proxy({
    add: function (val) {
        return val + 1;
    },
    name: '页面仔小杨'
}, {
        get: function(target, key){
            console.log('get')
            return target[key]
        },
        set: function(target, key, value, receiver){
            console.log(`setting ${key} = ${value}`)
            return target[key] = value
        }

    });

console.log(pro.name)
pro.name='页面仔小杨2'
console.log(pro.name)