new Date(2019, 12, 0).getDate() // 31
  new Date(2018, 2, 0).getDate()  // 28
  // 根据这个我们可以得到一个方法
  function getMonthLength(month) {
    const date = new Date(month)
    const year = date.getFullYear()
    // 月份是从 0 开始计算的
    const _month = date.getMonth() + 1
    return new Date(year, _month, 0).getDate()
  }

    let person = {
        name: "",
        sex: "",
        age: ""
    }

    let person1 = {
        name: "Bob",
        sex: "man",
        age: 18
    };
    let person2 = {
        name: 'Mary',
        sex: 'woman',
        age: 17
    };

    function person(name, sex, age) {
        return {
            name, sex, age
        }
    }
    
    let person1 = person("Bob", "man", 18);
    let person2 = person("Mary", "woman", 17);

    function Person(name, sex, age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    let person1 = new Person("Bob", "man", 18);
    let person2 = new Person("Mary", "woman", 17);

    function Person(name, sex, age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.career = "teacher";
        this.skill = function(){console.log(("传道受业解惑")}
    }
    let person1 = new Person("Bob", "man", 18);
    let person2 = new Person("Mary", "woman", 17);

    function Person(name, sex, age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    Person.prototype.career = "teacher";
    Person.prototype.skill = function(){console.log("传道受业解惑")};
    let person1 = new Person("Bob", "man", 18);
    let person2 = new Person("Mary", "woman", 17);

    // 这个方法用来检测 prototype 和某个实例之间的关系
    console.log(Person.prototype.isPrototypeOf(person1); // true

    // 每个实力对象都有 hasOwnProperty() 方法， 用来判断某个属性属于自身还是属于 prototype
    console.log(person1.hasOwnProperty("name")); // true
    console.log(person1.hasOwnProperty("career")); // false

    // in 运算符可以用来判断某个实例是否含有某个属性或方法，不管是自身的还是prototype的
    console.log("name" in person1); // true
    console.log("skill" in person1); // true
    console.log('color' in person1); // false

const obj = {name: 'cym'}
function fn(age) {
  console.log(this.name + '今年' + age + '岁了')
}
// 如上代码，我们要让 this 指向 obj
const bindFn = fn.bind(obj)
bindFn(24) // cym今年24岁了

Function.prototype.bind2 = function(ctx = globalThis) {
  // 取到我们要绑定的参数
  const args = [...arguments].slice(1)
  // 缓存 this，因为返回一个函数 this 就会变成新的函数
  const that = this
  // 返回一个函数
  return function() {
    // 返回函数里面的 arguments 是返回函数传入的参数哦，别搞混了
    that.apply(ctx, args.concat([...arguments]))
  }
}

const obj = {name: 'cym'}
function fn() {
  console.log(this)
}
// 如上代码，我们要让 this 指向 obj
const bindFn = fn.bind(obj)
const instance = new bindFn(24) // fn {}

Function.prototype.bind2 = function(ctx = globalThis) {
  // 取得参数
  const args = [...arguments].slice(1)
  // 取得函数
  const that = this
  // 要返回一个函数,还要判断是否有进行实例化的操作
  function Fn() {
    const allArgs = args.concat([...arguments])
    // 如果被实例化了
    if (this instanceof Fn) {
      that.apply(this, allArgs)
    } else {
      that.apply(ctx, allArgs)
    }
  }
  // 但是我们需要保证原型不能丢失，还得是原来函数的实例
  // 这种写法可能不雅观，因为直接让两个原型指向了同一个地址，一般情况下我们会使用一个临时性构造函数来处理一下
  // Fn.prototype = this.prototype
  Fn.prototype = Object.create(this.prototype)
  // 返回这个绑定好 this 的函数
  return Fn
}

const obj = {name: 'cym'}
function fn() {
  console.log(this)
}
// 如上代码，我们要让 this 指向 obj
const bindFn = fn.bind2(obj)
const instance = new bindFn()   // fn {}
bindFn()  // {name: 'cym'}

    function Person(name) {
        this.name = name;
        this.sayHello = function () {
            console.log("Hello !!")
        }
        this.getName = function () {
            console.log(this.name)
        }
    }
    
    function Teacher(name) {
        Person.apply(this, arguments);
        this.sayHello = function () {
            console.log("Hello, everyone. I am " + name + " !!")
        }
    }
    
    let teacher = new Teacher("Lily");
    console.log(teacher.sayHello()); // Hello, everyone. I am Lily !!
    console.log(teacher.name); // Lily
    console.log(teacher.getName()); // Lily

    function foo1(a) {
        console.log(a)
    }
    function foo2(a, b) {
        console.log("a: " + a, "b: " + b)
    }
    
    function foo () {
        if(arguments.length === 1) {
            foo1.apply(null, arguments)
        } 
        if(arguments.length === 2) {
            foo2.apply(null, arguments)
        }
    }
    
    foo(1); // 1
    foo(1, 22); // a: 1 b: 22

    function Person() {
        this.sayHello = function(){throw '没有定义该方法'}
    };
    
    function Teacher() {
        this.sayHello = function(){
            console.log("Hello everyone, I am a teacher.")
        }
    };
    
    function Worker() {
        this.sayHello = function(){
            console.log("Hello, I am a worker.")
        }
    };
    
    function Doctor(){};
    
    Teacher.prototype = new Person();
    Teacher.prototype.constructor = Teacher;
    
    Worker.prototype = new Person();
    Worker.prototype.constructor = Worker;
    
    Doctor.prototype = new Person();
    Doctor.prototype.constructor = Doctor;
    
    let teacher = new Teacher();
    console.log(teacher.sayHello()); // Hello everyone, I am a teacher.
    
    let worker = new Worker();
    console.log(worker.sayHello()); // Hello, I am a worker.
    
    let doctor = new Doctor();
    console.log(doctor.sayHello()); // error: Uncaught 没有定义该方法

    function Animal() {
        this.species = "动物";
    }
    function Cat(name, breed) {
        this.name = name;
        this.breed = breed;
    }
    let cat1 = new Cat("咪咪", "加菲猫")

    function Cat(name,breed){
　　　　Animal.apply(this, arguments);
　　　　this.name = name;
　　　　this.breed = breed;
　　}
　　let cat1 = new Cat("咪咪", "加菲猫")
　　console.log(cat1.species); // 动物

    Cat.prototype = new Animal();
    console.log(cat1.species); // 动物
    console.log(cat1.constructor); // Animal

    Cat.prototype.constructor = Cat;
    console.log(cat1.constructor); // Cat

    // 改写Animal
    function Animal() {}
    Animal.prototype.species = "动物";
    Cat.prototype = Animal.prototype;
    Cat.prototype.constructor = Cat;
    let cat1 = new Cat("咪咪", "加菲猫")
    console.log(cat1.species); // 动物

    Cat.prototype.constructor = Cat;
    console.log(Animal.constructor); // Cat
    // 这段代码同时也会修改 Animal 的 constructor

    let Foo = function(){};
    Foo.prototype = Animal.prototype;
    Cat.prototype = new F();
    at.prototype.constructor = Cat;
    let cat1 = new Cat("咪咪", "加菲猫");
    console.log(cat1.species); // 动物
    console.log(Animal.constructor); // Animal

    function Animal() {};
    Animal.prototype.species = "动物";
    function extend_1 (Child, Parent) {
        let p = Parent.prototype;
        let c = Child.prototype;
        for (let i in p) {
            c[i] = p[i]
        }
    }
    extent_1(Cat, Animal);
    let cat1 = new Cat("咪咪", "加菲猫");
    console.log(cat1.species); // 动物

    let Chinese = {
        nation: '**'
    };
    let Foo = function(){};
    Foo.prototype = Chinese;
    let Doctor = new F();
    Doctor.career = "医生";

function checkDataType(obj){ 
    if(Object.prototype.toString.call(obj) === '[object Array]') return "Array";
    if(Object.prototype.toString.call(obj) === '[object Object]') return "Object";
    if(Object.prototype.toString.call(obj) === '[object Function]') return "Function";
    if(Object.prototype.toString.call(obj) === '[object String]') return "String";
    if(Object.prototype.toString.call(obj) === '[object Number]') return "Number";
    if(Object.prototype.toString.call(obj) === '[object Boolean]') return "Boolean";
    if(Object.prototype.toString.call(obj) === '[object Symbol]') return "Symbol";
    if(Object.prototype.toString.call(obj) === '[object Undefined]') return "Undefined";
    if(Object.prototype.toString.call(obj) === '[object Date]') return "Date";
    if(Object.prototype.toString.call(obj) === '[object Math]') return "Math";
    if(Object.prototype.toString.call(obj) === '[object Set]') return "Set";
    if(Object.prototype.toString.call(obj) === '[object Map]') return "Map";
}    

~42 // -(42+1) ===> -43

const str = 'hello world'
~str.indexOf('lo') // -4，真值
if (~str.indexOf('lo')) {
  // true
  // 找到匹配
}
~str.indexOf('ol') // 0，假值
!~str.indexOf('ol') // true
if (!~str.indexOf('ol')) {
  // true
  // 没有找到匹配
}

Math.floor(1.9) // 1
~~1.9 // 1
// 操作负数
Math.floor(-1.9) // -2
~~-1.9 // -1

~~1.9 // 1
1.9 | 0 // 1

~~-1.9 // -1
;-1.9 | 0 // -1

// 取数据
let {data: arr} = data;
// 取出name, 转成数组
let nameArr = arr.map(item => item.name.split("-"))
// 将name的数组转换为需要的格式
let cc = nameArr.map(item => mapArrToObj(item))
// 合并相同name的数组
let dd = composeRepeatItem(cc)
// 将其他字段添加到数据当中
let eee = appendOtherKeys(arr, dd)
console.log(eee, "eee")

// 将数组转化为树状对象格式
function mapArrToObj(arr) {
    let obj = {}, i= 0;
    obj.label = arr[i];
    i++;
    if(i < arr.length) {
        loopChild(obj, arr, i)
    }
    return obj
}
// 判断对象中是否存在children，不存在则添加
function loopChild(obj ,arr, i) {
	if (!obj.children) {
        obj.children = [{label:arr[i]}];
        i++;
        if(i < arr.length) {
            loopChild(obj.children[0], arr, i)
        }
    }
}
// 合并相同label的数组
function composeRepeatItem(arr) {
    let newArr1 = [],  o = [], s = [];
    for (var i = 0; i < arr.length; i++) {
	let item = arr[i];
	if(newArr1.indexOf(item.label) === -1) {
	    newArr1.push(item.label)
	    o.push(item)
	}
    }
    for (var m = 0; m < arr.length; m++) {
	let arr_item = arr[m];
	for (var n = 0; n < o.length; n++) {
	    let o_item = o[n]
	    if(arr_item.label === o_item.label) {
		if(o_item.children) {
		    o_item.children.push(arr_item.children[0])
		}
	    }
	}
    }
    for (var k = 0; k < o.length; k++) {
	o[k].children && o[k].children.splice(0, 1);
	let o_item1 = o[i];
	if(o[k].children) {
	    o[k].children = composeRepeatItem(o[k].children)
	}
        s.push(o[k])
    }
    return s
}
// 将其他字段添加到数组中
function appendOtherKeys(arr, newArr) {
    for (var i = 0; i < arr.length; i++) {
    let arr_item = arr[i];
    let names = arr_item.name.split("-");
    for (var l = 0; l < newArr.length; l++) {
	    let new_arr_item = newArr[l];
            let index = 0;
 	    if(new_arr_item.label === names[index]) {
                loopToAppend(new_arr_item, names, index, arr_item)
            }
        }
    }
    return newArr
}
// 判断是否有children，有则继续执行函数，没有则添加字段
function loopToAppend(obj, names, index, arr_item) {
    if(obj.children) {
	    index ++;
	    for (var i = 0; i < obj.children.length; i++) {
                if(obj.children[i].label === names[index]) {
                loopToAppend(obj.children[i], names, index, arr_item)
            }
        }
    } else if(!obj.children) {
        obj.id = arr_item.id
        obj.disabled = arr_item.status !== 1
    }
}

{
  "plugins": [
    ["@babel/plugin-proposal-decorators", {
      "legacy": true
    }],
    ["@babel/plugin-proposal-class-properties", {
      "loose": true
    }]
  ]
}

@addProperty
class Person {}

function addProperty(target) {
  target.age = 18;
}
console.log(Person.age) // 18

var curry = (fn,...args) => {
    var func = args.length<fn.length?
    (...arguments) => curry(fn,...args,...arguments):
	fn(...args);
    return func;
}
	
function sumFn(a,b,c) {return a+b+c;}
var sum = curry(sumFn)
console.log(sum(2)(3)(5))

// Promise.map 的实现
if (!Promise.map) {
  Promise.map = function(vals, cb) {
    return Promise.all(
      vals.map(val => {
        return new Promise((resolve, reject) => {
          cb(val, resolve, reject)
        })
      })
    )
  }
}

// 测试
const p1 = Promise.resolve(21)
const p2 = 42
// const p3 = Promise.reject('failed')
Promise.map([p1, p2], function(val, done, failed) {
  // 保证 val 是 Promise，统一格式
  Promise.resolve(val).then(res => {
   done(res * 2)
  //  捕获失败的情况
  }, failed)
}).then(result => {
  console.log(result, 'result')
}).catch(error => {
  console.log(error, 'error')
})

// 最终输出结果是，如果加上一个失败的 promise 该函数也是可以捕获的哦
// [42, 84]