如何通过递归检查数组中的所有数字元素是否都是偶数？

Question

我目前正在尽可能多地学习递归，但我真的不知道如何使用它来检查数组中的所有数字元素是否都是偶数。使用 ES6，我可以使用 "every" 来实现如下期望的结果：

const isEven = (arr) => arr.every((item) => item % 2 === 0);
console.log(isEven([2,4,6,8])); // true
console.log(isEven([2,4,6,9])); // false

以下是我的递归尝试：

const isEven = (arr) => (arr.length === 0) ? true : isEven(arr.slice(1)) % 2 === 0;
console.log(isEven([2,4,6,8])); // true
console.log(isEven([2,4,6,9])); // true

如您所见，第二个示例的结果不正确，我感觉我也没有走在正确的道路上。有人可以告诉我我做错了什么吗？

Answer 1

您的实现的问题是isEven 返回一个boolean，但您尝试将结果当作数字来使用。因此，事实证明，返回结果仅基于元素的数量，因为每次翻转：

console.log("true % 2 === 0 :", true % 2 === 0);
console.log("false % 2 === 0:", false % 2 === 0);

const isEven = (arr) => (arr.length === 0) ? true : isEven(arr.slice(1)) % 2 === 0;
console.log(isEven([]));     // true
console.log(isEven([1]));    // false
console.log(isEven([1, 1])); // true

如果我们将您的函数完全写成单个条件运算符，我们可以通过添加一些日志来更好地了解发生了什么：

const isEven = (arr) => {
  if (arr.length === 0) {
    console.log("base case - finish recursion. result: true");
    return true;
  }
  const recursionValue = isEven(arr.slice(1));
  const result = recursionValue % 2 === 0;
  console.log(`After recursion: 
  recursionValue: ${recursionValue} 
  result        : ${result}`);
  return result;
}

console.log(isEven([2,4,6,9])); // true

.as-console-wrapper { max-height: 100% !important; }

或者以不同的方式说明这一点，这就是递归的解决方式：

isEven([2,4,6,9])
| --> | isEven([4,6,9]) % 2 === 0
|     | --> | isEven([6,9]) % 2 === 0
|     |     | --> | isEven([9]) % 2 === 0
|     |     |     | --> isEven([]) % 2 === 0
|     |     |     |   | --> arr.length === 0 --> true
|     |     |     |   | true % 2 === 0 --> false
|     |     |     | false % 2 === 0  --> true
|     |     | true % 2 === 0 --> false
|     | false % 2 === 0 --> true
| true

---

要实现您想要的，您需要每次都检查第一个元素，而不是 isEven 的结果。

• 如果数组为空，那么整个数组一定是偶数。这是基本情况。递归结束，结果为true
• 如果第一个元素是奇数，则并非所有数组都是偶数。这是一个终止条件。结束递归并返回false - 这意味着不会达到基本情况。
• 如果数组中有个项并且第一项是偶数，则只需使用数组的其余部分进行递归，每次检查上述两个条件。

这可确保您在第二个条件从未达到时获得true，或者在曾经达到时获得false。

const isEven = (arr) => {
  if (arr.length === 0) // empty - base case
    return true;
  if (arr[0] % 2 === 1) // odd - stop and return false
    return false;
    
  return isEven(arr.slice(1)); // recursion
}

console.log(isEven([2,4,6,8])); // true
console.log(isEven([2,4,6,9])); // false

Answer 2

问题出在isEven(arr.slice(1)) % 2 === 0 部分。 isEven 函数应该返回一个布尔值，对其取模没有意义。

相反，您可以这样做：

isEven = arr => arr.length === 0 ? true : arr[0] % 2 === 0 && isEven(arr.slice(1));

Answer 3

前提应该是：

数组是偶数，如果第一个元素是偶数，数组的其余部分（也是一个数组）也是偶数

所以基本上：

const isEven = (arr) => (arr.length === 0) ? true : arr[0] % 2 === 0 && isEven(arr.slice(1));

这可以通过解构稍微重写以更好地举例说明。

const isEven = ([first, ...rest]) =>
    (first % 2 === 0) &&
    (rest.length ? isEven(rest) : true);