用javaScript實作的5個函數

1.資料扁平化

數組扁平化有很多方法，但最終最好的方法就是遞歸，實作一個指定深度的扁平化方法，這樣基本的套路都會了解。

function flattenDepth(array, depth = 1) {
 2  let result = []
 3  array.forEach(item => {
 4    let d = depth
 5    if (Array.isArray(item) && d > 0) {
 6      result.push(...(flattenDepth(item, --d)))
 7    } else {
 8      result.push(item)
 9    }
10  })
11  return result
12}
13
14console.log(flattenDepth([1, [2, [3, [4]], 5]])) // [ 1, 2, [ 3, [ 4 ] ], 5 ]
15console.log(flattenDepth([1, [2, [3, [4]], 5]], 2)) // [ 1, 2, 3, [ 4 ], 5 ]
16console.log(flattenDepth([1, [2, [3, [4]], 5]], 3)) // [ 1, 2, 3, 4, 5 ]

           

遞歸實作很簡潔易懂，就是将每一項周遊，如果某一項為數組，則讓該項繼續調用，這裡指定了 depth 作為扁平化的深度，因為這個參數對數組的每一項都要起作用，故放在循環的裡面。

2，函數柯裡化

function curry(func) {
 2  var l = func.length
 3  return function curried() {
 4    var args = [].slice.call(arguments)
 5    if(args.length < l) {
 6      return function() {
 7        var argsInner = [].slice.call(arguments)
 8        return curried.apply(this, args.concat(argsInner))
 9      }
10    } else {
11      return func.apply(this, args)
12    }
13  }
14}
15
16var f = function(a, b, c) {
17  return console.log([a, b, c])
18};
19
20var curried = curry(f)
21curried(1)(2)(3) // => [1, 2, 3]
22curried(1, 2)(3) // => [1, 2, 3]
23curried(1, 2, 3) // => [1, 2, 3]
           

上面的代碼不難看出，每次判斷參數的個數，與被柯裡化的函數參數個數比較，如果小于就繼續傳回函數，否則就執行。

3，節流函數

function throttle(func, wait) {
 2  var timer
 3  return function() {
 4    var context = this
 5    var args = arguments
 6    if (!timer) {
 7      timer = setTimeout(function () {
 8        timer = null
 9        func.apply(context, args)
10      }, wait)
11    }
12  }
13}
           

4.對象拷貝

function clone(value, isDeep) {
 2  if (value === null) return null
 3  if (typeof value !== 'object') return value
 4  if (Array.isArray(value)) {
 5    if (isDeep) {
 6      return value.map(item => clone(item, true))
 7    }
 8    return [].concat(value)
 9  } else {
10    if (isDeep) {
11      var obj = {}
12      Object.keys(value).forEach(item => {
13        obj[item] = clone(value[item], true)
14      })
15      return obj
16    }
17    return { ...value }
18  }
19}
20
21var objects = { c: { 'a': 1, e: [1, {f: 2}] }, d: { 'b': 2 } }
22var shallow = clone(objects, true)
23console.log(shallow.c.e[1]) // { f: 2 }
24console.log(shallow.c === objects.c) // false
25console.log(shallow.d === objects.d) // false
26console.log(shallow === objects) // false