const add1 = (num) => {
  return num + 1;
};

const mul5 = (num) => {
  return num * 5;
};

const sub8 = (num) => {
  return num - 8;
};

const compose = function (...args) {
  return function (num) {
    return args.reduceRight((res, cb) => cb(res), num);
  };
};

console.log(compose(sub8, mul5, add1)(1));  // 2

const add1 = (num) => {
  return num + 1;
};

const mul5 = (num) => {
  return num * 5;
};

const sub8 = (num) => {
  return num - 8;
};

const compose = function (...args) {
  return function (num) {
    return args.reduce((res, cb) => cb(res), num);
  };
};

console.log(compose(sub8, mul5, add1)(1)); // -34

Array.prototype.myForEach = function (callBackFn, thisArg) {
  if (typeof callBackFn !== "function") {
    throw new Error("callBackFn must be function");
  }

  thisArg = thisArg || this;
  const len = thisArg.length;
  for (let i = 0; i < len; i++) {
    callBackFn.call(thisArg, thisArg[i], i, thisArg);
  }
};

Array.prototype.myMap = function (callbackFn, thisArg) {
  if (typeof callbackFn !== "function") {
    throw new Error("callbackFn must be function");
  }

  const arr = [];
  thisArg = thisArg || this;
  const len = thisArg.length;

  for (let i = 0; i < len; i++) {
    arr.push(callbackFn.call(thisArg, thisArg[i], i, thisArg));
  }
  return arr;
};

Array.prototype.myFilter = function (callbackFn, thisArg) {
  if (typeof callbackFn !== "function") {
    throw new Error("must be function");
  }
  
  const len = this.length;
  thisArg = thisArg || this
  const _newArr = [];
  
  for (let i = 0; i < len; i++) {
    if (callbackFn.call(thisArg, thisArg[i], i, thisArg)) {
      if (typeof thisArg[i] === "object") {
        _newArr.push(Object.create(thisArg[i]));
      } else {
        _newArr.push(thisArg[i]);
      }
    }
  }
  return _newArr;
};

Object.prototype.filterProperty = function (callbackFn, thisArg) {
  if (typeof callbackFn !== "function") {
    throw new Error("must be function");
  }

  thisArg = thisArg || this;
  const propArray = [];
  for (let prop in thisArg) {
    if (callbackFn.call(thisArg, prop, thisArg[prop], thisArg)) {
      propArray.push(prop);
    }
  }
  return propArray;
};

foo.bind(obj,1,2)(3)
foo.bind(obj,1,2,3)

Function.prototype.myBind = function (thisArgs, ...args1) {
  thisArgs = Object(thisArgs)
  const _self = this;
  // const args1 = Array.prototype.slice.call(arguments, 1);
  return function (...args2) {
    // const args2 = Array.prototype.slice.call(arguments, 1);
    return _self.apply(thisArgs, args1.concat(args2));
  };
};

Function.prototype.myCall = function (thisArg, ...args) {
  if (thisArg) {
    thisArg = Object(thisArg);
  } else {
    thisArg = typeof window !== "undefined" ? window : global;
  }

  thisArg._fn = this;

  const result = thisArg._fn(...args);

  delete thisArg._fn;

  return result;
};

Function.prototype.myApply = function (thisArg, args) {
  if (thisArg) {
    thisArg = Object(thisArg);
  } else {
    thisArg = typeof window !== "undefined" ? window : global;
  }

  let result;
  if (!args) {
    result = thisArg._fn();
  } else {
    result = thisArg._fn(...args);
  }
  delete thisArg._fn;
  return result;
};

function foo(a,b,c,d) {
  return a + b + c + d
}

function bar(a) {
  return function(b) {
    return function(c) {
      return function(d) {
        return a + b + c + d
    }
  }
}
foo(1,2,3,4) // 10
bar(1)(2)(3)(4) // 10

const bar = a => b => c => d => a + b + c + d

function add (a,b,c) {
  a = a + 2
  b = b * 2
  c = -c
  return a + b + c
}

function add(a,b,c) {
  a = a + 2
  return function(b,c) {
    b = b * 2
    return function(c) {
      c = -c
      return a + b + c
    }
  }
}

function add(a,b){
  return a + b
}
add(5,1)
add(5,2)
add(5,3)
add(5,4)

function add(a,b) {
  // 復(fù)用的邏輯
  console.log("+",a)
  return function(b) {
    return a + b
  }
}

const add5 = add(5)
add5(2)
add5(3)
add5(5)

function currying(fn) {
    function curried(...args) {
    }
    return curried
}

function currying(fn) {
  function curried(...args) {
    // 判斷當(dāng)前已接收的參數(shù)個(gè)數(shù)是否與fn函數(shù)一致
    // 1.當(dāng)已經(jīng)傳入的參數(shù)數(shù)量 大于等于 需要的參數(shù)時(shí)，就執(zhí)行函數(shù)
    if(args.length >= fn.length) {
      return fn.apply(this, args)
    } else {
      // 2.沒(méi)達(dá)到個(gè)數(shù)時(shí)，需要返回一個(gè)新的函數(shù)，繼續(xù)來(lái)接受參數(shù)
      return function curried2(...args2) {
        // 接收到參數(shù)后，需要遞歸調(diào)用curried來(lái)檢查函數(shù)的個(gè)數(shù)是否達(dá)到
        return curried.apply(this, [...args, ...args2])
      }
    }
  }
  return curried
}

function add (a,b,c,d) {
  return a + b + c + d
}

const curryingFn = currying(add);
console.log(add(1, 2, 3, 4)); // 10
console.log(curryingFn(1)(2)(3)(4)); // 10
console.log(curryingFn(1, 2)(3)(4)); // 10
console.log(curryingFn(1, 2, 3)(4)); // 10
console.log(curryingFn(1, 2, 3, 4)); // 10

const debounceElement = document.getElementById("debounce");

const handleClick = function (e) {
  console.log("點(diǎn)擊了一次");
};

// debounce防抖函數(shù)
function debounce(fn, delay) {
  // 定一個(gè)定時(shí)器對(duì)象，保存上一次的定時(shí)器
  let timer = null
  // 真正執(zhí)行的函數(shù)
  function _debounce() {
    // 取消上一次的定時(shí)器
    if (timer) {
      clearTimeout(timer);
    }
    // 延遲執(zhí)行
    timer = setTimeout(() => {
      fn()
    }, delay);
  }
  return _debounce;
}

debounceElement.onclick = debounce(handleClick, 300);

const debounceElement = document.getElementById("debounce");

const handleClick = function (e) {
  console.log("點(diǎn)擊了一次", e, this);
};

function debounce(fn, delay) {
  let timer = null;
  function _debounce(...args) {
    if (timer) {
      clearTimeout(timer);
    }
    timer = setTimeout(() => {
      fn.apply(this, args) // 改變this指向 傳遞參數(shù)
    }, delay);
  }
  return _debounce;
}

debounceElement.onclick = debounce(handleClick, 300);

const debounceElement = document.getElementById("debounce");

const handleClick = function (e) {
  console.log("點(diǎn)擊了一次", e, this);
};

// 添加一個(gè)immediate參數(shù) 選擇是否立即調(diào)用
function debounce(fn, delay, immediate = false) {
  let timer = null;
  let isInvoke = false; // 是否調(diào)用過(guò)
  function _debounce(...args) {
    if (timer) {
      clearTimeout(timer);
    }

    // 如果是第一次調(diào)用 立即執(zhí)行
    if (immediate && !isInvoke) {
      fn.apply(this.args);
      isInvoke = true;
    } else {
      // 如果不是第一次調(diào)用 延遲執(zhí)行 執(zhí)行完重置isInvoke
      timer = setTimeout(() => {
        fn.apply(this, args);
        isInvoke = false;
      }, delay);
    }
  }
  return _debounce;
}

debounceElement.onclick = debounce(handleClick, 300, true);

const debounceElement = document.getElementById("debounce");
const cancelElemetnt = document.getElementById("cancel");

const handleClick = function (e) {
  console.log("點(diǎn)擊了一次", e, this);
};

function debounce(fn, delay, immediate = false) {
  let timer = null;
  let isInvoke = false; 
  function _debounce(...args) {
    if (timer) {
      clearTimeout(timer);
    }

    if (immediate && !isInvoke) {
      fn.apply(this.args);
      isInvoke = true;
    } else {
      timer = setTimeout(() => {
        fn.apply(this, args);
        isInvoke = false;
      }, delay);
    }
  }
	
  // 在_debounce新增一個(gè)cancel方法 用來(lái)取消定時(shí)器
  _debounce.cancel = function () {
    clearTimeout(timer);
    timer = null;
  };
  return _debounce;
}

const debonceClick = debounce(handleClick, 5000, false);
debounceElement.onclick = debonceClick;
cancelElemetnt.onclick = function () {
  console.log("取消了事件");
  debonceClick.cancel();
};

const debounceElement = document.getElementById("debounce");
const cancelElemetnt = document.getElementById("cancel");

const handleClick = function (e) {
  console.log("點(diǎn)擊了一次", e, this);
  return "handleClick返回值";
};

function debounce(fn, delay, immediate = false) {
  let timer = null;
  let isInvoke = false;
  function _debounce(...args) {
    return new Promise((resolve, reject) => {
      if (timer) clearTimeout(timer);

      if (immediate && !isInvoke) {
        try {
          const result = fn.apply(this, args);
          isInvoke = true;
          resolve(result); // 正確的回調(diào)
        } catch (err) {
          reject(err); // 錯(cuò)誤的回調(diào)
        }
      } else {
        timer = setTimeout(() => {
          try {
            const result = fn.apply(this, args); 
            isInvoke = false;
            resolve(result); // 正確的回調(diào)
          } catch (err) {
            reject(err); // 錯(cuò)誤的回調(diào)
          }
        }, delay);
      }
    });
  }

  _debounce.cancel = function () {
    clearTimeout(timer);
    timer = null;
  };
  return _debounce;
}

const debonceClick = debounce(handleClick, 300, true);
// 創(chuàng)建一個(gè)debonceCallBack用于測(cè)試返回的值
const debonceCallBack = function (...args) {
  debonceClick.apply(this, args).then((res) => {
    console.log({ res });
  });
};

debounceElement.onclick = debonceCallBack;
cancelElemetnt.onclick = () => {
  console.log("取消了事件");
  debonceClick.cancel();
};

const handleMove = () => {
  console.log("監(jiān)聽(tīng)了一次鼠標(biāo)移動(dòng)事件");
};

const throttle = function (fn, interval) {
  // 記錄當(dāng)前事件觸發(fā)的時(shí)間
  let nowTime;
  // 記錄上次觸發(fā)的時(shí)間
  let lastTime = 0;

  // 事件觸發(fā)時(shí)，真正執(zhí)行的函數(shù)
  function _throttle() {
    // 獲取當(dāng)前觸發(fā)的時(shí)間
    nowTime = new Date().getTime();
    // 當(dāng)前觸發(fā)時(shí)間減去上次觸發(fā)時(shí)間大于設(shè)定間隔
    if (nowTime - lastTime > interval) {
      fn();
      lastTime = nowTime;
    }
  }

  return _throttle;
};

document.onmousemove = throttle(handleMove, 1000);

const handleMove = (e) => {
	console.log("監(jiān)聽(tīng)了一次鼠標(biāo)移動(dòng)事件", e, this);
};

const throttle = function (fn, interval) {
  let nowTime;
  let lastTime = 0;

  function _throttle(...args) {
    nowTime = new Date().getTime();
    if (nowTime - lastTime > interval) {
      fn.apply(this, args);
      lastTime = nowTime;
    }
  }

  return _throttle;
};

document.onmousemove = throttle(handleMove, 1000);

const handleMove = (e) => {
  console.log("監(jiān)聽(tīng)了一次鼠標(biāo)移動(dòng)事件", e, this);
};

const throttle = function (fn, interval, leading = true) {
  let nowTime;
  let lastTime = 0;

  function _throttle(...args) {
    nowTime = new Date().getTime();

    // leading為flase表示不希望立即執(zhí)行函數(shù) 
    // lastTime為0表示函數(shù)沒(méi)執(zhí)行過(guò)
    if (!leading && lastTime === 0) {
      lastTime = nowTime;
    }

    if (nowTime - lastTime > interval) {
      fn.apply(this, args);
      lastTime = nowTime;
    }
  }

  return _throttle;
};

document.onmousemove = throttle(handleMove, 3000, false);

const handleMove = (e) => {
  console.log("監(jiān)聽(tīng)了一次鼠標(biāo)移動(dòng)事件", e, this);
};

// trailing用來(lái)選擇最后一次是否執(zhí)行
const throttle = function (fn,interval,leading = true,trailing = false) {
  let nowTime;
  let lastTime = 0;
  let timer;

  function _throttle(...args) {
    nowTime = new Date().getTime();
    // leading為flase表示不希望立即執(zhí)行函數(shù)
    // lastTime為0表示函數(shù)沒(méi)執(zhí)行過(guò)
    if (!leading && lastTime === 0) {
      lastTime = nowTime;
    }

    if (timer) {
      clearTimeout(timer);
      timer = null;
    }

    if (nowTime - lastTime >= interval) {
      fn.apply(this, args);
      lastTime = nowTime;
      return;
    }
		
    // 如果選擇了最后一次執(zhí)行 就設(shè)置一個(gè)定時(shí)器
    if (trailing && !timer) {
      timer = setTimeout(() => {
        fn.apply(this, args);
        timer = null;
        lastTime = 0;
      }, interval - (nowTime - lastTime));
    }
  }

  return _throttle;
};

document.onmousemove = throttle(handleMove, 3000, true, true);

// 深拷貝函數(shù)，參數(shù)是一個(gè)待拷貝的對(duì)象
function deepClone(originValue) {
  // 如果傳入的是null或者不是對(duì)象類型， 那么直接返回
  if(originValue == null || typeof originValue !== 'object') {
    return originValue
  }
    
  // 創(chuàng)建一個(gè)新對(duì)象，遞歸拷貝屬性
  const newObj = {}
  for(const key in originValue) {
  // 不拷貝原型上的
    if(originValue.hasOwnProterty(key)) {
        newObj[key] = deepClone(originValue[key])
    }
  }
  
  return newObj
}

const obj = {
  name: 'zhangsan',
  address: {
    city: 'hangzhou'
  }
}

const newObj = deepClone(obj)
obj.address.city = 'beijing'
console.log(newObj) // { name: 'zhangsan', address: { city: 'hangzhou' } }

function deepClone(originValue) {
  if(originValue == null || typeof originValue !== 'object') {
    return originValue
  }

  // 判斷傳入的是數(shù)組還是對(duì)象
  const newObj = Array.isArray(originValue) ? [] : {}
  for(const key in originValue) {
    newObj[key] = deepClone(originValue[key])
  }

  return newObj
}

const obj = {
  name: 'zhangsan',
  address: {
    city: 'hangzhou'
  },
  friends: ['zhangsan', 'lisi']
}


const newObj = deepClone(obj)
obj.address.city = 'beijing'
obj.friends[0] = 'wangwu'
console.log(newObj) 
// {
//  name: 'zhangsan',
//  address: { city: 'hangzhou' },
//  friends: [ 'zhangsan', 'lisi' ]
//}

function deepClone(originValue) {
  // 判斷是否是函數(shù)類型
  if (originValue instanceof Function) {
    // 將函數(shù)轉(zhuǎn)成字符串
    let str = originValue.toString()
    // 截取函數(shù)體內(nèi)容字符串
    let subStr = str.substring(str.indexOf("{"), 1, str.lastIndexOf("}"))
    // 利用截取函數(shù)體內(nèi)容的字符串和函數(shù)的構(gòu)造器重新生成函數(shù)并返回
    return new Function(subStr)
  }

  if(originValue == null || typeof originValue !== 'object') {
    return originValue
  }

  // 判斷傳入的是數(shù)組還是對(duì)象
  const newObj = Array.isArray(originValue) ? [] : {}
  for(const key in originValue) {
    newObj[key] = deepClone(originValue[key])
  }

  return newObj
}

const obj = {
  foo: function () {
    console.log("function");
  },
};

const newObj = deepClone(obj);

console.log(obj.foo === newObj.foo); // false

function deepClone(originValue) {

  // 判斷是否是函數(shù)類型
  if (originValue instanceof Function) {
    // 將函數(shù)轉(zhuǎn)成字符串
    let str = originValue.toString()
    // 截取函數(shù)體內(nèi)容字符串
    let subStr = str.substring(str.indexOf("{"), 1, str.lastIndexOf("}"))
    // 利用截取函數(shù)體內(nèi)容的字符串和函數(shù)的構(gòu)造器重新生成函數(shù)并返回
    return new Function(subStr)
  }
  
  // 判斷是否是Date類型
  if(originValue instanceof Date) {
    return new Date(originValue.getTime())
  }

  // 判斷是否是Set類型(淺拷貝)
  if(originValue instanceof Set) {
    return new Set([...originValue])
  }

  // 判斷是否是Map類型(淺拷貝)
  if(originValue instanceof Map) {
    return new Map([...originValue])
  }

  if(originValue == null && typeof originValue !== 'object') {
    return originValue
  }

  const newObj = Array.isArray(originValue) ? [] : {}
  for(const key in originValue) {
    newObj[key] = deepClone(originValue[key])
  }

  return newObj
}

const obj = {
  name: 'zhangsan',
  address: {
    city: 'hangzhou'
  },
  friends: ['zhangsan', 'lisi'],
  set: new Set([1,2,3]),
  map: new Map([['aaa',111], ['bbb', '222']]),
  createTime: new Date()
}

const newObj = deepClone(obj)
console.log(newObj.set === obj.set)  // false
console.log(newObj.map === obj.map) // false
console.log(newObj.createTime === obj.createTime) // false

function deepClone(originValue) {

  // 判斷是否是函數(shù)類型
  if (originValue instanceof Function) {
    // 將函數(shù)轉(zhuǎn)成字符串
    let str = originValue.toString()
    // 截取函數(shù)體內(nèi)容字符串
    let subStr = str.substring(str.indexOf("{"), 1, str.lastIndexOf("}"))
    // 利用截取函數(shù)體內(nèi)容的字符串和函數(shù)的構(gòu)造器重新生成函數(shù)并返回
    return new Function(subStr)
  }
  
  // 判斷是否是Date類型
  if(originValue instanceof Date) {
    return new Date(originValue.getTime())
  }

  // 判斷是否是Set類型(淺拷貝)
  if(originValue instanceof Set) {
    return new Set([...originValue])
  }

  // 判斷是否是Map類型(淺拷貝)
  if(originValue instanceof Map) {
    return new Map([...originValue])
  }

  // 判斷是否是Smybol類型
  if(typeof originValue === 'symbol') {
    return Symbol(originValue.description)
  }

  if(originValue == null && typeof originValue !== 'object') {
    return originValue
  }

  const newObj = Array.isArray(originValue) ? [] : {}
  for(const key in originValue) {
    newObj[key] = deepClone(originValue[key])
  }

  // 對(duì)key是Symbol做處理
  const symbolKeys = Object.getOwnPropertySymbols(originValue)
  for(const key of symbolKeys) {
    newObj[key] = deepClone(originValue[key])
  }

  return newObj
}

const s1 = Symbol('aaa')
const s2 = Symbol('bbb')
const obj = {
  name: 'zhangsan',
  address: {
    city: 'hangzhou'
  },
  friends: ['zhangsan', 'lisi'],
  set: new Set([1,2,3]),
  map: new Map([['aaa',111], ['bbb', '222']]),
  createTime: new Date(),
  eating: function() {
    console.log(this.name + ' is eating')
  },
  s1: s1,
  [s2]: {a: 1}
}

const newObj = deepClone(obj)

console.log(obj.s1 === newObj.s1) // flase
console.log(obj[s2] === newObj[s2]) // false

// 參數(shù)中設(shè)置一個(gè)WeakMap用來(lái)保存
function deepClone(originValue, map = new WeakMap()) {

  // 判斷是否是函數(shù)類型
  if (originValue instanceof Function) {
    // 將函數(shù)轉(zhuǎn)成字符串
    let str = originValue.toString()
    // 截取函數(shù)體內(nèi)容字符串
    let subStr = str.substring(str.indexOf("{"), 1, str.lastIndexOf("}"))
    // 利用截取函數(shù)體內(nèi)容的字符串和函數(shù)的構(gòu)造器重新生成函數(shù)并返回
    return new Function(subStr)
  }
  
  // 判斷是否是Date類型
  if(originValue instanceof Date) {
    return new Date(originValue.getTime())
  }

  // 判斷是否是Set類型(淺拷貝)
  if(originValue instanceof Set) {
    return new Set([...originValue])
  }

  // 判斷是否是Map類型(淺拷貝)
  if(originValue instanceof Map) {
    return new Map([...originValue])
  }

  // 判斷是否是Smybol類型
  if(typeof originValue === 'symbol') {
    return Symbol(originValue.description)
  }

  if(originValue == null && typeof originValue !== 'object') {
    return originValue
  }

  // 判斷之前是否存過(guò)，如果有則直接獲取返回
  if(map.has(originValue)) {
    return map.get(originValue)
  }

  const newObj = Array.isArray(originValue) ? [] : {}
  // 創(chuàng)建的newObj放到map里
  map.set(originValue, newObj)
  for(const key in originValue) {
    newObj[key] = deepClone(originValue[key], map)
  }

  // 對(duì)key是Symbol做處理
  const symbolKeys = Object.getOwnPropertySymbols(originValue)
  for(const key of symbolKeys) {
    newObj[key] = deepClone(originValue[key], map)
  }

  return newObj
}

const s1 = Symbol('aaa')
const s2 = Symbol('bbb')
const obj = {
  name: 'zhangsan',
  address: {
    city: 'hangzhou'
  },
  friends: ['zhangsan', 'lisi'],
  set: new Set([1,2,3]),
  map: new Map([['aaa',111], ['bbb', '222']]),
  createTime: new Date(),
  eating: function() {
    console.log(this.name + ' is eating')
  },
  s1: s1,
  [s2]: {a: 1}
}

obj.info= obj
const newObj = deepClone(obj)
console.log(newObj)

function _new(TargetClass, ...args) {
  // 1. 創(chuàng)建空對(duì)象，并將新對(duì)象的__proto__屬性指向構(gòu)造函數(shù)的prototype
  const obj = Object.create(TargetClass.prototype)
  // 2. 將這個(gè)新對(duì)象綁定到函數(shù)的this上，執(zhí)行構(gòu)造函數(shù)
  const ret =TargetClass.apply(obj, args)
  return typeof ret === "object" ? ret : obj;
}


// 測(cè)試 
function Foo(name) {
  this.name = name;
}
Foo.prototype.sayHello = function () {
  console.log("this is " + this.name);
};
const f = _new(Foo, "hello");
f.sayHello(); // this is hello
console.log(f); // Foo { name: 'hello' }

// 父類: 公共屬性和方法
function Person() {
  this.name = "yjw"
}

// 父類定義一個(gè)吃的方法
Person.prototype.eating = function() {
  console.log(this.name + ' is eating')
}

// 子類: 特有屬性和方法
function Student() {
  this.sno = '001'
}

// Student的原型對(duì)象指向一個(gè)Person的實(shí)例對(duì)象per
const per = new Person()
Student.prototype = per

// 子類定義一個(gè)學(xué)習(xí)的方法
Student.prototype.studying = function() {
  console.log(this.name + ' is studying')
}


const stu = new Student()

console.log(stu)
console.log(stu.name) // stu對(duì)象中沒(méi)有name屬性 會(huì)去他的原型對(duì)象per上找 per對(duì)象上有name屬性
stu.eating()	// stu對(duì)象中沒(méi)有eating方法 會(huì)去他的原型對(duì)象per上找per對(duì)象上也沒(méi)eating方法 再往上去per的原型對(duì)象上找 per的原型對(duì)象上有eating方法
stu.studying()

// 父類: 公共屬性和方法
function Person(name) {
  this.name = name
}

// 父類定義一個(gè)吃的方法
Person.prototype.eating = function() {
  console.log(this.name + ' is eating')
}

// 子類: 特有屬性和方法
function Student(name, sno) {
  // 借用了父類的構(gòu)造函數(shù)
  Person.call(this, name)
  this.sno = sno
}

// Student的原型對(duì)象指向一個(gè)Person的實(shí)例對(duì)象per
const per = new Person()
Student.prototype = per

// 子類定義一個(gè)學(xué)習(xí)的方法
Student.prototype.studying = function() {
  console.log(this.name + ' is studying')
}

// 父類: 公共屬性和方法
function Person(name) {
  this.name = name
}

// 父類定義一個(gè)吃的方法
Person.prototype.eating = function() {
  console.log(this.name + ' is eating')
}

// 子類: 特有屬性和方法
function Student(name, sno) {
  // 借用了父類的構(gòu)造函數(shù)
  Person.call(this, name)
  this.sno = sno
}

Student.prototype = Object.create(Person.prototype) // 原型式繼承 不用new Person()多調(diào)用父類構(gòu)造函數(shù)了
Object.defineProperty(Student.prototype, "constructor", {
  enumerable: false,
  configurable: true,
  writable: true,
  value: Student
}) // 改構(gòu)造函數(shù)名稱

// 子類定義一個(gè)學(xué)習(xí)的方法
Student.prototype.studying = function() {
  console.log(this.name + ' is studying')
}

// 上面的 Object.create(Person.prototype) 也可以寫(xiě)成

Object.setPrototypeOf(Student.prototype, Person.prototype)

// 也可以寫(xiě)成
function object(o) {
  function F() {}
  F.prototype = o
  return new F()
}

Student.prototype = object(Person.prototyp)

class MyPromise {
  /**
   * Promise規(guī)范定義 構(gòu)造函數(shù)接收一個(gè)回調(diào)函數(shù)executor作為參數(shù)
   * 這個(gè)executor回調(diào)函數(shù)又接收兩個(gè)回調(diào)函數(shù)作為參數(shù) 一個(gè)是resolve（成功時(shí)回調(diào)） 一個(gè)是reject（時(shí)表示回調(diào)）
   */
  constructor(executor) {
    // Promise 三種狀態(tài) 分別是pending（進(jìn)行中）、fulfilled（已成功）和rejected（已失敗）
    this.status = 'pending' 
    this.value = undefined
    this.reason = undefined

    const resolve = (value) => {
      if(this.status === 'pending') {
        // 調(diào)用resolve 狀態(tài)改為fulfilled
        this.status = 'fulfilled'
        // 保存resolve回調(diào)的參數(shù)
        this.value = value
      }
    }

    const reject = (reason) => {
      if(this.status === 'pending') {
       // reject 狀態(tài)改為rejected
        this.status = 'rejected'
        // 保存reject回調(diào)的參數(shù)
        this.reason = reason
      }
    }
		
    // 傳入的回調(diào)函數(shù)是會(huì)直接執(zhí)行的
    executor(resolve,reject)
  }

}

class MyPromise {
  constructor(executor) {
    this.status = 'pending' 
    this.value = undefined
    this.reason = undefined

    const resolve = (value) => {
      if(this.status === 'pending') {
        // 延遲調(diào)用（微任務(wù)）
        queueMicrotask(() => {
        	this.status = 'fulfilled'
          this.value = value
          this.onFulfilled && this.onFulfilled(this.value)
        }, 0)
      }
    }

    const reject = (reason) => {
      if(this.status === 'pending') {
        // 延遲調(diào)用（微任務(wù)）
        queueMicrotask(() => {
        	this.status = 'rejected'
          this.reason = reason
          this.onRejected && this.onRejected(this.reason)
        }, 0)
      }
    }
		
    executor(resolve,reject)
  }

  then(onFulfilled, onRejected) {
    onFulfilled && this.onFulfilled = onFulfilled
    onRejected && this.onRejected = onRejected
  }
}

const promise = new MyPromise((resolve, reject) => {
  resolve('resolve')
  reject('reject')
})


promise.then(res => {
  console.log({res})
}, err => {
  console.log({err})
})

setTimeout(() => {
	promise.then(res =>{
		console.log({res})
	})
}, 10000)

// 封裝一個(gè)函數(shù)
const execFunctionWithCatchError = (exeFn, value, resolve, reject) => {
  try {
    const result = exeFn(value)
    resolve(result)
  } catch(err) {
    reject(err)
  }
}


class MyPromise {
  constructor(executor) {
    this.status = 'pending' 
    this.value = undefined
    this.reason = undefined
    this.onFulfilledFns = []
    this.onRejectFns = []

    const resolve = (value) => {
      if(this.status === 'pending') {
        queueMicrotask(() => {
          if(this.status !== 'pending') return 
          this.status = 'fulfilled'
          this.value = value
          this.onFulfilledFns.forEach(fn => {
            fn && fn(this.value)
          })
        }, 0)
      }
    }

    const reject = (reason) => {
      if(this.status === 'pending') {
        queueMicrotask(() => {
          if(this.status !== 'pending') return 
          this.status = 'rejected'
          this.reason = reason
          this.onRejectFns.forEach(fn => {
            fn && fn(this.reason)
          })
        }, 0)
      }
    }
		
    try {
      executor(resolve,reject)
    } catch(err) {
      reject(err)
    }
  }

  then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) => {
      // 如果在then調(diào)用的時(shí)候狀態(tài)已經(jīng)確定下來(lái)，直接調(diào)用
      if(this.status === 'fulfilled' && onFulfilled) {
        execFunctionWithCatchError(onFulfilled, this.value, resolve, reject)
      }

      // 如果在then調(diào)用的時(shí)候狀態(tài)已經(jīng)確定下來(lái)，直接調(diào)用
      if(this.status === 'rejected' && onRejected) {
        execFunctionWithCatchError(onRejected, this.reason, resolve, reject)
      }

      if(this.status === 'pending') {
        // 將成功的回調(diào)和失敗的回調(diào)都放到數(shù)組中
        if(onFulfilled) this.onFulfilledFns.push(() => {
          execFunctionWithCatchError(onFulfilled, this.value, resolve, reject)
        })
        if(onRejected) this.onRejectFns.push(() => {
          execFunctionWithCatchError(onRejected, this.reason, resolve, reject)
        })
      }
    })
  }
}

catch(onRejected) {
  return this.then(undefined, onRejected)
}

then(onFulfilled, onRejected) {
  // 當(dāng)onRejected為空時(shí) 我們手動(dòng)拋出一個(gè)錯(cuò)誤
  onRejected = onRejected || (err => { throw err })
  return new  return new MyPromise((resolve, reject) => {
    	...
  })
}

finally(onFinally) {
  // 不管成功和失敗都調(diào)用onFinally
  this.then(onFinally, onFinally)
}

then(onFulfilled, onRejected) {
  // 當(dāng)onRejected為空時(shí) 我們手動(dòng)拋出一個(gè)錯(cuò)誤
  onRejected = onRejected || (err => { throw err })
   // 當(dāng)onFulfilled為空時(shí) 將上一個(gè)promise的value傳下去
  onFulfilled = onFulfilled || (value => value)
  return new  return new MyPromise((resolve, reject) => {
    	...
  })
}

static resolve(value) {
    return new MyPromise((resolve) => resolve(value))
}

static reject(reason) {
    return new MyPromise((resolve, reject) => reject(reason))
}

static all(promises) {
  return new MyPromise((resolve, reject) => {
    const values = []
    promises.forEach(promise =>  {
      promise.then(res => {
        values.push(res)
        if(values.length === promises.length) {
          resolve(values)
        }
      }, err => {
        reject(err)
      })
    })
  })
}

static allSettled(promises) {
  return new MyPromise((resolve, reject) => {
    const result = []
    promises.forEach(promise =>  {
      promise.then(res => {
        result.push({state: 'resolved', value: res})
        if(result.length === promises.length) {
          resolve(result)
        }
      }, err => {
        result.push({state: 'rejected', reason: err})
        if(result.length === promises.length) {
          resolve(result)
        }
      })
    })
  })
}

static race(promises) {
  return new MyPromise((resolve, reject) => {
    promises.forEach(promise =>  {
      promise.then(res => {
        resolve(res)
      }, err => {
        reject(err)
      })
    })
  })
}

static any(promises) {
  return new MyPromise((resolve, reject) => {
    const reasons = []
    promises.forEach(promise =>  {
      promise.then(res => {
        resolve(res)
      }, err => {
        reasons.push(err)
        if(reasons.length === promises.length) {
          reject(reasons)
        }
      })
    })
  })
}