es6新特性

一、类

class Base{
    constructor(){
        this.name = "杨洋"
    }
    get y(){
        return this.name
    }
    set y(n){
        this.name = n;
    }
    getV(){ 
        return "这是我定义的方法"
    }
}
var n = new Base();
n.y = "朱一龙";
console.log(n.name,n.getV(),"222===")

二、继承、重载、静态方法

class Base {
    top() {
        console.log("top")
    }
    mid() {
        console.log("middle")
    }
    static s(){
        console.log("这是静态方法")
    }
    all() {
        let me = this; 
        me.top(); 
        me.mid(); 
        return "总的"; 
    }

}
class c1 extends Base {
    top() {
        // super.top();// 继承
        console.log("这是第一个新的top")
    }
}
class c2 extends Base {
    top() {
        // super.top();// 继承
        console.log("这是第二个新的top")
    }
}
function getV(nn){
    var n = new Base()
    if(nn == "1"){
        n =  new c1(); 
    }else{
        n = new c2(); 
    }
    return n.all();
}
console.log(getV("2"))
Base.s();

注意：静态方法必须使用定义的类名去调用，不能使用实例化后的对象进行调用

三、实现交集、并集、差集

// 交集
function compare1(arr1,arr2){
    return [...new Set(arr1)].filter((it)=>arr2.includes(it));
} 

// 差集
function compare2(arr1,arr2){
     return [...new Set([...arr1, ...arr2])];
} 

// 并集
function compare3(arr1,arr2){
    return [...new Set(arr1)].filter(it => !arr2.includes(it));
} 

// 数组对象
// 交集
function compare4(arr1, arr2, key) {
  const set2 = new Set(arr2.map(it => it[key]));
  return arr1.filter(it => set2.has(it[key]));
}
 
// 并集
function compare5(arr1, arr2, key) {
  const set2 = new Set(array1.map(it => it['id']));
  return arr1.concat(arr2.filter(item => !set2.has(item[key])));
}
 
// 差集
function compare6(arr1, arr2, key) {
  const set2 = new Set(arr2.map(it => it[key]));
  return arr1.filter(it => !set2.has(it[key]));
}

1、交集
方法一：在arr1中筛选包含在arr2中的数据，即为交集。(filter + includes)
const arr1 = ['0', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.filter(e => arr2.includes(e))
console.log(arr) // ['2', '4']
方法二：先将两个数组合并，再筛选出既属于arr1又属于arr2的数据，最后去重，即为交集。(concat + filter + includes + Set)
const arr1 = ['0', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const array = arr1.concat(arr2).filter(e => arr1.includes(e) && arr2.includes(e))
const arr = [...new Set(array)]
console.log(arr) 

2、并集
方法一：将两个数组合并，然后去重，即为并集。（concat + Set）
const arr1 = ['0', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = [...new Set(arr1.concat(arr2))]
console.log(arr)
方法二：先将两个数组合并，然后执行reduce函数，结果值的初始值设置为空数组 [] , 当当前数据不存在结果值数组里时，将当前数据push到结果值数组里，最后获得结果值数组，即为并集。（concat + reduce）
const arr1 = ['0', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.concat(arr2).reduce((pre, cur) => {
    if (!pre.includes(cur)) {
        pre.push(cur)
    }
    return pre
}, [])
console.log(arr)

3、差集
-先将两个数组合并，然后筛选在arr1的并且不在arr2的，即为A-B的差集。（concat + filter + includes）
const arr1 = ['0', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.concat(arr2).filter(e => arr1.includes(e) && !arr2.includes(e))
console.log(arr)
-先将两个数组合并，然后筛选在arr2的并且不在arr1的，即为B-A的差集。
const arr1 = ['0', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = arr1.concat(arr2).filter(e => arr2.includes(e) && !arr1.includes(e))
console.log(arr)

4、补集
方法一：先将两个数组合并，再分别筛选出既不在arr1又不在arr2中的数据，连个数组合并，即为补集。（concat + filter + includes）
const arr1 = ['0', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const array = arr1.concat(arr2)
const arr = [...array.filter(e => !arr1.includes(e)), ...array.filter(e => !arr2.includes(e))]
console.log(arr) 
方法二：在arr1中筛选出不在arr2中的数据，在arr2中筛选出不在arr1中的数据，两个数组合并，即为补集。（filter + includes）
const arr1 = ['1', '2', '3', '4']
const arr2 = ['2', '4', '6', '8']
const arr = [...arr1.filter(e => !arr2.includes(e)), ...arr2.filter(e => !arr1.includes(e))]
console.log(arr)