中文排序

[‘王大鹏’,’阿松大’,’八十多’].sort((a,b)=>a.localeCompare(b,’zh’))

遍历方法

链式操作

什么时候需要拷贝数据

js中pop/push/shift/unshift/splice 这些都是在原来的数据上进行修改的， concat /slice/map/reduce 是对原来的数据进行了浅拷贝

为什么每次map最好都深拷贝那

因为深拷贝数据安全，不会产生数据混乱，但是性能消耗又比较大

递归性能

如果说是2的30次方的话 ，机器直接就崩掉了

dom的绝对位置

['王大鹏', '阿松大', '八十多'].sort((a, b) => a.localeCompare(b, 'zh'))
// 阶乘
function factorial (n) {
  return n === 0 ? 1 : factorial(n - 1) * n
}
// 斐波那契数列
// 1,1,2,3,5,8,13
function fibonacci (n) {
  let a = n === 1 || n == 2 ? 1 : fibonacci(n - 1) + fibonacci(n - 2)
  return a
}
console.log(fibonacci(5))
// 递归要考虑性能 上面的递归消耗性能太大了
// 可以用reduce 和 for循环的两种写法，本质上是一样de
function fibonacciFor (n) {
  let [a, b] = [0, 1]
  for (let i = 0; i < n; i++) {
    [a, b] = [b, a + b]
  }
  return b
}
console.log(fibonacciFor(5))
function fibonacciReduce (n) {
  return Array(n).fill().reduce(([a, b], _) => {
    return [b, a + b]
  }, [0, 1])[1]
}
console.log(fibonacciReduce(5))
// 获取dom节点的绝对位置
// 也就是说dom节点在api中，没有获取当前节点在整个文档流的绝对位置
// 所以需要递归遍历他的父节点，把父节点的offectTop加起来
// 也可以用while 语法来写结果是一样的
function get_layout (ele) {
  const layout = {
    width: ele.offsetWidth,
    height: ele.offsetHeight,
    left: ele.offsetLeft,
    top: ele.offsetTop
  }
  if (ele.offsetParent) {
    const parentLayout = get_layout(ele.offsetParent)
    layout.left += parentLayout.left
    layout.top += parentLayout.top
  }
  return layout
}
// 手写深拷贝 初步写法
function clone (obj) {
  if (obj === null || typeof obj !== 'object') return obj
  const newObj = new obj.constructor()
  for (let key in Object.getOwnPropertyDescriptors(obj)) {
    newObj[key] = clone(obj[key])
  }
  return newObj
}
console.log(clone({ "123": "qwe", 3: { 4: 5 } }))
console.log(clone([1, 2, 3]))
// 深度比较
function deepCompare (a, b) {
  if (a === null || typeof a !== 'object' || b === null || typeof b !== 'object') {
    return a === b
  }
  const propsA = Object.getOwnPropertyDescriptors(a)
  const propsB = Object.getOwnPropertyDescriptors(b)
  if (Object.keys(propsA).length !== Object.keys(propsB).length) {
    return false
  }
  // 数组every 全部都满足一个条件
  return Object.keys(propsA).every(key => deepCompare(a[key], b[key]))
}