翻譯連載 | 第 9 章：遞歸（上）－《JavaScript輕量級函數式編程》 |《你不知道的JS》姊妹篇

時間 2019-11-09

標籤翻譯連載遞歸 javascript 輕量級函數編程你不知道的JS 欄目應用數學简体版

原文原文鏈接

原文地址：Functional-Light-JS
原文做者：Kyle Simpson－《You-Dont-Know-JS》做者

關於譯者：這是一個流淌着滬江血液的純粹工程：認真，是 HTML 最堅實的樑柱；分享，是 CSS 裏最閃耀的一瞥；總結，是 JavaScript 中最嚴謹的邏輯。通過捶打磨練，成就了本書的中文版。本書包含了函數式編程之精髓，但願能夠幫助你們在學習函數式編程的道路上走的更順暢。比心。前端

譯者團隊（排名不分前後）：阿希、blueken、brucecham、cfanlife、dail、kyoko-df、l3ve、lilins、LittlePineapple、MatildaJin、冬青、pobusama、Cherry、蘿蔔、vavd317、vivaxy、萌萌、zhouyaonode

第 9 章：遞歸（上）

在下一頁，咱們將進入到遞歸的論題。git

(本頁剩餘部分故意留白)github

咱們來談談遞歸吧。在咱們入坑以前，請查閱上一頁的正式定義。正則表達式

我知道，這個笑話弱爆了 :)算法

大部分的開發人員都認可遞歸是一門很是強大的編程技術，但他們並不喜歡去使用它。在這個意義上，我把它放在與正則表達式相同的類別中。遞歸技術強大但又使人困惑，所以被視爲 不值得咱們投入努力。編程

我是遞歸編程的超級粉絲，你，也能夠的！在這一章節中個人目標就是說服你：遞歸是一個重要的工具，你應該將它用在你的函數式編程中。當你正確使用時，遞歸編程能夠輕鬆地描述複雜問題。數組

定義

所謂遞歸，是當一個函數調用自身，而且該調用作了一樣的事情，這個循環持續到基本條件知足時，調用循環返回。性能優化

警告： 若是你不能確保基本條件是遞歸的 終結者，遞歸將會一直執行下去，而且會把你的項目損壞或鎖死；恰當的基本條件十分重要！bash

可是... 這個定義的書面形式太讓人疑惑了。咱們能夠作的更好些。思考下這個遞歸函數：

function foo(x) {
	if (x < 5) return x;
	return foo( x / 2 );
}
複製代碼

設想一下，若是咱們調用 foo(16) 將會發生什麼：

在 step 2 中, x / 2 的結果是 8，這個結果以參數的形式傳遞到 foo(..) 並運行。一樣的，在 step 3 中， x / 2 的結果是 4，這個結果以參數的形式傳遞到另外一個 foo(..) 並運行。希望我解釋得足夠直白。

可是一些人常常會在 step 4 中卡殼。一旦咱們知足了基本條件 x (值爲4) < 5，咱們將再也不調用遞歸函數，只是（有效地）執行了 return 4。特別是圖中返回 4 的虛線那塊，它簡化了那裏的過程，所以咱們來深刻了解最後一步，並把它折分爲三個子步驟：

該次的返回值會回過頭來觸發調用棧中全部的函數調用（而且它們都執行 return）。

另一個遞歸實例：

function isPrime(num,divisor = 2){
	if (num < 2 || (num > 2 && num % divisor == 0)) {
		return false;
	}
	if (divisor <= Math.sqrt( num )) {
		return isPrime( num, divisor + 1 );
	}

	return true;
}
複製代碼

這個質數的判斷主要是經過驗證，從2到 num 的平方根之間的每一個整數，看是否存在某一整數能夠整除 num (% 求餘結果爲 0)。若是存在這樣的整數，那麼 num 不是質數。反之，是質數。divisor + 1 使用遞歸來遍歷每一個可能的 divisor 值。

遞歸的最著名的例子之一是計算斐波那契數，該數列定義以下：

fib( 0 ): 0
fib( 1 ): 1
fib( n ):
	fib( n - 2 ) + fib( n - 1 )
複製代碼

注意: 數列的前幾個數值是： 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... 每個數字都是數列中前兩個數字之和。

直接用代碼來定義斐波那契：

function fib(n) {
	if (n <= 1) return n;
	return fib( n - 2 ) + fib( n - 1 );
}
複製代碼

函數 fib(..) 對自身進行了兩次遞歸調用，這一般叫做二分遞歸查找。後面咱們將會更多地討論二分遞歸查找。

在整個章節中，咱們將會用不一樣形式的 fib(..) 來講明關於遞歸的想法，但不太好的地方就是，這種特殊的方式會形成不少重複性的工做。 fib(n-1) 和 fib(n-2) 運行時候二者之間並無任何的共享，但作的事情幾乎又徹底相同，這種狀況一直持續到整個整數空間(譯者注：形參 n)降到 0 。

在第五章的性能優化方面咱們簡單的談到了記憶存儲技術。本章中，記憶存儲技術使得任意一個傳入到 fib(..) 的數值只會被計算一次而不是屢次。雖然咱們不會在這裏過多地討論這個技術話題，但不管是遞歸或其它任何算法，咱們都要謹記，性能優化是很是重要的。

相互遞歸

當一個函數調用自身時，很明顯，這叫做直接遞歸。好比前面部分咱們談到的 foo(..)，isPrime(..)以及 fib(..)。若是在一個遞歸循環中，出現兩個及以上的函數相互調用，則稱之爲相互遞歸。

這兩個函數就是相互遞歸：

function isOdd(v) {
	if (v === 0) return false;
	return isEven( Math.abs( v ) - 1 );
}

function isEven(v) {
	if (v === 0) return true;
	return isOdd( Math.abs( v ) - 1 );
}
複製代碼

是的，這個奇偶數的判斷笨笨的。但也給咱們提供了一些思路：某些算法能夠根據相互遞歸來定義。

回顧下上節中的二分遞歸法 fib(..)；咱們能夠換成相互遞歸來表示：

function fib_(n) {
	if (n == 1) return 1;
	else return fib( n - 2 );
}

function fib(n) {
	if (n == 0) return 0;
	else return fib( n - 1 ) + fib_( n );
}
複製代碼

注意： fib(..) 相互遞歸的實現方式改編自「用相互遞歸來實現斐波納契數列」研究報告(www.researchgate.net/publication…) 。

雖然這些相互遞歸的示例有點不切實際，可是在更復雜的使用場景下，相互遞歸是很是有用的。

爲何選擇遞歸？

如今咱們已經給出了遞歸的定義和說明，下面來看下，爲何說遞歸是有用的。

遞歸深諳函數式編程之精髓，最被普遍引證的緣由是，在調用棧中，遞歸把(大部分)顯式狀態跟蹤換爲了隱式狀態。一般，當問題須要條件分支和回溯計算時，遞歸很是有用，此外在純迭代環境中管理這種狀態，是至關棘手的；最起碼，這些代碼是不可或缺且晦澀難懂。可是在堆棧上調用每一級的分支做爲其本身的做用域，很明顯，這一般會影響到代碼的可讀性。

簡單的迭代算法能夠用遞歸來表達：

function sum(total,...nums) {
	for (let i = 0; i < nums.length; i++) {
		total = total + nums[i];
	}

	return total;
}

// vs

function sum(num1,...nums) {
	if (nums.length == 0) return num1;
	return num1 + sum( ...nums );
}
複製代碼

咱們不只用調用棧代替了 for 循環，並且用 returns 的形式在回調棧中隱式地跟蹤增量的求和（ total 的間歇狀態），而非在每次迭代中從新分配 total。一般，FPer 傾向於儘量地避免從新分配局部變量。

像咱們總結的那樣，在基本算法裏，這些差別是微乎其微的。可是，隨着算法複雜度的提高，你將更加能體會到遞歸帶來的收益，而不是這些命令式狀態跟蹤。

聲明式遞歸

數學家使用 Σ 符號來表示一列數字的總和。主要緣由是，若是他們使用更復雜的公式並且不得不手動書寫求和的話，會形成更多麻煩（並且會下降閱讀性！），好比 1 + 3 + 5 + 7 + 9 + ..。符號是數學的聲明式語言！

正如 Σ 是爲運算而聲明，遞歸是爲算法而聲明。遞歸說明：一個問題存在解決方案，但並不必定要求閱讀代碼的人瞭解該解決方案的工做原理。咱們來思考下找出入參最大偶數值的兩種方法：

function maxEven(...nums) {
	var num = -Infinity;

	for (let i = 0; i < nums.length; i++) {
		if (nums[i] % 2 == 0 && nums[i] > num) {
			num = nums[i];
		}
	}

	if (num !== -Infinity) {
		return num;
	}
}
複製代碼

這種實現方式不是特別難處理，但它的一些細微的問題也不容忽視。很明顯，運行 maxEven()，maxEven(1) 和 maxEven(1,13) 都將會返回 undefined？最終的 if 語句是必需的嗎？

咱們試着換一個遞歸的方法來對比下。咱們用下面的符號來表示遞歸：

maxEven( nums ):
	maxEven( nums.0, maxEven( ...nums.1 ) )
複製代碼

換句話說，咱們能夠將數字列表的 max-even 定義爲其他數字的 max-even 與第一個數字的 max-even 的結果。例如：

maxEven( 1, 10, 3, 2 ):
	maxEven( 1, maxEven( 10, maxEven( 3, maxEven( 2 ) ) )
複製代碼

在 JS 中實現這個遞歸定義的方法之一是：

function maxEven(num1,...restNums) {
	var maxRest = restNums.length > 0 ?
			maxEven( ...restNums ) :
			undefined;

	return (num1 % 2 != 0 || num1 < maxRest) ?
		maxRest :
		num1;
}
複製代碼

那麼這個方法有什麼優勢嗎？

首先，參數與以前不同了。我專門把第一個參數叫做 num1，剩餘的其它參數放在一塊兒叫做 restNums。咱們本能夠把全部參數都放在 nums 數組中，並從 nums[0] 獲取第一個參數。這是爲何呢？

函數的參數是專門爲遞歸定義的。它看起來像這樣：

maxEven( num1, ...restNums ):
	maxEven( num1, maxEven( ...restNums ) )
複製代碼

你有發現參數和遞歸之間的類似性嗎？

當咱們在函數體簽名中進一步提高遞歸的定義，函數的聲明也會獲得提高。若是咱們可以把遞歸的定義從參數反映到函數體中，那就更棒了。

但我想說最明顯的改進是，for 循環形成的錯亂感沒有了。全部循環邏輯都被抽象爲遞歸回調棧，因此這些東西不會形成代碼混亂。咱們能夠輕鬆的把精力集中在一次比較兩個數字來找到最大偶數值的邏輯中 —— 無論怎麼說，這都是很重要的部分！

從思想上來說，這如同一位數學家在更龐大的方程中使用 Σ 求和同樣。咱們說，「數列中剩餘值的最大偶數是經過 maxEven(...restNums) 計算出來的，因此咱們只須要繼續推斷這一部分。」

另外，咱們用 restNums.length > 0 保證推斷更加合理，由於當沒有參數的狀況下，返回的 maxRest 結果確定是 undefined。咱們不須要對這部分的推理投入額外的精力。這個基本條件（沒有參數狀況下）顯而易見。

接下來，咱們把精力放在對比 num1 和 maxRest 上 —— 算法的主要邏輯是如何肯定兩個數字中的哪個（若是有的話）是最大偶數。若是 num1 不是偶數（num1 % 2 != 0），或着它小於 maxRest，那麼，即便 maxRest 的值是 undefined，maxRest 會 return 掉。不然，返回結果會是 num1。

在閱讀整個實現過程當中，與命令式的方法相比，我所作這個例子的推理過程更加直接，核心點更加突出，少作無用功；比 for 循環中引用 無窮數值 這一方法 更具備聲明性。

小貼士： 咱們應該指出，除了手動迭代或遞歸以外，另外一種（可能更好的）建模的方法是咱們在在第7章中討論的列表操做。咱們先把數列中的偶數用 filter(..) 過濾出來，而後經過遞歸 reduce(..) 函數（對比兩個數值並返回其中較大的數值）來找到最大值。在這裏，咱們只是使用這個例子來講明在手動迭代中遞歸的聲明性更強。

還有一個遞歸的例子：計算二叉樹的深度。二叉樹的深度是指經過樹的節點向下（左或右）的最長路徑。還有另外一種經過遞歸來定義的方式：任何樹節點的深度爲1（當前節點）加上來自其左側或右側子樹的深度的最大值：

depth( node ):
	1 + max( depth( node.left ), depth( node.right ) )
複製代碼

直接轉換爲二分法遞歸函數：

function depth(node) {
	if (node) {
		let depthLeft = depth( node.left );
		let depthRight = depth( node.right );
		return 1 + max( depthLeft, depthRight );
	}

	return 0;
}
複製代碼