function isObject(obj) {
  return typeof obj === 'object' && obj != null
}
function deepCopy(source, hash = new WeakMap()) {
  // 验证：非对象 或者 Null 直接返回
  if (!isObject(source)) return source
  // 使用 WeakMap 解决循环引用，使用过的存放在 WeakMap 中
  if (hash.has(source)) return hash.get(source) // 重新哈希表
  // 数组处理
  const target = Array.isArray(source) ? [] : {}
  // 缓存
  hash.set(source, target) // 设置哈希表值

  for (let key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      if (isObject(source[key])) {
        target[key] = deepCopy(source[key], hash)
      } else {
        target[key] = source[key]
      }
    }
  }
  return target
}

// 1. 使用 Object.getOwnPropertySymbols(...) 获取 Symbol 属性数组
function deepCopy2(source, hash = new WeakMap()) {
  if (!isObject(source)) return source

  if (hash.has(source)) return hash.get(source)

  const target = Array.isArray(source) ? [] : {}

  hash.set(source, target)

  // 处理 Symbol
  const symKeys = Object.getOwnPropertySymbols(source)

  if (symKeys.length) {
    symKeys.forEach(symKey => {
      if (isObject(source[symKey])) {
        target[symKey] = deepCopy2(source[symKey], hash)
      } else {
        target[symKey] = source[symKey]
      }
    })
  }
  // 处理正常情况
  for (let key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      if (isObject(source[key])) {
        target[key] = deepCopy2(source[key], hash)
      } else {
        target[key] = source[key]
      }
    }
  }
  return target
}

// 2. 使用 Reflect.ownKeys 处理 Symbol 属性
function deepCopy22(source, hash = new WeakMap()) {
  
  if (!isObject(source)) return source
  if (hash.has(source)) return hash.get(source)

  const target = Array.isArray(source) ? [] : {}

  hash.set(source, target)

  Reflect.ownKeys(source).forEach(key => {
    if (isObject(source[key])) {
      target[key] = deepCopy22(source[key], hash)
    } else {
      target[key] = source[key]
    }
  })
  return target
}

function deepCopy3(source) {
  if (!isObject(source)) return source
  const root = {}
  const queue = [
    {
      parent: root,
      key: undefined,
      source
    }
  ]
  while (queue.length) {
    // 广度优先
    const node = queue.pop()
    const { parent, key, source } = node
    let res = parent
    if (typeof key !== 'undefined') {
      res = parent[key] = Array.isArray(source) ? [] : {}
    }
    Reflect.ownKeys(source).forEach(key => {
      if (isObject(source[key])) {
        queue.push({
          parent: res,
          key,
          source: source[key]
        })
      } else {
        res[key] = source[key]
      }
    })
  }
  return root
}

/**
 * 触发高频事件后n秒内函数只会执行一次，如果n秒内高频事件再次被触发，则重新计算时间
 */
function debounce(func, wait = 500, immediate = false) {
  let timer, result
  return function() {
    // 清空定时器
    timer && clearTimeout(timer)
    if (immediate) {
      !timer && (result = func.apply(this, arguments))
    } else {
      // this 指向 和 event 指向； => 和 apply
      timer = setTimeout(() => {
        result = func.apply(this, arguments)
      }, wait)
    }
    return result
  }
}

/**
 * 高频事件触发，但在n秒内只会执行一次，所以节流会稀释函数的执行频率
 */
// 反转标志位
function throttle(func, wait) {
  let isOK = true // 标志位
  return function() {
    if (!isOK) return
    isOK = false
    setTimeout(() => {
      func.apply(this, arguments)
      isOK = true
    }, wait);
  }
}

var throttle = function(fn, interval) {
    var self = fn,timer,firstTime = true
    return function() {
      var args = arguments
      // 首次
      if (firstTime) {
        self.apply(this, args)
        return firstTime = false
      }
      if (timer) return false // 定时器还在，说明前一次还没有结束

      timer = setTimeout(() => { // 延迟一段时间后执行
        clearTimeout(timer)
        timer = null
        self.apply(this, args)
      }, interval || 500)
    }
  }

// 分时函数
/**
 *
 * @param {*} datas 数据源数组
 * @param {*} fn 方法
 * @param {*} count 数量
 */
let timeChunk = function (datas = [], fn, count = 1) {
  const length = datas.length
  // 执行方法
  let start = function () {
    for (let i = 0; i < Math.min(count, length); i++) {
      let obj = datas.shift() // 每次取一个 执行 fn
      fn(obj)
    }
  }
  return function () {
    let timer = setInterval(() => {
      if (length === 0) {
        clearInterval(timer) // 全部数据创建完成
      }
      start()
    }, 1000) // 分段执行的间隔时间
  }
}

Function.prototype.call2 = function (context) {
    // context 为 null  指向 window  对象
    var context = context || window;
   //  fn 指向该函数
    context.fn = this;
  // 处理 arguments
    var args = [];
    for(var i = 1, len = arguments.length; i < len; i++) {
        args.push('arguments[' + i + ']');
    }
   // 使用 eval 执行 fn 
    var result = eval('context.fn(' + args +')');
  // 删除 fn 属性
    delete context.fn
  // 返回执行结果
    return result;
}

Function.prototype.apply = function (context, arr) {
    var context = Object(context) || window;
    context.fn = this;

    var result;
    if (!arr) {
        result = context.fn();
    }
    else {
        var args = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            args.push('arr[' + i + ']');
        }
        result = eval('context.fn(' + args + ')')
    }

    delete context.fn
    return result;
}