JS 快排，对象扁平化，add(1)(2)(3)

更多JS源码 Github

quickSort

简单来说是，从数组中随机选择一个数后，遍历数组。小的放入左栈，大的放入右栈。而后递归分别执行

代码

function quickSort(args){
  let l = args.length
  if(l <= 1){
    return args
  }
  var left = []
  var right = []
  let mid = Math.floor(l/2)
  let midVal = args[mid]
  for (let i = 0 ; i< l;i++){
    if(i === mid){
      continue
    }
    if(args[i]<=midVal){
      left.push(args[i])
    }
    else{
      right.push(args[i])
    }
  }
  return quickSort(left).concat([midVal]).concat(right)
}

console.log(quickSort([2,3,1,6]))

对象的扁平化 objectFlat

不知道怎么说，看代码就行不复杂

// objectFlat.js
function objectFlat(obj = ''){
  const res = {}
  function flat(item,preKey = ''){
    Object.entries(item).forEach(([key,value]) => {
      let newkey = key
      if (Array.isArray(item)){
        newkey = preKey ? `${preKey}[${key}]`:key
      }else{
        newkey = preKey ? `${preKey}.${key}`: key
      }
      if(value && typeof value === 'object'){
        flat(value,newkey)
      }else{
        res[newkey] = value
      }
    })
  }
  flat(obj)
  return res
}
const source = { a: { b: { c: 1, d: 2 }, e: 3 }, f: { g: 2 } }
console.log(objectFlat(source));
const obj = {
  a: 1,
  b: [1, 2, { c: true }],
  c: { e: 2, f: 3 },
  g: null,
};
console.log(objectFlat(obj));

add(1)(2)(3)

这也属于是经典题目了。 思路大概是接收参数，如果参数的长度>=1.那么就存储参数继续读取。否则的话就执行函数。

有一个巨大的问题就是add(1)(2)(3)(4, 5)()我的最后一个小括号要怎么去掉

代码

function addCurry(...args){
  return args.reduce((a,b) => {
    return a+b
  })
}
function currying(fn){
  let args = []
  return function temp(...newArgs){
    if(newArgs.length){
      args = [...args,...newArgs]
      return temp
    }else{
      let val = fn.apply(this,args)
      args = []
      return val
    }
  }
}


let add = currying(addCurry)
console.log(add(1)(2)(3)(4, 5)())
console.log(add(1)(2)(3, 4, 5)())
console.log(add(1)(2, 3, 4, 5)())