简单算法题收录

展开嵌套数组
检查数组中的项是数组的话也要对其进行展开，将展开的结果通过concat拍平放到当前数组中，完成数组展开

function flat(ar) {
  let arr = []

  for (var i = 0; i < ar.length; i++) {
    if (Array.isArray(ar[i])) arr = arr.concat(flat(ar[i]))
    else arr.push(ar[i])
  }

  return arr
}

实现一个数组的reduce
reduce的作用是将数组中的值通过某种规律聚合到一起，最终将聚合的结果返回

function reduce(arr, fn, initialValue) {
  if (arr.length === 0) return initialValue
  let hasInitialValue = initialValue !== undefined
  let index, res
  if (hasInitialValue) {
    index = 0
    res = initialValue
  } else {
    index = 1
    res = arr[0]
  }
  for (; index < arr.length; index++) {
    res = fn(res, arr[index], index, arr)
  }
  return res
}

实现一个深拷贝
针对需要拷贝的值再进行一次拷贝

function deepClone(data) {
  let needCopy = Array.isArray(data) || (data && typeof data === 'object')
  if (!needCopy) return data
  let _data = null
  
  if (Array.isArray(data)) {
    _data = data.reduce((total, cur) => {
      total.push(deepClone(cur))
      return total
    }, [])
  } else {
    _data = Object.keys(data).reduce((total, cur) => {
      total[cur] = deepClone(data[cur])
      return total
    }, {})
  }

  return _data
}

实现一个可以循环引用的深拷贝
如果内容被拷贝过就直接返回，不拷贝了

function deepClone(data) {
  const caches = [] // 拷贝的内容缓存一下
  return _deepClone(data)

  function _deepClone(data) {
    let needCopy = Array.isArray(data) || (data && typeof data === 'object')
    if (!needCopy) return data
    if (caches.includes(data)) return data // 检查是否被拷贝过
    caches.push(data)
    let _data = null
    
    if (Array.isArray(data)) {
      _data = data.reduce((total, cur) => {
        total.push(_deepClone(cur))
        return total
      }, [])
    } else {
      _data = Object.keys(data).reduce((total, cur) => {
        total[cur] = _deepClone(data[cur])
        return total
      }, {})
    }

    return _data
  }
}