好程式設計師 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>

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 方法。

總結

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

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

相關文章