let myInstanceof = (target,origin) => {
     while(target) {
         if(target.__proto__===origin.prototype) {
            return true
         }
         target = target.__proto__
     }
     return false
 }
 let a = [1,2,3]
 console.log(myInstanceof(a,Array));  // true
 console.log(myInstanceof(a,Object));  // true

const a = [1, 2, 3, 4];
const b = array1.map(x => x * 2);
console.log(b);   // Array [2, 4, 6, 8]

    // 實(shí)現(xiàn)
     Array.prototype.myMap = function(fn, thisValue) {
            let res = []
            thisValue = thisValue||[]
            let arr = this
            for(let i=0; i<arr.length; i++) {
                res.push(fn.call(thisValue, arr[i],i,arr))   // 參數(shù)分別為this指向，當(dāng)前數(shù)組項(xiàng)，當(dāng)前索引，當(dāng)前數(shù)組
            }
            return res
        }
        // 使用
        const a = [1,2,3];
        const b = a.myMap((a,index)=> {
                return a+1; 
            }
        )
        console.log(b)   // 輸出 [2, 3, 4]

Array.prototype.myMap = function(fn,thisValue){
     var res = [];
     thisValue = thisValue||[];
     this.reduce(function(pre,cur,index,arr){
         return res.push(fn.call(thisValue,cur,index,arr));
     },[]);
     return res;
}
​
var arr = [2,3,1,5];
arr.myMap(function(item,index,arr){
 console.log(item,index,arr);
})

 function reduce(arr, cb, initialValue){
     var num = initValue == undefined? num = arr[0]: initValue;
     var i = initValue == undefined? 1: 0
     for (i; i< arr.length; i++){
        num = cb(num,arr[i],i)
     }
     return num
 }
 
 function fn(result, currentValue, index){
     return result + currentValue
 }
 
 var arr = [2,3,4,5]
 var b = reduce(arr, fn,10) 
 var c = reduce(arr, fn)
 console.log(b)   // 24

function flatten(arr) {
     var res = [];
     for (let i = 0, length = arr.length; i < length; i++) {
     if (Array.isArray(arr[i])) {
     res = res.concat(flatten(arr[i])); //concat 并不會改變原數(shù)組
     //res.push(...flatten(arr[i])); //或者用擴(kuò)展運(yùn)算符 
     } else {
         res.push(arr[i]);
       }
     }
     return res;
 }
 let arr1 = [1, 2,[3,1],[2,3,4,[2,3,4]]]
flatten(arr1); //[1, 2, 3, 1, 2, 3, 4, 2, 3, 4]

     function flat(arr, deep) {
        let res = []
        for(let i in arr) {
            if(Array.isArray(arr[i])&&deep) {
                res = res.concat(flat(arr[i],deep-1))
            } else {
                res.push(arr[i])
            }
        }
        return res
    }
    console.log(flat([12,[1,2,3],3,[2,4,[4,[3,4],2]]],1));

/**
 * 將函數(shù)柯里化
 * @param fn    待柯里化的原函數(shù)
 * @param len   所需的參數(shù)個數(shù)，默認(rèn)為原函數(shù)的形參個數(shù)
 */
function curry(fn,len = fn.length) {
 return _curry.call(this,fn,len)
}
​
/**
 * 中轉(zhuǎn)函數(shù)
 * @param fn    待柯里化的原函數(shù)
 * @param len   所需的參數(shù)個數(shù)
 * @param args  已接收的參數(shù)列表
 */
function _curry(fn,len,...args) {
    return function (...params) {
         let _args = [...args,...params];
         if(_args.length >= len){
             return fn.apply(this,_args);
         }else{
          return _curry.call(this,fn,len,..._args)
         }
    }
}

let _fn = curry(function(a,b,c,d,e){
 console.log(a,b,c,d,e)
});
​
_fn(1,2,3,4,5);     // print: 1,2,3,4,5
_fn(1)(2)(3,4,5);   // print: 1,2,3,4,5
_fn(1,2)(3,4)(5);   // print: 1,2,3,4,5
_fn(1)(2)(3)(4)(5); // print: 1,2,3,4,5

/**
 * @param  fn           待柯里化的函數(shù)
 * @param  length       需要的參數(shù)個數(shù)，默認(rèn)為函數(shù)的形參個數(shù)
 * @param  holder       占位符，默認(rèn)當(dāng)前柯里化函數(shù)
 * @return {Function}   柯里化后的函數(shù)
 */
function curry(fn,length = fn.length,holder = curry){
 return _curry.call(this,fn,length,holder,[],[])
}
/**
 * 中轉(zhuǎn)函數(shù)
 * @param fn            柯里化的原函數(shù)
 * @param length        原函數(shù)需要的參數(shù)個數(shù)
 * @param holder        接收的占位符
 * @param args          已接收的參數(shù)列表
 * @param holders       已接收的占位符位置列表
 * @return {Function}   繼續(xù)柯里化的函數(shù) 或 最終結(jié)果
 */
function _curry(fn,length,holder,args,holders){
 return function(..._args){
 //將參數(shù)復(fù)制一份，避免多次操作同一函數(shù)導(dǎo)致參數(shù)混亂
 let params = args.slice();
 //將占位符位置列表復(fù)制一份，新增加的占位符增加至此
 let _holders = holders.slice();
 //循環(huán)入?yún)?，追加參?shù) 或 替換占位符
 _args.forEach((arg,i)=>{
 //真實(shí)參數(shù) 之前存在占位符 將占位符替換為真實(shí)參數(shù)
 if (arg !== holder && holders.length) {
     let index = holders.shift();
     _holders.splice(_holders.indexOf(index),1);
     params[index] = arg;
 }
 //真實(shí)參數(shù) 之前不存在占位符 將參數(shù)追加到參數(shù)列表中
 else if(arg !== holder && !holders.length){
     params.push(arg);
 }
 //傳入的是占位符,之前不存在占位符 記錄占位符的位置
 else if(arg === holder && !holders.length){
     params.push(arg);
     _holders.push(params.length - 1);
 }
 //傳入的是占位符,之前存在占位符 刪除原占位符位置
 else if(arg === holder && holders.length){
    holders.shift();
 }
 });
 // params 中前 length 條記錄中不包含占位符，執(zhí)行函數(shù)
 if(params.length >= length && params.slice(0,length).every(i=>i!==holder)){
 return fn.apply(this,params);
 }else{
 return _curry.call(this,fn,length,holder,params,_holders)
 }
 }
}

let fn = function(a, b, c, d, e) {
 console.log([a, b, c, d, e]);
}
​
let _ = {}; // 定義占位符
let _fn = curry(fn,5,_);  // 將函數(shù)柯里化，指定所需的參數(shù)個數(shù)，指定所需的占位符
​
_fn(1, 2, 3, 4, 5);                 // print: 1,2,3,4,5
_fn(_, 2, 3, 4, 5)(1);              // print: 1,2,3,4,5
_fn(1, _, 3, 4, 5)(2);              // print: 1,2,3,4,5
_fn(1, _, 3)(_, 4,_)(2)(5);         // print: 1,2,3,4,5
_fn(1, _, _, 4)(_, 3)(2)(5);        // print: 1,2,3,4,5
_fn(_, 2)(_, _, 4)(1)(3)(5);        // print: 1,2,3,4,5

function shallowCopy(target, origin){
    for(let item in origin) target[item] = origin[item];
    return target;
}

var obj={a:1,b:[1,2,3],c:function(){console.log('i am c')}}
var tar={};
Object.assign(tar,obj);

var arr=[1,2,[3,4]];
var newArr=arr.slice(0);
Array.prototype.concat
var arr=[1,2,[3,4]];
var newArr=arr.concat();

var arr=[1,2,[3,4]];
var newArr=arr.concat();

// 實(shí)現(xiàn)深拷貝  遞歸
function deepCopy(newObj,oldObj){
     for(var k in oldObj){
         let item=oldObj[k]
         // 判斷是數(shù)組、對象、簡單類型？
         if(item instanceof Array){
             newObj[k]=[]
             deepCopy(newObj[k],item)
         }else if(item instanceof Object){
             newObj[k]={}
             deepCopy(newObj[k],item)
         }else{  //簡單數(shù)據(jù)類型，直接賦值
             newObj[k]=item
         }
     }
}

Function.prototype.myCall=function(context=window){  // 函數(shù)的方法，所以寫在Fuction原型對象上
 if(typeof this !=="function"){   // 這里if其實(shí)沒必要，會自動拋出錯誤
    throw new Error("不是函數(shù)")
 }
 const obj=context||window   //這里可用ES6方法，為參數(shù)添加默認(rèn)值，js嚴(yán)格模式全局作用域this為undefined
 obj.fn=this      //this為調(diào)用的上下文,this此處為函數(shù)，將這個函數(shù)作為obj的方法
 const arg=[...arguments].slice(1)   //第一個為obj所以刪除,偽數(shù)組轉(zhuǎn)為數(shù)組
 res=obj.fn(...arg)
 delete obj.fn   // 不刪除會導(dǎo)致context屬性越來越多
 return res
}
//用法：f.call(obj,arg1)
function f(a,b){
 console.log(a+b)
 console.log(this.name)
}
let obj={
 name:1
}
f.myCall(obj,1,2) //否則this指向window

 
obj.greet.call({name: 'Spike'}) //打出來的是 Spike

Function.prototype.myApply=function(context){  // 箭頭函數(shù)從不具有參數(shù)對象！?。。?！這里不能寫成箭頭函數(shù)
 let obj=context||window
 obj.fn=this
 const arg=arguments[1]||[]    //若有參數(shù)，得到的是數(shù)組
 let res=obj.fn(...arg)
 delete obj.fn
 return res
} 
function f(a,b){
 console.log(a,b)
 console.log(this.name)
}
let obj={
 name:'張三'
}
f.myApply(obj,[1,2])  //arguments[1]

this.value = 2
var foo = {
 value: 1
};
var bar = function(name, age, school){
 console.log(name) // 'An'
 console.log(age) // 22
 console.log(school) // '家里蹲大學(xué)'
}
var result = bar.bind(foo, 'An') //預(yù)置了部分參數(shù)'An'
result(22, '家里蹲大學(xué)') //這個參數(shù)會和預(yù)置的參數(shù)合并到一起放入bar中

Function.prototype.bind = function(context, ...outerArgs) {
 var fn = this;
 return function(...innerArgs) {   //返回了一個函數(shù)，...rest為實(shí)際調(diào)用時傳入的參數(shù)
 return fn.apply(context,[...outerArgs, ...innerArgs]);  //返回改變了this的函數(shù)，
 //參數(shù)合并
 }
}

// 聲明一個上下文
let thovino = {
 name: 'thovino'
}
​
// 聲明一個構(gòu)造函數(shù)
let eat = function (food) {
 this.food = food
 console.log(`${this.name} eat ${this.food}`)
}
eat.prototype.sayFuncName = function () {
 console.log('func name : eat')
}
​
// bind一下
let thovinoEat = eat.bind(thovino)
let instance = new thovinoEat('orange')  //實(shí)際上orange放到了thovino里面
console.log('instance:', instance) // {}

function thovinoEat (...innerArgs) {
 eat.call(thovino, ...outerArgs, ...innerArgs)
}

Function.prototype.bind = function (context, ...outerArgs) {
 let that = this;
​
function res (...innerArgs) {
     if (this instanceof res) {
         // new操作符執(zhí)行時
         // 這里的this在new操作符第三步操作時，會指向new自身創(chuàng)建的那個簡單空對象{}
         that.call(this, ...outerArgs, ...innerArgs)
     } else {
         // 普通bind
         that.call(context, ...outerArgs, ...innerArgs)
     }
     }
     res.prototype = this.prototype //！??！
     return res
}

function Person(name,age){
 this.name=name
 this.age=age
}
Person.prototype.sayHi=function(){
 console.log('Hi！我是'+this.name)
}
let p1=new Person('張三',18)
​
////手動實(shí)現(xiàn)new
function create(){
 let obj={}
 //獲取構(gòu)造函數(shù)
 let fn=[].shift.call(arguments)  //將arguments對象提出來轉(zhuǎn)化為數(shù)組，arguments并不是數(shù)組而是對象    ?。?！這種方法刪除了arguments數(shù)組的第一個元素，！！這里的空數(shù)組里面填不填元素都沒關(guān)系，不影響arguments的結(jié)果      或者let arg = [].slice.call(arguments,1)
 obj.__proto__=fn.prototype
 let res=fn.apply(obj,arguments)    //改變this指向，為實(shí)例添加方法和屬性
 //確保返回的是一個對象(萬一fn不是構(gòu)造函數(shù))
 return typeof res==='object'?res:obj
}
​
let p2=create(Person,'李四',19)
p2.sayHi()

[].shift.call(arguments)  也可寫成：
 let arg=[...arguments]
 let fn=arg.shift()  //使得arguments能調(diào)用數(shù)組方法,第一個參數(shù)為構(gòu)造函數(shù)
 obj.__proto__=fn.prototype
 //改變this指向，為實(shí)例添加方法和屬性
 let res=fn.apply(obj,arg)

// Promise/A+ 規(guī)范規(guī)定的三種狀態(tài)
const STATUS = {
 PENDING: 'pending',
 FULFILLED: 'fulfilled',
 REJECTED: 'rejected'
}
​
class MyPromise {
 // 構(gòu)造函數(shù)接收一個執(zhí)行回調(diào)
 constructor(executor) {
     this._status = STATUS.PENDING // Promise初始狀態(tài)
     this._value = undefined // then回調(diào)的值
     this._resolveQueue = [] // resolve時觸發(fā)的成功隊(duì)列
     this._rejectQueue = [] // reject時觸發(fā)的失敗隊(duì)列
    ​
 // 使用箭頭函數(shù)固定this（resolve函數(shù)在executor中觸發(fā)，不然找不到this）
 const resolve = value => {
     const run = () => {
         // Promise/A+ 規(guī)范規(guī)定的Promise狀態(tài)只能從pending觸發(fā)，變成fulfilled
         if (this._status === STATUS.PENDING) {
             this._status = STATUS.FULFILLED // 更改狀態(tài)
             this._value = value // 儲存當(dāng)前值，用于then回調(diào)
            ​
             // 執(zhí)行resolve回調(diào)
             while (this._resolveQueue.length) {
                 const callback = this._resolveQueue.shift()
                 callback(value)
             }
         }
     }
     //把resolve執(zhí)行回調(diào)的操作封裝成一個函數(shù),放進(jìn)setTimeout里,以實(shí)現(xiàn)promise異步調(diào)用的特性（規(guī)范上是微任務(wù)，這里是宏任務(wù)）
     setTimeout(run)
 }
​
 // 同 resolve
 const reject = value => {
     const run = () => {
         if (this._status === STATUS.PENDING) {
         this._status = STATUS.REJECTED
         this._value = value
        ​
         while (this._rejectQueue.length) {
             const callback = this._rejectQueue.shift()
             callback(value)
         }
     }
 }
     setTimeout(run)
 }

     // new Promise()時立即執(zhí)行executor,并傳入resolve和reject
     executor(resolve, reject)
 }
​
 // then方法,接收一個成功的回調(diào)和一個失敗的回調(diào)
 function then(onFulfilled, onRejected) {
  // 根據(jù)規(guī)范，如果then的參數(shù)不是function，則忽略它, 讓值繼續(xù)往下傳遞，鏈?zhǔn)秸{(diào)用繼續(xù)往下執(zhí)行
  typeof onFulfilled !== 'function' ? onFulfilled = value => value : null
  typeof onRejected !== 'function' ? onRejected = error => error : null

  // then 返回一個新的promise
  return new MyPromise((resolve, reject) => {
    const resolveFn = value => {
      try {
        const x = onFulfilled(value)
        // 分類討論返回值,如果是Promise,那么等待Promise狀態(tài)變更,否則直接resolve
        x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
      } catch (error) {
        reject(error)
      }
    }
  }
}
​
  const rejectFn = error => {
      try {
        const x = onRejected(error)
        x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
      } catch (error) {
        reject(error)
      }
    }

    switch (this._status) {
      case STATUS.PENDING:
        this._resolveQueue.push(resolveFn)
        this._rejectQueue.push(rejectFn)
        break;
      case STATUS.FULFILLED:
        resolveFn(this._value)
        break;
      case STATUS.REJECTED:
        rejectFn(this._value)
        break;
    }
 })
 }
 catch (rejectFn) {
  return this.then(undefined, rejectFn)
}
// promise.finally方法
finally(callback) {
  return this.then(value => MyPromise.resolve(callback()).then(() => value), error => {
    MyPromise.resolve(callback()).then(() => error)
  })
}

 // 靜態(tài)resolve方法
 static resolve(value) {
      return value instanceof MyPromise ? value : new MyPromise(resolve => resolve(value))
  }

 // 靜態(tài)reject方法
 static reject(error) {
      return new MyPromise((resolve, reject) => reject(error))
    }

 // 靜態(tài)all方法
 static all(promiseArr) {
      let count = 0
      let result = []
      return new MyPromise((resolve, reject) =>       {
        if (!promiseArr.length) {
          return resolve(result)
        }
        promiseArr.forEach((p, i) => {
          MyPromise.resolve(p).then(value => {
            count++
            result[i] = value
            if (count === promiseArr.length) {
              resolve(result)
            }
          }, error => {
            reject(error)
          })
        })
      })
    }

 // 靜態(tài)race方法
 static race(promiseArr) {
      return new MyPromise((resolve, reject) => {
        promiseArr.forEach(p => {
          MyPromise.resolve(p).then(value => {
            resolve(value)
          }, error => {
            reject(error)
          })
        })
      })
    }
}

myButton.addEventListener('click', function () {
  ajax()
})

function ajax() {
  let xhr = new XMLHttpRequest() //實(shí)例化，以調(diào)用方法
  xhr.open('get', 'https://www.google.com')  //參數(shù)2，url。參數(shù)三：異步
  xhr.onreadystatechange = () => {  //每當(dāng) readyState 屬性改變時，就會調(diào)用該函數(shù)。
    if (xhr.readyState === 4) {  //XMLHttpRequest 代理當(dāng)前所處狀態(tài)。
      if (xhr.status >= 200 && xhr.status < 300) {  //200-300請求成功
        let string = request.responseText
        //JSON.parse() 方法用來解析JSON字符串，構(gòu)造由字符串描述的JavaScript值或?qū)ο?
        let object = JSON.parse(string)
      }
    }
  }
  request.send() //用于實(shí)際發(fā)出 HTTP 請求。不帶參數(shù)為GET請求
}

function ajax(url) {
  const p = new Promise((resolve, reject) => {
    let xhr = new XMLHttpRequest()
    xhr.open('get', url)
    xhr.onreadystatechange = () => {
      if (xhr.readyState == 4) {
        if (xhr.status >= 200 && xhr.status <= 300) {
          resolve(JSON.parse(xhr.responseText))
        } else {
          reject('請求出錯')
        }
      }
    }
    xhr.send()  //發(fā)送hppt請求
  })
  return p
}
let url = '/data.json'
ajax(url).then(res => console.log(res))
  .catch(reason => console.log(reason))

function debounce(fn, delay) {
     if(typeof fn!=='function') {
        throw new TypeError('fn不是函數(shù)')
     }
     let timer; // 維護(hù)一個 timer
     return function () {
         var _this = this; // 取debounce執(zhí)行作用域的this(原函數(shù)掛載到的對象)
         var args = arguments;
         if (timer) {
            clearTimeout(timer);
         }
         timer = setTimeout(function () {
            fn.apply(_this, args); // 用apply指向調(diào)用debounce的對象，相當(dāng)于_this.fn(args);
         }, delay);
     };
}

// 調(diào)用​
input1.addEventListener('keyup', debounce(() => {
 console.log(input1.value)
}), 600)

function throttle(fn, delay) {
  let timer;
  return function () {
    var _this = this;
    var args = arguments;
    if (timer) {
      return;
    }
    timer = setTimeout(function () {
      fn.apply(_this, args); // 這里args接收的是外邊返回的函數(shù)的參數(shù)，不能用arguments
      // fn.apply(_this, arguments); 需要注意：Chrome 14 以及 Internet Explorer 9 仍然不接受類數(shù)組對象。如果傳入類數(shù)組對象，它們會拋出異常。
      timer = null; // 在delay后執(zhí)行完fn之后清空timer，此時timer為假，throttle觸發(fā)可以進(jìn)入計(jì)時器
    }, delay)
  }
}

div1.addEventListener('drag', throttle((e) => {
  console.log(e.offsetX, e.offsetY)
}, 100))

function getData(url) {
  return new Promise((resolve, reject) => {
    $.ajax({
      url,
      success(data) {
        resolve(data)
      },
      error(err) {
        reject(err)
      }
    })
  })
}
const url1 = './data1.json'
const url2 = './data2.json'
const url3 = './data3.json'
getData(url1).then(data1 => {
  console.log(data1)
  return getData(url2)
}).then(data2 => {
  console.log(data2)
  return getData(url3)
}).then(data3 =>
  console.log(data3)
).catch(err =>
  console.error(err)
)

for(let i=0;i<=10;i++){   //用var打印的都是11
 setTimeout(()=>{
    console.log(i);
 },1000*i)
}

for(var i = 1; i <= 10; i++){
    (function (i) {
        setTimeout(function () {
            console.log(i);
        }, 1000 * i)
    })(i);
}

var a
for(let i=0;i<10;i++){
 a=document.createElement('a')
 a.innerHTML=i+'<br>'
 a.addEventListener('click',function(e){
     console.log(this)  //this為當(dāng)前點(diǎn)擊的<a>
     e.preventDefault()  //如果調(diào)用這個方法，默認(rèn)事件行為將不再觸發(fā)。
     //例如，在執(zhí)行這個方法后，如果點(diǎn)擊一個鏈接（a標(biāo)簽），瀏覽器不會跳轉(zhuǎn)到新的 URL 去了。我們可以用 event.isDefaultPrevented() 來確定這個方法是否(在那個事件對象上)被調(diào)用過了。
     alert(i)
 })
 const d=document.querySelector('div')
 d.appendChild(a)  //append向一個已存在的元素追加該元素。
}

class EventBus {
    on(eventName, listener) {}
    off(eventName, listener) {}
    once(eventName, listener) {}
    trigger(eventName) {}
}

const e = new EventBus();
// fn1 fn2
e.on('e1', fn1)
e.once('e1', fn2)
e.trigger('e1') // fn1() fn2()
e.trigger('e1') // fn1()
e.off('e1', fn1)
e.trigger('e1') // null

      //聲明類
      class EventBus {
        constructor() {
          this.eventList = {} //創(chuàng)建對象收集事件
        }
        //發(fā)布事件
        $on(eventName, fn) {
          //判斷是否發(fā)布過事件名稱? 添加發(fā)布 : 創(chuàng)建并添加發(fā)布
          this.eventList[eventName]
            ? this.eventList[eventName].push(fn)
            : (this.eventList[eventName] = [fn])
        }
        //訂閱事件
        $emit(eventName) {
          if (!eventName) throw new Error('請傳入事件名')
          //獲取訂閱傳參
          const data = [...arguments].slice(1)
          if (this.eventList[eventName]) {
            this.eventList[eventName].forEach((i) => {
              try {
                i(...data) //輪詢事件
              } catch (e) {
                console.error(e + 'eventName:' + eventName) //收集執(zhí)行時的報錯
              }
            })
          }
        }
        //執(zhí)行一次
        $once(eventName, fn) {
          const _this = this
          function onceHandle() {
            fn.apply(null, arguments)
            _this.$off(eventName, onceHandle) //執(zhí)行成功后取消監(jiān)聽
          }
          this.$on(eventName, onceHandle)
        }
        //取消訂閱
        $off(eventName, fn) {
          //不傳入?yún)?shù)時取消全部訂閱
          if (!arguments.length) {
            return (this.eventList = {})
          }
          //eventName傳入的是數(shù)組時,取消多個訂閱
          if (Array.isArray(eventName)) {
            return eventName.forEach((event) => {
              this.$off(event, fn)
            })
          }
          //不傳入fn時取消事件名下的所有隊(duì)列
          if (arguments.length === 1 || !fn) {
            this.eventList[eventName] = []
          }
          //取消事件名下的fn
          this.eventList[eventName] = this.eventList[eventName].filter(
            (f) => f !== fn
          )
        }
      }
      const event = new EventBus()

      let b = function (v1, v2, v3) {
        console.log('b', v1, v2, v3)
      }
      let a = function () {
        console.log('a')
      }
      event.$once('test', a)
      event.$on('test', b)
      event.$emit('test', 1, 2, 3, 45, 123)

      event.$off(['test'], b)

      event.$emit('test', 1, 2, 3, 45, 123)