/* 先将传入的指定执行环境的对象 context 取到
将需要执行的方法(调用call的对象) 作为 context 的一个属性方法fn
处理传入的参数， 并执行 context的属性方法fn， 传入处理好的参数
删除私自定义的 fn 属性
返回执行的结果 */
// 模拟 call 方法
Function.prototype.defineCall = function (context) {
    context = context || window;
    context.fn = this; //this指向 sayName函数实例
    let args = [];
    for (let i = 1; i < arguments.length; i++) { //i从1开始 
        args.push(arguments[i]);
    } //或者args = [...arguments].slice(1);
    let result = context.fn(args.join(','));
    delete context.fn;
    return result;
}
let sayName = function (age) {
    console.log('current name: ' + this.name, "current age: " + age);
}
let obj1 = {
    name: "obj's name"
}
sayName.defineCall(obj1, 22); //this指向 sayName函数实例
// current name: obj's name current age: 22


// 模拟 apply 方法
Function.prototype.defineApply = function (context, arr) {
    context = context || window;
    context.fn = this;
    let result;
    if (!arr) { // 第二个参数不传
        result = context.fn();
    } else { // 第二个参数是数组类型
        let args = [];
        for (let i = 0; i < arr.length; i++) { //i从0开始
            args.push(arr[i]);
        }
        result = context.fn(args.join(','));
    }
    delete context.fn;
    return result;
}
let obj2 = {
    name: ['Tom', 'Johy', 'Joe', 'David']
}
sayName.defineApply(obj2, [3, 4, 5, 6, 7]);
// current name: Tom,Johy,Joe,David current age: 3,4,5,6,7


//用call、apply模拟实现bind
Function.prototype.bind = function (context) {
    let self = this; // 保存函数的引用
    return function () { // 返回一个新的函数
        // console.log(arguments);
        // return self.apply(context, arguments);
        return self.call(context, arguments);
    }
};

let obj = {
    name: 'seven'
}

let func = function () {
    console.log(this.name)
}.bind(obj);
func('zhangsan', 20);

function debounce(fn, delay) {//防抖
  // 维护一个 timer，用来记录当前执行函数状态
  let timer = null;

  return function() {
    // 通过 ‘this’ 和 ‘arguments’ 获取函数的作用域和变量
    let context = this;
    let args = arguments;
    // 清理掉正在执行的函数，并重新执行
    clearTimeout(timer);
    timer = setTimeout(function() {
      fn.apply(context, args);
    }, delay);
  }
}
let flag = 0; // 记录当前函数调用次数
// 当用户滚动时被调用的函数
function foo() {
  flag++;
  console.log('Number of calls: %d', flag);
}

// 在 debounce 中包装我们的函数，过 2 秒触发一次
document.body.addEventListener('scroll', debounce(foo, 2000));

function throttle(func, delay){//节流
  let timer = null;

  return function(){
    let context = this;
    let args    = arguments;
    if(!timer){
      timer = setTimeout(function(){
        func.apply(context, args);
        timer = null;
      }, delay);
    }
  }
}

//第一种：JSON.parse(JSON.stringify())方法实现深拷贝
var obj={a:"hello",b:1,c:true,d:[1,2],e:{x:1,y:2},f:function(){console.log("copytest");},g:null,h:undefined};
var copyobj=JSON.parse(JSON.stringify(obj));
console.log(copyobj);
copyobj.a="change";
copyobj.d[0]=9;
copyobj.e.x=8;
console.log(obj);


//第二种：递归的方法实现深拷贝
function deepclone(obj,copyobj){
    var copyobj=copyobj||{};
    for (var keys in obj) { //使用for..in进行遍历   数组的话keys为0,1..... keys是string类型
        if(obj.hasOwnProperty(keys)){//剥离原型链的数据
            if((typeof(obj[keys])) ==='object' && obj[keys]!==null){//判断是否为引用数据类型
                if (Object.prototype.toString.call(obj[keys]) === '[object Array]') { //Object原型方法得到类型
                    copyobj[keys]=[];
                }else{
                    copyobj[keys]={};
                }
                deepclone(obj[keys],copyobj[keys]);
            }else{
                copyobj[keys]=obj[keys];
            }
        }
    }
    return copyobj;
}

// 嵌套数组指定层次展开   flat扁平化
// 1. 普通方法 递归
function flattenMd() {
    let result = []
    return function flatten(arr) {//闭包
        arr.forEach(item => {
            if (Array.isArray(item)) {
                flatten(item)
            } else {
                result.push(item)
            }
        })
        return result
    }
}
// var ary = [1, [2, [3, [4, 5]]], 6]
// flattenMd()(ary);  函数柯里化  部分求值

//2.concat  与方法1类似 没用闭包
function flattenMd(arr) {
    let result = [] // 利用函数作用域保存result var result = []也可
    arr.forEach(item => {
        if (Array.isArray(item)) {
            result = result.concat(flattenMd(item))
        } else {
            result.push(item)
        }
    })
    return result
}

//3. reduce 
function flattenMd(arr) { //.concat([3,4])和.concat(3,4)均可
    return arr.reduce((prev, item) => prev.concat(Array.isArray(item) ? flattenMd(item) : item), [])
}

// 4. 展开运算符
function flattenMd(arr) {
    let flatten = arr => [].concat(...arr)//可去掉一层[]
    return flatten(arr.map(item => Array.isArray(item) ? flattenMd(item) : item))
}

// 5. join和split组合（ 只适用字符串数组， 最简单粗暴）
//[ '1', '2', '3', '4', '5', '6' ] 得到的是字符串数组  再转换一下才行
function flattenMd(arr) {
    return arr.join().split(',')
    //join() 方法用于把数组中的所有元素放入一个字符串 默认用,隔开
}

//reduce（）函数接受两个参数，一个函数一个累积变量的初始值。
//函数有四个参数：累计变量初值（默认第一个成员），当前变量值（默认第二个成员），当前位置，数组自身。
//arr.reduce(function(prev, cur, index, arr){}, initialValue)
Array.prototype.myReduce=function(fn,base){
    if(typeof fn !== 'function'){
        throw new TypeError("arguments[0] is not a function");//TypeError是错误的类型之一：类型错误
    }

    var initialArr=this;//调用myReduce()函数的当前对象
    var arr=initialArr.concat();//目的是返回一个等于初始数组的新数组，后面的操作都基于arr，这样初始数组不会发生改动
    var index,newValue;
    
    if(arguments.length==2){
        arr.unshift(base);
        index = 0; //！！当前位置 指的是当前变量（第二个参数）针对调用该方法的数组位置即initialArr
    }else{
        index=1;
    }

    if(arr.length===1){//长度为1 直接返回
        newValue=arr[0];
    }

    while(arr.length>1){
        newValue=fn.call(null,arr[0],arr[1],index,initialArr);
        index++;
        arr.splice(0,2,newValue);//删除前两位 然后把累加值添加到第一位
    }
    return newValue;
};

// 模拟实现map
// arr.map(function (currentValue, index, arr) {
// })
// currentValue 必须。 当前元素的值
// index 可选。 当期元素的索引值
// arr 可选。 当期元素属于的数组对象

Array.prototype.newMap = function (fn) { //写法一
    var newArr = [];
    for (var i = 0; i < this.length; i++) {
        newArr.push(fn(this[i], i, this)) //this指向调用newMap方法的数组
    }
    return newArr;
}

// arr.reduce((previousValue, currentValue, currentIndex, array) => {}, initialValue？)
// reduce若不指定初始值， 那么第一次迭代的 previousValue 为 ar[[0], currentValue 为 arr[1], currentIndex 为 1，
// 若指定初始值， 那么第一次迭代的 previousValue 为 initialValue, currentValue为 arr[0], currentIndex 为0.

Array.prototype.newMap = function (fn, Arg) { ////写法二：用数组的reduce方法实现数组的map
    var res = [];
    this.reduce((prev, curr, index, array) => {
        res.push(fn.call(Arg, curr, index, array));
    }, 0) //指定初始值initialValue=0，所以从currentIndex=0开始，即第一个开始  不这样会缺第一项，结果为[3,4]
    return res;
}


let arr = [1, 2, 3];
let res = arr.newMap((a) => a + 1);
console.log(res); //[2,3,4]

Array.prototype.myFill = function (value, start = 0, end = this.length) {
    for (let i = start; i < end; i++) {
        this[i] = value;
    }
}

Array.prototype.myFilter = function myFilter(fn, context) {
    if (typeof fn !== "function") {
        throw new TypeError(`${fn} is not a function`);
    }
    let arr = this;
    let temp = [];
    for (let i = 0; i < arr.length; i++) {
        let result = fn.call(context, arr[i], i, arr);
        if (result) temp.push(arr[i]);
    }
    return temp;
};

Array.prototype.myFind = function (fn, start = 0, end = this.length) {
    for (let i = start; i < end; i++) {
        if (fn.call(this, this[i], i, this)) {
            return this[i]
        }
    }
}

Array.prototype.myFindIndex = function (fn, start = 0, end = this.length) {
    for (let i = start; i < end; i++) {
        if (fn.call(this, this[i], i, this)) {
            return i
        }
    }
    return -1
}

 //promise.all()
  function myall(proArr) {
    return new Promise((resolve, reject) => {
      let ret = []
      let count = 0
      let done = (i, data) => {
        ret[i] = data
        if(++count === proArr.length) resolve(ret)
      }
      for (let i = 0; i < proArr.length; i++) {
        proArr[i].then(data => done(i,data) , reject)
      }
    })
  }
  
  
//promise.race();这么简单得益于promise的状态只能改变一次，即resolve和reject都只被能执行一次
 function myrace(proArr) {
    return new Promise(function (resolve, reject) {
      for(let i=0;i<proArr.length;i++){
        proArr[i].then(resolve,reject);
      }
    })
  }

//手写3遍以上
var xhr = new XMLHttpRequest();// 创建XMLHttqRequest
var url = 'https://bbin.com';
xhr.onreadystatechange=function(){// 监听状态码的变化，每次变化 均执行
    if(xhr.readyState===4){

        if (xhr.status === 200) { // 服务端 状态码
            console.log(xhr.responseText); //服务器返回的响应文本
        }else{
            console.error(xhr.statusText); //状态码的文本描述，如200的statusText是ok
        }
    
    }
}

xhr.open('GET', url, true); // 初始化请求参数，还没发送请求   true表示异步
xhr.send(null); // 向服务器发送请求,但是不带有数据发送过去,一般在get方式发送时候多使用这个方式

function myNew(constructor,params){
  var args = [].slice.call(arguments);
  var constructor = args.shift();
  var obj = new Object();
  obj.__proto__ = constructor.prototype;
  var res = constructor.apply(obj,args);
  return (typeof res === 'object' && typeof res !== null) ? res : obj;
}

// 用于创建一个新对象,被创建的对象继承另一个对象(o)的原型
function createObj(o) {//传入的参数o为返回实例的__porto__,也就是实例构造函数的显示原型
    function F() {}//构造函数
    F.prototype = o;
    return new F();//返回实例
}

function instanceofObj(a, b) {
    // 模拟 a instanceof b
    let prototypeB = b.prototype;
    let protoA = a.__proto__;
    let state