这个问题是关于 Eloquent JavaScript 一书中的一个练习

Question

本练习的最后一部分是编写一个递归函数，它接受两个参数，分别是连接列表和索引。该函数将在列表中的相应索引处查找对象中的值。我编写的代码按我想要的方式工作（我可以看到它在每次调用该函数时都在 console.log 中工作。但在最后一次它引用 undefined 作为我的值。我不明白为什么。哦，它有效索引为 0。代码如下。

首先，列表如下所示：

list = {
    value: 1,
    rest: {
        value: 2,
        rest: {
            value: 3,
            rest: null
            }
        }
    };



   const nth = (list, targetNum) => {
   let value = Object.values(list)[0];
   if (targetNum == 0) {
       return value;
   } else {
       targetNum = targetNum -1;
       list = Object.values(list)[1];
    //    console.log(value);
    //    console.log(targetNum);
    //    console.log(list);
       nth(list, targetNum);
   }
};
console.log(nth(arrayToList([1,2,3]),2)); 

下面是 arrayToList 的代码，它是练习的第一部分，如果你有任何很酷的 cmets，导致提示最终建议从最后构建列表。

const arrayToList = (arr) => { 
    let list = {
        value: arr[0],
        rest: nestObject()
    };
    function nestObject() {
        let rest = {};
        arr.shift();
        const length = arr.length;
        if (length == 1) {
            rest.value = arr[0];
            rest.rest = null;
        } else {
            rest.value = arr[0];
            rest.rest = nestObject();
        }
        return rest;   
    }
    return list;
};

Answer 1

你只需要在递归调用nth时添加一个return。否则执行逻辑但不返回值（除非targetNum为0）

const nth = (list, targetNum) => {
   let value = Object.values(list)[0];
   if (targetNum == 0) {
       return value;
   } else {
       targetNum = targetNum -1;
       list = Object.values(list)[1];
       return nth(list, targetNum); // return needed here too
   }
};

或者更简洁：

const nth = (list, n) => n === 0 ? list.value : nth(list.rest, n - 1)

这是另一个非递归的arrayToList，它从末尾构建列表：

const arrayToList = arr => arr.slice().reverse().reduce((rest, value) => ({value, rest}), null);

（这里的slice只是为了复制数组，以免原地反转。）

Answer 2

这两种解决方案都令人费解且不必要的冗长。实际上，这两个函数都可以是单行的。这里有一些提示：

对于toList 的事情，请考虑以下几点：

• 如果输入数组为空，则返回null（基本情况）

• 否则，将输入数组拆分为“head”（=第一个元素）和“tail”（=其余元素）。例如[1,2,3,4] => 1 and [2,3,4]

• 返回一个对象，value 等于“头”，rest 等于 toList 应用于“尾”（递归）

在更高级的说明中，拆分可以直接在函数签名中进行解构：

const toList = ([head=null, ...tail]) => ...

nth(list, N) 也是如此

• 如果N 为零，则返回list.value（基本情况）

• 否则，返回带有参数list.rest 和N-1（递归）的nth 应用程序

同样，签名可以从解构中受益：

const nth = ({value, rest}, n) => 

完整代码，如果你有兴趣：

const toList = ([value = null, ...rest]) =>
    value === null
        ? null
        : {value, rest: toList(rest)}

const nth = ({value, rest}, n) =>
    n === 0
        ? value
        : nth(rest, n - 1)

//

let lst = toList(['a', 'b', 'c', 'd', 'e', 'f'])
// or simply toList('abcdef')

console.log(lst)

console.log(nth(lst, 0))
console.log(nth(lst, 4))

Answer 3

Georg’s recursive solutions 很漂亮！

我想添加来自the book 的提示“从头开始构建列表”解决方案：

const arrayToList => (arr) => {
  var list
  while (arr.length) {
    list = {value: arr.pop(), rest: list}
  }
  return list
}