js如何使用递归？

Question

给定一个数组：

let arr = [0,1]

编写一个函数，期望得到的值：

[0,1,1,2,3,5,8,13,21....]

我的写法是：

    let arr = [0,1]
    function fn(props) {
      let length = props.length
      let xx = props[length-1] + props[length-2]
      props.push(xx)
      return props
    }
    setInterval(() => {
      console.log(fn(arr))
    },1000)

有没有别的方式，使用递归？

Answer 1

var arr = [0, 1]
/**
 * param arr {Array} 初始数组
 * param length {Number} 最终数组长度
 * returns {Array} 指定长度的数列
 */
var FBLQSL = (_arr, length) => { 
    while(arr.length < length){
      arr[arr.length] = arr[arr.length-2] + arr[arr.length-1]
    }
    return arr;
}
FBLQSL(arr, 10)

Answer 2

递归

let arr = [0, 1];
const LENGTH = 10;
function fn(props) {
  let length = props.length;
  let xx = props[length - 1] + props[length - 2];
  props.push(xx);
  props.length < LENGTH ? fn(props) : "";
}
fn(arr);
console.log(arr);//[ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ]

Answer 3

这个你最好用个循环，用递归会导致栈溢出，这个问题也不是个非线性的问题，不应该用递归来实现。这种线性问题应该用循环实现。

把setInterval改成以下循环：

let i=0;
for(i=0;i<9800;i++){
    fn(arr);
}

执行9880次。

Answer 4

let array = [0, 1];
let result = [];
const reduceFn = (array) => {
    array.reduce((prev, cur, index, arr) => {
        const sum = (prev || 0) + cur
        arr.push(sum)
        result.push(arr.shift())
    })
    // 加了个判断，怕栈溢出
    if (result.length < 30) {
        reduceFn(array)
    }
}
reduceFn(array)

Answer 5

function fib(arr) {
    var ret = arr.slice();
    for (var i = arr.length; i < 10; i++) ret.push(ret[i - 2] + ret[i - 1]);
    return ret;
}
console.log(fib([0, 1]));

Answer 6

const inputArr = [0, 1]
const maxLen = 10

const Y = f => (x => f(x(x)))(x => f((...y) => x(x)(...y)))

const recursive = f => (arr, maxLen) => {
  const len = arr.length
  return len >= maxLen
    ? arr
    : f(arr.concat(arr[len - 1] + arr[len - 2]), maxLen)
}

const outputArr = Y(recursive)(inputArr, maxLen)
console.log(outputArr)

如果有帮到你请 upvote ～