ES6对象的简洁写法

//直接写入变量
const foo="bar";
const abc={foo};
console.log(abc);//{foo:"bar"}
//直接写入函数
const obj={
	getobj(){
	console.log("hello");
	}
}
obj.getobj();//"hello"

ES6属性表达式,不能和简洁写法同时使用,会报错

const obj ={
["abc"+"de"]:123,
["hel"+"lo"]:function(){
console.log("你好!!");
}
}
console.log(obj["abc"+"de"]);//123
console.log(obj.abcde);//123
console.log(obj["hel"+"lo"]());//你好!!
console.log(obj.hello());//你好!!

Object.is()用来比较两个值是否严格相等,类似于=却可以解决=的缺点:+0===-0为true和NaN不等于自身

console.log(NaN===NaN);//false
console.log(Object.is(NaN,NaN));//true
console.log(+0===-0);//true
console.log(Object.is(+0,-0));//false

Object.assign()用于对象的合并,将源对象的所有可枚举(遍历)属性,复制到目标对象

const obj1={a:1};
const obj2={b:2};
const obj3={c:3};
console.log(Object.assign(obj1,obj2,obj3));//{a:1,b:2,c:3}
**//Object.assign(目标对象,源对象1,源对象2...)**
**//如果目标对象与源对象有同名属性,或者源对象与源对象有同名属性,后面的会覆盖前面的**
**//如果只有一个参数,会返回该参数;如果只有一个参数,还不是对象,会转为对象,再返回;**
**//如果目标对象位置参数为undefined和null时结果报错**
**//当字符串出现在源对象位置上时,会以数组的形式,拷贝到目标对象**

Object.setPrototypeOf()用来设置一个对象的原型对象,返回参数对象本身

var obj ={a:10};
Object.setPrototypeOf(obj,{b:20});
console.log(obj.b);//20
console.log(obj);//{a:10}
//语法:Object.setPrototypeOf(参数对象,新的原型对象);
//如果第一个参数不是对象,会自动转为对象,undefined和null报错

Object.getPrototypeOf()用来读取一个对象的原型对象

//如果第一个参数不是对象,会自动转为对象,undefined和null报错

遍历对象方法,类似于数组的相同方法,Object.keys()对键名遍历(下标)丶Object.values()对键值遍历(值)和Object.entries()对键值对的遍历,需要配合for循环

 for (let index of Object.keys({ a: "李四", b: "王五" })) {
            console.log(index);//a b
        }
 for (let index of Object.values({ a: "李四", b: "王五" })) {
            console.log(index);//李四 王五
        }
for (let index of Object.entries(["张三", "李四"])) {
            console.log(index);//[a,李四] [b,王五]
        }  

Set()数据结构,由于值具有唯一性,可以用来进行数组和字符串的去重

**Set的属性和方法:
size属性:返回Set实例的成员总数(length)
Set的操作方法:
1.add(value)添加某个值,返回Set结构本身
2.delete(value)删除某个值,返回布尔值,表示是否删除成功
3.has(value)返回一个布尔值,判断是否是Set的成员
4.clear()清除所有成员,没有返回值
**Set的遍历方法:/由于Set数据结构没有键名,只有键值,因此keys和values方法结果完全一致
1.keys()返回键名的遍历值(属性名)
2.values()返回键值的遍历值(属性值)
3.entries()返回键值对的遍历值(键值对{a:a})
4.forEach()使用回调函数遍历每个成员
**

var arr = [1, 2, 2, 2, 2, 3, 3, 3, 4, 5];
        var ary = new Set(arr);
        console.log(ary);//Set{1,2,3,4,5}
        console.log(ary.size);//5** //Set的size属性,类似于length**
        console.log(ary.add(22));//Set{1,2,3,4,5,22} **//Set的add方法,添加值**
        ary.delete(22);//**Set的delete方法用于删除某个值**
        console.log(ary);//Set{1,2,3,4,5}
        console.log(ary.has(22));//false **//Set的has方法用于判断某个值是否存在**
        //ary.clear();//Set的clear方法用于清除所有成员
        //console.log(ary);//Set{}
         for (let item of ary.keys()) {
            console.log(item);//1 2 3 4 5
        }//**由于Set数据结构没有键名,只有键值,因此keys和values方法结果完全一致**
        for (let item of ary.values()) {
            console.log(item);//1 2 3 4 5
        }
        for (let item of ary.entries()) {
            console.log(item);[1,1][2,2][3,3][4,4][5,5]
        }
        ary.forEach(function (item, index) {
            console.log(item,index);//item:1,2,3,4,5 index:1,2,3,4,5
        })   

Map()数据结构,可以使用各种类型的值(对象的值)当做键(对象名)

**Map的属性和方法
size属性:返回Map结构的成员总数
Map操作方法
1.set(key,value)设置键名key对应的键值为value,返回整个Map结构,如果key已经有值,键值会被更新
2.get(key)读取key对应的键值,如果找不到key,返回undefined
3.has(key)返回一个布尔值,表示某个键是否在当前Map对象中
4.delete(key)删除某个键,返回true,如果删除失败,返回false
5.clear()清除所有成员,没有返回值
Map遍历方法 和Set数据结构不同的是Map有键名,键值
1.keys()返回键名的遍历值(属性名)
2.values()返回键值的遍历值(属性值)
3.entries()返回键值对的遍历值(键值对{a:a})
4.forEach()使用回调函数遍历每个成员
**

var obj = new Map();
        console.log(obj.size);
        //通过set方法设置键名及键值
        //键名为字符串
        obj.set("name", "张三");
        //键名为数值
        obj.set(18, "age");
        //键名为undefined
        obj.set(undefined, "hello");
        //键名为布尔值
        obj.set(true, "你好!");
        //键名为null
        obj.set(null, "hi");
        console.log(obj);
        //通过get方法,获取key对应的键值
        console.log(obj.get(null));
        //通过has方法,判断某个键是否在当前Map对象之中
        console.log(obj.has(1));
        //通过delete方法,删除某个键
        obj.delete("name");
        console.log(obj);
        //通过clear方法,清除所有成员
        // obj.clear();
        // console.log(obj);
        //Map的遍历方法
        for (let item of obj.keys()) {
            console.log(item); //18 undefined true null
        }
        for (let item of obj.values()) {
            console.log(item); //age hello 你好!  hi
        }
        for (let item of obj.entries()) {
            console.log(item);//[18, "age"][undefined, "hello"][true, "你好!"][null, "hi"]
        }
        obj.forEach(function (item, index) {
            console.log(item,index);//item:age hello 你好!  hi   index:18 undefined true null
        })

WeakSet()||WeakMap()数据结构构造函数

1.不能遍历,成员都是弱引用,如果没有被引用会被垃圾回收机制回收
2.键名只能为对象类型数据,不能为其他数据类型.但值可以是任意的类型
3.键名是弱引用,如果这个键名用过了,在其他的地方没有再被引用,就会被垃圾回收机制回收,并释放内存
4.没有size属性,没有部署Iterator接口
5.避免内存泄漏

定义

类似于数组,集合实现了iterator 接口，所以可以使用 扩展运算符 和 for…of 进行遍历
是一种新的数据结构，它可以接收一个数组或者是类数组对象
Set对象是值的集合,值是惟一的

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

let sets = new Set()

Set可以接收一个数组作为参数，用来初始化

let sets = new Set([1,2])
console.log(sets);

不能直接添加数字

let sets = new Set(2)

方法

set.size

返回set结构成员数量
类似于数组长度

let sets = new Set()
sets.size;//0

set.prototype.add 添加

添加成员 返回set结构本身

let sets = new Set()
sets.add(1).add('str').add([2,2])

let sets = new Set()
sets.add(1)
sets.add('str')
sets.add([2,2])
sets.size;//3

set.prototype.clear

清空set所有成员 没有返回值

let sets = new Set()
sets.add(1)
sets.add('str')
sets.add([2,2])
sets.clear()

set.prototype.delete(value)

删除元素value 返回布尔值 表示是否删除成功

let sets = new Set()
sets.add(1).add('str').add([2,2])
sets.delete('str'); // true
sets.delete('hh'); // false

set.prototype.entries()

let sets = new Set()
sets.add(1)
sets.add('str')
sets.add([2,2])
let entries= sets.entries();
for(let i of entries){
    console.log(i)
}
// [1, 1]
// ["str", "str"]
// [[1,2], [1,2]]
console.log(entries,sets.entries())

set.prototype.forEach

set结构的实例和数组一样，也有forEach方法
forEach(callback,this)
function callback(value, key, set){}
value === key 属性值, set 遍历的对象

let obj = {name:'obj'}
let sets = new Set()
sets.add(1)
sets.add('str')
sets.add([2,2])
sets.forEach(function(value, key, set){
   console.log(value, key, set)
   console.log(this)
},obj)
// 1 1 Set(3) {1, "str", Array(2)}
// str str Set(3) {1, "str", Array(2)}
// [2, 2] [2, 2] Set(3) {1, "str", Array(2)}
// this 指向 obj{name:'obj'}

set.prototype.has(value) 声明对象中是否存在具有给定值的元素Set。

返回一个布尔值 表示该值是否为Set的成员

let sets = new Set()
sets.add(1)
sets.add('str')
sets.has('str')//true

set.prototype.keys()

let sets = new Set()
sets.add(1).add('str').add([2,2])
console.log(sets.keys())

let keys= sets.keys();
for(let i of keys){
	console.log(i)
}
// 1
// 'str'
// [1,2]

set.prototype.values()

返回一个新Iterator对象，该对象按插入顺序包含该对象中每个元素的值

let sets = new Set()
sets.add(1).add('str').add([2,2])
console.log(sets.values())

和keys一样

let values = sets.values();
for(let i of values){
	console.log(i)
}
// 1
// 'str'
// [1,2]

set[Symbol.iterator]()

访问遍历器iterator

let Sy = sets[Symbol.iterator]()
console.log(Sy)

set对象应用

帮助我们数组去重

let numbers = [1,1,2,3,2,1,5,8,8,96,12,undefined,null,'']
let numberSet = new Set(numbers)
console.log(numberSet)

let uniqunNumber = [...numberSet];
//[1, 2, 3, 5, 8, 96, 12, undefined, null, ""]

交集

求重复部分

let numbers = [1,1,2,3,2,1,5]
let numbers2 = [1,1,5,2]
let res = [...new Set(numbers)].filter(item=>{
	let s2 = new Set(numbers2)
	return s2.has(item)
})
// let res = [...new Set(numbers)].filter(item => new Set(numbers2).has(item))
console.log(res) // [1, 2, 5]

并集

数组合并

let numbers = [1,1,2,3,2,1,5]
let numbers2 = [1,1,5,2]
let s = new Set([...numbers,...numbers2])
[...s] // [1,2,3,5]

差集

A有B没有

let numbers = [1,1,2,3,2,1,5]
let numbers2 = [1,1,5,2]

let res = [...new Set(numbers)].filter(item => !new Set(numbers2).has(item))
// [3]
let res2 = [...new Set(numbers2)].filter(item => !new Set(numbers).has(item))
// []