前言
在學習 JavaScript，或者前端面試中，有人會問你節流函數、防抖函數、遞歸函數等，本文分享了5個常見函數，希望對你有所幫助。
在 JavaScript 中有一些問題會被拿出來經常讨論，這些問題每個人都有不同的思路，想要了解這些問題，最好的方法就是自己實作一遍，話不多說，開始正題。
數組扁平化
數組扁平化有很多方法，但最終最好的方法就是遞歸，實作一個指定深度的扁平化方法，這樣基本的套路都會了解。
1function 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 作為扁平化的深度，因為這個參數對數組的每一項都要起作用，故放在循環的裡面。
柯裡化
函數的柯裡化都被講爛了，每個人都有自己的了解和實作方法，一句話解釋就是 參數夠了就執行，參數不夠就傳回一個函數，之前的參數存起來，直到夠了為止 。
1function 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] 上面的代碼不難看出，每次判斷參數的個數，與被柯裡化的函數參數個數比較，如果小于就繼續傳回函數，否則就執行。
防抖
防抖按照我的了解就是 不管你觸發多少次，都等到你最後觸發後過一段你指定的時間才觸發 。按照這個解釋，寫一個基本版的。
1function debounce(func, wait) {
2 var timer
3 return function() {
4 var context = this
5 var args = arguments
6 clearTimeout(timer)
7 timer = setTimeout(function() {
8 func.apply(context, args)
9 }, wait)
10 }
11} 現在有個要求就是剛開始的時候也觸發，最後一次也觸發，并且可以配置，先寫個測試頁面友善測試功能，每次按空格鍵就會讓數字加1，來測試防抖和節流函數。
1<!DOCTYPE html>
2<html lang="zh-cmn-Hans">
3<head>
4 <style> 5 #container{text-align: center; color: #333; font-size: 30px;}
6 </style>
7</head>
8<body>
9 <div id="container"></div>
10 <script>11 var count = 1
12 var container = document.getElementById('container')
13 function getUserAction(e) {
14 // 空格
15 if (e.keyCode === 32) {
16 container.innerHTML = count++
17 }
18 }
19 // document.onkeydown = debounce(getUserAction, 1000, false, true)
20 document.onkeydown = throttle(getUserAction, 1000, true, true)
21 function debounce(func, wait, leading, trailing) {}
22 function throttle(func, wait, leading, trailing) {}
23 </script>
24</body>
25</html> 通過 leading 和 trailing 兩個參數來決定開始和結束是否執行，如果 leading 為 true，則沒次按空格都會執行一次，如果 trailing 為 true，則每次結束都會将最後一次觸發執行。以防抖函數距離，如果兩者都為 true，則第一次按空格會加 1，然後快速按空格，此時裡面的 getUserAction 并不會執行，而是等到松手後再執行，加入 trailing 為 false，則松手後不會執行。
1function debounce(func, wait, leading, trailing) {
2 var timer, lastCall = 0, flag = true
3 return function() {
4 var context = this
5 var args = arguments
6 var now = + new Date()
7 if (now - lastCall < wait) {
8 flag = false
9 lastCall = now
10 } else {
11 flag = true
12 }
13 if (leading && flag) {
14 lastCall = now
15 return func.apply(context, args)
16 }
17 if (trailing) {
18 clearTimeout(timer)
19 timer = setTimeout(function() {
20 flag = true
21 func.apply(context, args)
22 }, wait)
23 }
24 } 解釋一下，每次記錄上次調用的時間，與現在的時間對比，小于間隔的話，第一次執行後之後就不會執行，大于間隔或在間隔時間後調用了，則重置 flag，可以與上面那個基本版的對比着看。
節流
節流就是， 不管怎麼觸發，都是按照指定的間隔來執行 ，同樣給個基本版。
1function 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} 同樣和防抖函數一樣加上兩個參數，也可使用上面的例子來測試，其實兩者的代碼很類似。
1function throttle(func, wait, leading, trailing) {
2 var timer, lastCall = 0, flag = true
3 return function() {
4 var context = this
5 var args = arguments
6 var now = + new Date()
7 flag = now - lastCall > wait
8 if (leading && flag) {
9 lastCall = now
10 return func.apply(context, args)
11 }
12 if (!timer && trailing && !(flag && leading)) {
13 timer = setTimeout(function () {
14 timer = null
15 lastCall = + new Date()
16 func.apply(context, args)
17 }, wait)
18 } else {
19 lastCall = now
20 }
21 }
22} 對象拷貝
對象拷貝都知道分為深拷貝和淺拷貝，黑科技手段就是使用
1JSON.parse(JSON.stringify(obj)) 還有個方法就是使用遞歸了
1function 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 對于基本類型直接傳回，對于引用類型，周遊遞歸調用 clone 方法。
總結
其實對于上面這些方法，總的來說思路就是遞歸和高階函數的使用，其中就有關于閉包的使用，前端就愛問這些問題，最好就是自己實作一遍，這樣有助于了解。
![Django之驗證碼（十七）驗證碼[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)