day05

//把多元参数转换成一元参数的过程
//任意参数转换成医院参数
function add(a,b,c,d){
   return a+b+c+d;
}
//add();
//函数的长度就是参数的个数
//console.log(add.length);
//处理多参数的curry，不定参数的curry
function curry(add){
  return function curryFn(...args){
   if(add.length>args.length){
     //如果参数不够，就继续返还函数连续传入的参数
    return function(...args2){
     return curryFn(...args,...args2);
    }
   }else{
    //如果参数已经够了，直接执行函数返还函数结果
     return add(...args);
   }
  }
}
let mtadd = curry(add);
console.log(myadd);
let res = myadd(1)(2)(3)(4);
console.log(res);

ES6 新增数据类型

//独一无二的值（随机生成一个唯一的id）
//是一种类型，简单的数据类型
//是一个内置对象，其构造函数返回一个原语
let s = Symbol();
console.log(s);//Symbol

//没有数位限制
//直接创建
let num = BigInt(2**53);
console.log(num);//9007199254740992n
//通过数字后面加n
let num = 100n;
console.log(num); //100n
//bigint运算只能和bigint运算

可选运算符/空合并运算符

//符号：?
let obj = {
 name:'zhangsan',
  boj1:{
   myname：'lisi'
  },
}
console.log(obj?.name);//zhangsan
//obj里面有没有name这个元素，有就打印出来，没有就undefined
//合并空运算符 ??
function fn(a,b){
  var a=a??1;
  var b=b??2;
  console.log(a,b);
}
fn('',0); //0
fn(3,4);  //3 4
fn(undefined,null); // 1 2
//有值就输出值，没值就输出运算符后面的，可以过滤空字符串

类

//ES6的类本质也是构造函数，只是提供了一种新的语法糖
//直接把属性写外边，不需要this
//支持get和set
class Person{
  constructor(){
   this.name='zhangsan';
    this.myfn();
  }
  fn(){
   console.log(this.name);
  }
  myfn(){
   console.log('myfn');
  }
}
let zhangsan = new Person();
zhangsan.fn();

静态成员

//静态成员：属于类的 不属于 实例化对象的成员，不需要实例化
class Person{
 static num = 0; //静态属性
  constructor(name){
   this.name = name;
  }
  static fn(){
   console.log('fn');//静态方法
  }
}
console.log(Person.num);
Person.fn() //0 fn
//单例模式：一个类只保证有一个实例
class Person{
  //通过instance保存实例化的的状态
 static instance = null;
  constructor(name){
   this.name = name;
    if(!Person.instance){
      //没有实例化，通过Person.instance静态属性保存实例
      Person.instance = this;
    }else{
      //已经实例化过了，直接获取静态属性返还
      return Person.instance;
    }
  }
}
let zhangsan = new Person('zhangsan');
let lisi = new Person('lisi');
console.log(zhangsan,lisi)
//只会返还zhangsan

私有成员

// ES6 私有 
 // 私有成员 ： 只能类的内部调用 ，子类 和外部都不能调用
 class Person{
    #weight="100kg"; // 私有属性
     constructor(name){
     this.name = name;  // 公有成员
     this.age = 20
  }
   // 利用公有方法调用私有成员 
   getWeight(){  // 公有方法,调取私有属性 
   console.log("体重是?",this.#weight);
    }
        #fn(){
                console.log("私有方法")
            }
        }
        let zhangsan = new Person("张三");
        // console.log(zhangsan);
        // console.log(zhangsan.#weight);
        // zhangsan.#fn();
        zhangsan.getWeight();

类的继承

// ES6的继承 ；
        class Dad{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }
            fn(){
                console.log("fn");
            }
        }
        // 子类继承父类  extends 关键字 
        // 一旦写了 constructor 那么一定要调用super函数； super
        // super特征：
            /* 
                1.super 不能单独使用,只能在 constructor 和 方法里
                2.super可以用于父类的传参 
                3.必须要在使用this之前调用super
                4.如果 没有constructor 函数 那么 super可以省略
            */
        class Son extends Dad{
            constructor(name,age){
                // console.log(super);
                super(name,age);
                this.height = "178cm";
            }
            myfn(){
                console.log("myfn");
                super.fn();
            }
        }
        let zhangsan = new Son("张三",20);
        console.log(zhangsan);
        // zhangsan.fn();
        zhangsan.myfn();