好程式設計師web前端分享用JavaScript實現的5個常見函式

好程式設計師IT發表於2019-04-08

好程式設計師 web 前端分享 JavaScript 實現的 5 個常見函式 在學習 JavaScript ,或者前端面試中,有人會問你節流函式、防抖函式、遞迴函式等,本文分享了 5 個常見函式,希望對 大家 有所幫助。

 

JavaScript 中有一些問題會被拿出來經常討論,這些問題每個人都有不同的思路,想要理解這些問題,最好的方法就是自己實現一遍,話不多說,開始正題。

 

陣列扁平化

 

陣列扁平化有很多方法,但最終最好的方法就是遞迴,實現一個指定深度的扁平化方法,這樣基本的套路都會了解。

 

function flattenDepth(array, depth = 1) {

  let result = []

  array.forEach(item => {

    let d = depth

    if (Array.isArray(item) && d > 0) {

      result.push(...(flattenDepth(item, --d)))

    } else {

      result.push(item)

    }

  })

  return result

}

 

console.log(flattenDepth([1, [2, [3, [4]], 5]])) // [ 1, 2, [ 3, [ 4 ] ], 5 ]

console.log(flattenDepth([1, [2, [3, [4]], 5]], 2)) // [ 1, 2, 3, [ 4 ], 5 ]

console.log(flattenDepth([1, [2, [3, [4]], 5]], 3)) // [ 1, 2, 3, 4, 5 ]

遞迴實現很簡潔易懂,就是將每一項遍歷,如果某一項為陣列,則讓該項繼續呼叫,這裡指定了 depth 作為扁平化的深度,因為這個引數對陣列的每一項都要起作用,故放在迴圈的裡面。

 

柯里化

 

函式的柯里化都被講爛了,每個人都有自己的理解和實現方法,一句話解釋就是 引數夠了就執行,引數不夠就返回一個函式,之前的引數存起來,直到夠了為止

 

function curry(func) {

  var l = func.length

  return function curried() {

    var args = [].slice.call(arguments)

    if(args.length < l) {

      return function() {

        var argsInner = [].slice.call(arguments)

        return curried.apply(this, args.concat(argsInner))

      }

    } else {

      return func.apply(this, args)

    }

  }

}

 

var f = function(a, b, c) {

  return console.log([a, b, c])

};

 

var curried = curry(f)

curried(1)(2)(3) // => [1, 2, 3]

curried(1, 2)(3) // => [1, 2, 3]

curried(1, 2, 3) // => [1, 2, 3]

上面的程式碼不難看出,每次判斷引數的個數,與被柯里化的函式引數個數比較,如果小於就繼續返回函式,否則就執行。

 

防抖

 

防抖按照我的理解就是 不管你觸發多少次,都等到你最後觸發後過一段你指定的時間才觸發 。按照這個解釋,寫一個基本版的。

 

function debounce(func, wait) {

  var timer

  return function() {

    var context = this

    var args = arguments

    clearTimeout(timer)

    timer = setTimeout(function() {

      func.apply(context, args)

    }, wait)

  }

}

現在有個要求就是剛開始的時候也觸發,最後一次也觸發,並且可以配置,先寫個測試頁面方便測試功能,每次按空格鍵就會讓數字加 1 ,來測試防抖和節流函式。

 

<!DOCTYPE html>

<html>

<head>

    <style>

        #container{text-align: center; color: #333; font-size: 30px;}

    </style>

</head>

<body>

    <div id="container"></div>

    <script>

      var count = 1

      var container = document.getElementById('container')

      function getUserAction(e) {

        // 空格

        if (e.keyCode === 32) {

          container.innerHTML = count++

        }

      }

      // document.onkeydown = debounce(getUserAction, 1000, false, true)

      document.onkeydown = throttle(getUserAction, 1000, true, true)

      function debounce(func, wait, leading, trailing) {}

      function throttle(func, wait, leading, trailing) {}

    </script>

</body>

</html>

透過 leading trailing 兩個引數來決定開始和結束是否執行,如果 leading true ,則沒次按空格都會執行一次,如果 trailing true ,則每次結束都會將最後一次觸發執行。以防抖函式距離,如果兩者都為 true ,則第一次按空格會加 1 ,然後快速按空格,此時裡面的 getUserAction 並不會執行,而是等到鬆手後再執行,加入 trailing false ,則鬆手後不會執行。

 

function debounce(func, wait, leading, trailing) {

  var timer, lastCall = 0, flag = true

  return function() {

    var context = this

    var args = arguments

    var now = + new Date()

    if (now - lastCall < wait) {

      flag = false

      lastCall = now

    } else {

      flag = true

    }

    if (leading && flag) {

      lastCall = now

      return func.apply(context, args)

    }

    if (trailing) {

      clearTimeout(timer)

      timer = setTimeout(function() {

        flag = true

        func.apply(context, args)

      }, wait)

    }

  }

}

解釋一下,每次記錄上次呼叫的時間,與現在的時間對比,小於間隔的話,第一次執行後之後就不會執行,大於間隔或在間隔時間後呼叫了,則重置 flag ,可以與上面那個基本版的對比著看。

 

節流

 

節流就是, 不管怎麼觸發,都是按照指定的間隔來執行 ,同樣給個基本版。

 

function throttle(func, wait) {

  var timer

  return function() {

    var context = this

    var args = arguments

    if (!timer) {

      timer = setTimeout(function () {

        timer = null

        func.apply(context, args)

      }, wait)

    }

  }

}

同樣和防抖函式一樣加上兩個引數,也可使用上面的例子來測試,其實兩者的程式碼很類似。

 

function throttle(func, wait, leading, trailing) {

  var timer, lastCall = 0, flag = true

  return function() {

    var context = this

    var args = arguments

    var now = + new Date()

    flag = now - lastCall > wait

    if (leading && flag) {

      lastCall = now

      return func.apply(context, args)

    }

    if (!timer && trailing && !(flag && leading)) {

      timer = setTimeout(function () {

        timer = null

        lastCall = + new Date()

        func.apply(context, args)

      }, wait)

    } else {

      lastCall = now

    }

  }

}

物件複製

 

物件複製都知道分為深複製和淺複製,黑科技手段就是使用

 

JSON.parse(JSON.stringify(obj))

還有個方法就是使用遞迴了

 

function clone(value, isDeep) {

  if (value === null) return null

  if (typeof value !== 'object') return value

  if (Array.isArray(value)) {

    if (isDeep) {

      return value.map(item => clone(item, true))

    }

    return [].concat(value)

  } else {

    if (isDeep) {

      var obj = {}

      Object.keys(value).forEach(item => {

        obj[item] = clone(value[item], true)

      })

      return obj

    }

    return { ...value }

  }

}

 

var objects = { c: { 'a': 1, e: [1, {f: 2}] }, d: { 'b': 2 } }

var shallow = clone(objects, true)

console.log(shallow.c.e[1]) // { f: 2 }

console.log(shallow.c === objects.c) // false

console.log(shallow.d === objects.d) // false

console.log(shallow === objects) // false

對於基本型別直接返回,對於引用型別,遍歷遞迴呼叫 clone 方法。

 

總結

 

其實對於上面這些方法,總的來說思路就是遞迴和高階函式的使用,其中就有關於閉包的使用,前端就愛問這些問題,最好就是自己實現一遍,這樣有助於理解。


來自 “ ITPUB部落格 ” ,連結:http://blog.itpub.net/69913892/viewspace-2640684/,如需轉載,請註明出處,否則將追究法律責任。

相關文章