您好,登錄后才能下訂單哦!
好程序員 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 方法。
總結
其實對于上面這些方法,總的來說思路就是遞歸和高階函數的使用,其中就有關于閉包的使用,前端就愛問這些問題,最好就是自己實現一遍,這樣有助于理解。
免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。