因为其实是一个题目，我就不分初级高级把一些常见的方法都一起过一遍。
- 普通递归法(n大了容易爆栈)
const fibonacci = (n) => {
if(n == 1 || n == 2) {
return 1;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
分析：逻辑简单，容易理解，但是费时，栈容易爆
- 尾调用优化递归
const fibonacci = (n,a = 1,b = 1) => {
if(n == 1 || n == 2) {
return b;
} else {
return fibonacci(n-1,b,a+b);
}
}
分析：因为函数最后没有用到任何外部的值，所以有尾调用优化，不存在费空间的问题，但是同样费时间，比如我们在计算fibonacci(10)的时候我们已经算出来10之前的所有项，但是如果我们现在算fibonacci(11)，就又需要从头开始计算。
- 普通循环
const fibonacci = (n) => {
let [a, b] = [1, 1];
if (n <= 2) {
return 1;
}
for (let i = 1; i < n; i++) {
[a, b] = [b, a + b];
}
return a;
}
分析： 跟上面一种方法差不多，没有记忆功能，不可能过得了测试。
其实，就单单算一次fibonacci的话，用3和2的方法都挺快的，但是如果我们要算很多个fibonacci的话(调用多次fibonacci()函数)，我们就需要把每次得到的结果保存下来，因为题目说了不要使用全局变量，所以我们就不得不使用闭包。
下面贴几个我认为比较好的方法 --来自网友; )
第一种
const fibonacci = ((memory = {}) => n => {
if(n < 2) return n
if(memory[n-2] === undefined){
memory[n-2] = fibonacci(n-2)
}
if(memory[n-1] === undefined){
memory[n-1] = fibonacci(n-1)
}
return memory[n] = memory[n-1] + memory[n-2]
})()
贴这个方法的人还问了为什么这个方法比另一个快，我们看看
const fibonacci = n =>{ let [a, b] = [0, 1] while(n--){[a, b] = [b, a + b]} return a }
有网友回复：
分析：刚才我们已经分析过了，下面的这种写法没有记忆能力，第一种方法用了闭包，把所有的结果保存到一个对象中，并不是网友回复对象更快这个原因，单纯就是第二种方法完全没有记忆能力，大家一定要擦亮自己的眼睛。我们来试试把对象换成数组（只需要把(memory = {})的大括号改成中括号[]），结果还是AC啦，完全没有问题。
第二种
const fibonacci = (n) => {
if (!fibonacci.cache) {
fibonacci.cache = [];
for (let i = 1; i <= 1000000; i++) {
if (i === 1 || i === 2) {
fibonacci.cache[i] = 1;
}
else if (i > 2) {
fibonacci.cache[i] = fibonacci.cache[i - 1] + fibonacci.cache[i - 2];
}
}
}
return fibonacci.cache[n];
}
分析：这种方法没有用到闭包，而是把结果添加到函数对象的一个属性上，并且不管问的是多少，我们先算个1000000以内的斐波那契数列，然后不管问哪里都可以。
第三种（一行）
const fibonacci = ((s) => (f = (i) => s[i] || (s[i] = f(i - 1) + f(i - 2))))([0, 1, 1])
为了让大家看的更加清楚一点，我们不用箭头函数的写法
const fibonacci = (function fibonacci(s) {
return function f(i) {
return s[i] === undefined ? (s[i] = f(i - 1) + f(i - 2)) : s[i];
}
})([0, 1, 1]);
分析：也是闭包，用数组存放结果，写的比较简洁优雅。
第四种
const fibonacci = ((dp) => (n) => {
if (dp[n]) {
return dp[n];
}
for (let i = dp.length - 1; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
})([0, 1, 1]);
分析：跟第三种类似，也是用闭包存储数据，区别就是3是递归调用函数（从大到小）来算值的，而4是（从小到大）来算值的。
涉及到的知识点：
