map和set

map

map结构是一种类似于json 的结构 跟json 的区别就是 json的key值只能是字符串 map的key值可以是任何类型

let fun1=()=>{
            console.log(111)
        }
       
        let map1=new Map()
        map1.set(2,"aa");
        map1.set(fun1,"bb")
        console.log(map1.get(fun1));
        // 只能通过set方法和get方法设置值和获取值

        console.log(map1.has(3));//判断是否含有某个key值
        // map1.delete(fun1);
        // console.log(map1)

        // map1.clear()//清除所有的


        map1.forEach((item,key)=>{
            // console.log(item,key)
        })
        // foreach可以循环map结构 item是value值 key是键值

        // for(var item of map1.keys()){
        //     console.log(item)
        // }
        // keys()方法能拿到所有键值然后进行循环使用
set

es6 set实现数组去重

// let arr=[12,34,12,34,56];
        // let res=[];
        // for (let i = 0; i< arr.length; i++) {
        //     if(res.indexOf(arr[i])==-1){
        //         res.push(arr[i]);
        //     }
            
        // }
        // console.log(res);

        // let set1=new Set(arr);
        // console.log(set1);
        // let res=Array.from(set1);//array.from把类数组变成数组
        // let  res=[...set1]//扩展运算符可以把类数组变成数组
        // console.log(res);

set是一种新的数据类型 是一个类数组 成员都是唯一的

set结构实例化的方法

{
            let arr=[12,34,12,34,56];
            let set1=new Set(arr);
            console.log(set1.add("aaa"));//往set里添加值
            console.log(set1)

            set1.delete(12);//删除set的某个值
            console.log(set1);

           console.log( set1.has("aaa")) //判断是否含有某个值

        //    set1.clear();//清空所有的值
        //    console.log(set1)


            set1.forEach((item)=>{
                console.log(item);
            })
            // set1在forEach的时候不能拿到下标
        }

扩展运算符和剩余运算符

…作为rest剩余运算符 把剩余的数组组成一个数组

1.解构赋值的时候 把解构源剩余的值解构为一个数组

let [a,b,...c]=[1,2,3,4];  
        console.log(a,b,c);
  1. …作为函数的参数
function fun1(a,...b){
           console.log(a,b) 
        }
        fun1(1,2,3)
…作为扩展运算符 展开运算符 spread

1.把类数组转化为数组

var set=new Set([1,2,3,1,2]);
        // [1,2,3];
        var res=[...set];//【1，2，3】

2.复制数组(第一层的深复制)

var arr2=[...res];

3.合并数组

var arr3=[...res,...arr2];
        console.log(...arr3);

ES5面向对象

function Animal(name){
            this.name=name
        }
        Animal.prototype.run=function(){
            alert("runrunrun"+this.name);
        }//实例化对象执行的方法
        Animal.run2=function(){
            alert("22222");
        }//整个类执行的方法
        var dog=new Animal("dog");
        dog.run();
        Animal.run2();
es5实现继承的方法：

1.call和apply
2.直接改变prototype
3.比如dog类继承animal类 dog.prototype=new Animal(); Dog.prototype.constructor=Dog;

ES6面向对象

class Animal{
            constructor(name,age){
                this.name=name;
                this.age=age
            }
            //constructor函数就相当于是es5里的构造函数  定义属性
            run(){
                alert(this.name+"runrunrun");
            }//不加static的方法就相当于是es5里在原型上扩充的方法 被实例化对象调用
            static run2(){
                alert(this);//this不再指向实例化对象而是指向整个类Animal
            }//在方法的前面加上static关键字 这个方法就变成了静态方法，被整个类调用，不能被实例化对象调用


        }

        var dog=new Animal("dog","19");
        // dog.run();
        // Animal.run2();


        // es6中添加了专门用来实现继承的关键字 extends super
        // cat继承animal animal是父类也叫做超类
        
        class Cat extends Animal{
            constructor(name,age,miao){
                super(name,age);
                this.miao=miao;
            }
            say(){
                alert(this.name+"喵喵喵") 
            }
        }
        var cat1=new Cat("小花",2,"猫叫");
        cat1.say();
        cat1.run();

es6的面向对象是es5的语法糖 跟之前的逻辑还有实现的效果是一样的 只不过写法更方便了 可以认为是对原来的原型的写法进行了封装