es6学习二

set集合

1.集合的声明

let s = new Set();

2.Set集合用于数组去重

const arr = [1,2,3,3,4,4,5,6];
const  Arr = new Set(arr);
console.log(Arr); //[1,2,,3,4,5,6]

3.size 检测数组的长度

let Arr = new Set(arr).size;
console.log(Arr); 

4.判断数组是否含有某个元素,如果有则可以返回true 没有返回false

 let Arr = new Set(arr).has(3);
 console.log(Arr);

5.删除某个元素

   //5.删除某个元素
        const s = new Set([1,2,3,66,7,8,]);
        // 内部含有iterator接口，可以使用for of循环
        for(let key of s){
          console.log(key);
        }
           s.delete(1);
          console.log(s); 
        //   6.增加一个元素
         s.add(10);
        console.log(s); 
        // 7.清空整个集合
        s.clear();
        console.log(s);

6.集合的应用

  //   集合的应用
    //   1.数组的去重
      let user =['1','2','3','4','3','1'];
    //  去重之后返回的是一个集合
      const arr = new Set(user);
    //   利用扩位运算符
      const arr2 = [...arr]
      console.log(arr2);
    //   2.交集
    let s1 = [1,2,4,5,6,6,7,7];
    let s2 = [1,2,368,9,9,0];
    const result = [...new Set(s1)].filter(items => {
        return new Set(s2).has(items);
    })
    console.log(result); 
    // 3.并集
     const result  =[...new Set( [...new Set(s1),...new Set(s2)])];
    console.log(result); 
    // 4.差集，结果与谁差集谁有关
    const result = [...new Set(s1)].filter(items => {
        return !new Set(s2).has(items);
    })
    console.log(result);

2.Map集合
用于缓存
Map一种以键值对形式存在的集合

  let m = new Map();
        // 1.添加元素
        m.set('mei','小橙子');
        m.set('shuai','小陈');
        // console.log(m);
        // 2.获取元素
        // console.log(m.get('mei'));
        // 3.删除元素
      /*   console.log(m.delete('shuai'));
        console.log(m); */
        // 4.检测
        console.log(m.has('mei'));
        // 5.元素个数
       /*  console.log(m);
        console.log(m.size); */
        // 6.清空
        console.log(m.clear());//清除成功返回true，和undfind
        console.log(m);

es6之class类

javaScript 语言中，生成实例对象的传统方法是通过构造函数和原型的组合模式.ES6 提供了更接近传统语言（java）的写法，引入了 Class（类）这个概念，作为对象的模板。通过class关键字，可以定义类。

   // es5对书写构造函数
      /*   function fn(brand,price) {
           this.brand = brand;
           this.price = price;
           
        }
        fn.prototype.call= function(somone){
            console.log(`我可以给${somone}打电话`);
        }
        fn.prototype.pall = function(sendmessage){
            console.log(`我可以给${sendmessage}发信息`);
        }
        let user = new fn('nokia','223');
        console.log(user.call('lili')); */
        // es6可以定义一个class类
        class fn {
            // 给类添加属性，必须通过构造方法
            constructor(brand,price){
               this.brand = brand;
               this.price = price;
            }
            // 给函数原型对象上添加方法
            call(somone){
                console.log(`我可以给${somone}打电话`);
            };
            send(sendmessage){
                console.log(`我可以给${sendmessage}发信息`);
            }
        }
        let user = new fn('jinli',599);
        console.log(user.call('lili'));
        // 通过class类不一定要有constructor方法
        class a {

        }
        let A = new a();
         console.log(A);

es6对对象的继承

  function Phone(barnd,price) {
            this.barnd = barnd;
            this.price = price;
        }
        Phone.prototype.call = function(){
            console.log('我可以打电话');
        }
        Phone.prototype.send = function(){
            console.log('我可以发消息');
        }
        // 子类
        function smartPhone(barnd1,price1,neicun,xiangshu) {
            // Phone.call(this,brand,price);
           this.barnd1 = barnd1;
           this.price1 = price1;
            this.neicun= neicun;
            this.xiangshu = xiangshu;
        }
        // 继承父类的方法 步骤二
        //es5中 步骤二和步骤三的顺序不能颠倒
        smartPhone.prototype = new Phone();
        smartPhone.prototype.constructor = smartPhone;
        //步骤三
        smartPhone.prototype.add = function(){
            console.log('可以下载软件');
        }
        smartPhone.prototype.plauGam = function(){
            console.log('可以打游戏');
        }
      let smart = new smartPhone('jinli',2999,'128g','2000w');
      console.log(smart);
      //es6实现对象的继承

       class Phone {
         //添加属性必须通过constructor构造函数
            constructor (barnd,price) {
                this.barnd = barnd;
                this.price = price;
            };
            call(someone){
            console.log(`我可以给${someone}打电话`);
          };
           sendMessage(someone){
               console.log(`我可以给${someone}打电话`);
           };
        }
        // 子类继承父类
        class smartPhone extends Phone {
            // 利用super方法定义与父类相同的属性
          
            constructor(brand,price,takephotos,piex){
               //调用父类的super方法 添加子类属性
                super(brand,price);
                this.takephotos = takephotos;
                this.piex = piex;
            }
            palygame(){
                console.log('可以打游戏');

            }

        }
        let iphone = new smartPhone('苹果','4999','拍照','2000w');
        console.log(iphone);