// forEach:遍历数组
Array.prototype.myForEach = function(fn){
    const arr = this
    for(let i=0;i<arr.length;i++){
        fn(arr[i], i, arr)
    }
}

const arr = ['a', 'b', 'c']
arr.myForEach(item => {
    console.log(item)
})
// map:返回经过处理的数组
Array.prototype.myMap = function(fn){
    const arr = this
    const ret = []
    for(let i = 0; i<arr.length;i++){
        ret.push(fn(arr[i], i, arr))
    }
    return ret
}


const arr2 = ['a', 'b', 'c']
const newArr2 = arr2.myMap(item => {
    return item + 1
})
console.log(newArr2)



// filter:返回处理结果为true的新数组
Array.prototype.myFilter = function(fn){
    const arr = this
    const ret = []
    for(let i=0;i<arr.length;i++){
        if(fn(arr[i], i, arr)){
            ret.push(arr[i])
        }
    }
    return ret
}


// find:返回处理条件第一个为true的数组项
Array.prototype.myFind = function(fn){
    const arr = this
    for(let i=0;i<arr.length;i++){
        if(fn(arr[i], i, arr)){
            return arr[i]
        }
    }
}


// findeIndex: 返回处理条件第一个为true的数组下标
Array.prototype.myFindIndex = function(fn){
    const arr = this
    for(let i = 0; i< arr.length;i++){
        if(fn(arr[i], i, arr)){
            return i
        }
    }
}   

const index = arr.myFindIndex(item => item === 'c')
console.log(index)


// every：如果数组每一项都符合处理条件，返回true,否则返回false
Array.prototype.myEvery = function(fn){
    const arr = this
    for(let i=0;i<arr.length;i++){
        if(!fn(arr[i], i, arr)){
            return false
        }
    }
    return true
}


// some: 只要数组有一项符合处理条件，返回true,都不满足返回false
Array.prototype.mySome = function(fn){
    const arr = this
    for(let i=0;i<arr.length;i++){
        if(fn(arr[i], i, arr)){
            return true
        }
    }
    return false
}

const ar = [1,2,3]
const data = ar.mySome(item => item >1)
console.log(data)


// includes: 传入某项检测
Array.prototype.myIncludes = function(item){
    const arr = this
    for(let i=0;i<arr.length;i++){
        if(Object.is(arr[i], item)){
            return true
        }
    }
    return false
}

// debounce: 函数防抖
function debounce(fn, delay = 1000){
    let timer;
    return () => {
        if(timer){
            clearTimeout(timer)
        }
        timer = setTimeout(() => {
            fn.apply(this, arguments)
        },delay)
    }
}
// 函数防抖指的是一定时间内没有再次触发函数，就执行该函数，否则重新计时


// throttle: 函数节流
function throttle(fn, delay = 100){
    let timer;
    return () => {
        if (!timer) {
            timer = setTimeout(() => {
                fn.apply(this, arguments)
                timer = null
            }, delay)
        }
    }
}
// 函数节流指的是规定某个时间内只能执行一次函数

// Promise手写简易版
class MyPromise {
  constructor(exector){
    this.state = 'PENDING'
    this.value = null
    this.resolvedCallbacks = []
    this.rejectedCallbacks = []
    const resolve = value => {
      if(this.state === 'PENDING'){
        this.state = "RESOLVED"
        this.value = value
        this.resolvedCallbacks.map(cb => cb())
      }
    }
    const reject = value => {
      if(this.state === 'PENDING'){
        this.state = "REJECTED"
        this.value = value
        this.rejectedCallbacks.map(cb => cb())
      }
    }
    try {
      executor(resolve, reject)
    } catch (e) {
      reject(e)
    }
  }

  then(onFulfilled, onRejected){
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : v => v
    onRejected = typeof onRejected === 'function' ? onRejected : r => { throw r }
    if(this.state === 'PENDING'){
      this.resolvedCallbacks.push(() => {
        onFulfilled(this.value)
      })
      this.rejectedCallbacks.push(() => {
        onRejected(this.value)
      })
    }
    if(this.state === 'RESOLVED'){
      onFulfilled(this.value)
    }
    if(this.state === 'REJECTED'){
      onRejected(this.value)
    }
  }
  catch(fn){
    return this.then(null, executor)
  }
  static resolve(val){
    return new MyPromise(resolve => {
      resolve(val)
    })
  }
  static reject(err){
    return new MyPromise((resolve, reject) => {
      reject(err)
    })
  }
  static race(promises){
    return new MyPromise((resolve, reject) => {
      for(let i=0;i<promises.length;i++){
        promises[i].then(resolve, reject)
      }
    })
  }
  static all(promises){
    const arr = []
    let i =0 
    function processData(index, data, resolve){
      arr[index] =  data
      i++ 
      if(i === promises.length){
        resolve(arr)
      }
    }
    return new MyPromise((resolve, reject) => {
      for(let i=0;i<promises.length;i++){
        promises[i].then(data => {
          processData(i, data, resolve)
        }, reject)
      }
    })
  }
}








// deepClone:深拷贝
function deepClone(source){
  if(typeof source !== 'object' || source === null){
    return source
  }
  const target = Array.isArray(source) ? [] : {}
  for(const key in source){
    if(Object.prototype.hasOwnProperty.call(source, key)){
      target[key] = deepClone(source[key])
    } else {
      target[key] = source[key]
    }
  }
  return target
}