@LongHorn-C

对于一些言论的man，我的意见是： 先让自己找到体面的工作，再在这里装B！ 饭都吃不饱，装嘛B！自己写的程序不能让自己体面地生活，那就表明这个人也只能做些虚拟的装B，其写的代码狗P不是。

这世界上有很多黑客，从来不会结交那些天真幼稚的小朋友做伙伴，因为黑客的精神重在探索和发布，而不是跟你在网上过家家。

@LongHorn-C

你有没有体面的工作，吃不吃的饱，我不关心。

至少我现在吃的饱，工作够体面，写的代码公司客户同事都买单，每天有环境规模做做研究，有时间发发文字，打打游戏，写写开源的东西。

@LongHorn-C

算法效率，拜托你发个测试截图，再来跟我摆货。

你最大的问题就是连 $ node > ctrl + shift + v 都不会

1. 那个代码现在没有任何问题
2. 写个你的高效率算法代码给我看看
3. 把你的测试截图给我看看

@LongHorn-C

1、sets参数是多余的

谁跟你说sets参数是多余的

return x in cache
       ? cache[x]
       : cache[x] = f(sets[x]);

2、缓存的作用非常有限

先学习函数式编程的基础课，再跟我谈缓存

自己把源代码复制到控制台，输出，仔细看看

@coordcn

楼主啊，我以为就我一个人对你有意见呢，原来人还不少啊，分享是好事情，但要多矮下身段来多跟人交流。

可以，发个你比我高明的代码，我自然会放下身段向你学习。我在这的帖子，只不过是推广，我写了文字，在很多网站都发同样的帖子。 而且有时候是同事帮我在每个地方发布。你当我是什么社区忠实的会员？

然而现在，你要向我的https://cnodejs.org/topic/55169b51e26684ed7ff21e1d好好学习，直到你写出比这个代码高明的时候。

如果你写不出来，正如那句话:

Talk is cheap, show me the code

@zysam

有点意思，python风格的代码倒适合描述事件的命名。不过用过python一段时间，我还是没有坚持住没有大括号的习惯。

@LongHorn-C

连自己的代码都不会编辑的你，说的话都不带打草稿的。 我到现在没见到你那code。

1. 我的代码有什么问题？
2. 你的代码在哪？

我觉得不知羞耻、空口白话很适合你。我们现在就可以从此楼辩个真章，上你的代码，我的代码已经摆在那了，要我再copy一次么。

@dayuoba

fibonacci的算法如下：

f(0) : 0 f(1) : 1 f(2) : f(1) + f(0) 1 f(3) : f(2) + f(1) 2 f(4) : f(3) + f(2) 3 f(5) : f(4) + f(3) 5 …

知道了这个规律，可以编码如下：

function fibonacci(n) {
    if (n === 0) {
        return 0;
    }
    if (n === 1) {
        return 1;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

实际运行，你会发现：

fibonacci(1000):
    调用fibonacci(999):
        调用fibonacci(998):
            调用fibonacci(997):
                调用fibonacci(996):
                    ...
                调用fibonacci(995):
                    ...
            调用fibonacci(996):
                ...
        调用fibonacci(997):
            ...
    调用fibonacci(998):
        调用fibonacci(997):
            ...
        调用fibonacci(996):
            ...

其中的很多是被重复调用，这就造成计算浪费，可以使用存储的方式：

• 0, 1是已知的，所以不计算了，直接放入缓存.
• 计算的时候，先从缓存取值. 如果是数字，那么表明n的计算已经被缓存过，直接返回.
• 如果不是数字，那么表明还没有缓存过n的计算，做一次fibonacci. 记住，这时候n一定是大于1的，所以放心的做fibonacci(n - 1) + fibonacci(n - 2)这样的计算.
• 计算完，把新的值保存进缓存.

function fibonacci() {
    var cache = [0, 1];  // 0, 1的值是固定值
    return function walk(n) {
        var result = cache[n];  // 先从缓存中取值
        if (typeof result !== 'number') {  // 是否是有效值？
            result =  walk(n - 1) + walk(n - 2);  // 不是，做一次fibonacci
            cache[n] = result;  // 把值加入缓存
        }
        return result;  // 返回计算结果
    };
}

var f = fibonacci();
f(0); // 0
f(1); // 1
f(2); // 1
f(3); // 2
f(4); // 3
f(5); // 5
f(6); // 8
f(7); // 13
f(8); // 21
...

这个代码写完，其实我也很满意，这是我经常发帖的一个原因：可以经常巧遇，写些工作中遇不到的算法解题。 这个代码我觉得还算不错吧。

@LongHorn-C

把你爹的代码和《javascript权威指南》复制过来的代码拼凑在一起，表示你懂了函数式编程？ 谁告诉你函数式编程memorize是一个固定的写法？？？

1. 如果没有给你memorize，你还不会写了？ 2. 每次写代码，你都先写好一个memorize才能写别的代码？ 3. 你拼凑的代码行数计算效率提高多少？

也不看看你爹的代码行数和你自己的代码行数。 谈函数式编程，你还早十年呢。写出自己的代码才是真的懂，孩子，别在这里脑残了。

@LongHorn-C

让我给你做个速度测试，孩子!!!

计算100

• 你的花费了14ms
• 哥的好像才1ms

计算1000

• 你的花费了38ms
• 哥的好像也是才1ms

计算10000

• 你的堆栈溢出了，宝贝！RangeError: Maximum call stack size exceeded
• 哥的好像也是才3ms

function memorize(f) {
    var cache = {}; 
    return function(){
        var key = arguments.length + Array.prototype.join.call(arguments,',');      
        if (key in cache) {console.log('retrieve from cache'); return cache[key];}
        else  return cache[key]=f.apply(this,arguments);
    }

}

fibonacci =memorize(function(n) {
    if (n === 0) {
         return 0;
        }
    if (n === 1) {
        return 1;
    }
        return fibonacci(n - 1) + fibonacci(n - 2);
});


var start = new Date();
fibonacci(1000);
var end = new Date();
console.log('Time: %dms.', end.getTime() - start.getTime());
// 38ms

function fibonacci() {
    var cache = [0, 1];  // 0, 1的值是固定值
    return function walk(n) {
        var result = cache[n];  // 先从缓存中取值
        if (typeof result !== 'number') {  // 是否是有效值？
            result =  walk(n - 1) + walk(n - 2);  // 不是，做一次fibonacci
            cache[n] = result;  // 把值加入缓存
        }
        return result;  // 返回计算结果
    };
}



var start = new Date();
var f = fibonacci();
f(1000);
var end = new Date();
console.log('Time: %dms.', end.getTime() - start.getTime());
// 3ms

@LongHorn-C

逗比，你的代码到3697就堆栈溢出，还有脸贴，我呸！！！

（我当然知道你的console, 自己去掉console试试谁的速度慢，我的要比你慢，我是你孙子！反之，你是我孙子！）

（去掉console, 哥的速度是你的3倍！年轻人，copy来的代码不要那么狂妄！）

var start = new Date();
fibonacci(3697);
var end = new Date();
console.log('Time: %dms.', end.getTime() - start.getTime());

king@king-pc:~$ node test

(null):0
(null)

RangeError: Maximum call stack size exceeded

@LongHorn-C

还不赶快跪下来叫爷爷！！！

@LongHorn-C

呵呵，又不比速度了！

那请问，你的代码能用吗? fibonacci(3697);就堆栈溢出，你还长脸了？？？

你的代码就是没法使用，毫不安全，无法信任的一坨shi！！！

@coordcn

Talk is cheap, show me the code

你这种饭都吃不饱的东西，我一点跟你讨论的兴趣都没有。

今天早上很顺心的开始工作，看来可以很快完成<<nodejs那些事儿>>的第一篇文字了。

正如康熙说的，thank u, my enemies，让我学会了如何思考消灭你们

@LongHorn-C

1. 速度你不行
2. 稳定性你不行，3697就完蛋
3. 代码行数你不行，哥的目测11行
4. 使用？ var f = fibonacci(); f(1); f(2);
5. 你抄袭了《javascript权威指南》和我的源码

先想想怎么解决你的堆栈吧，菜鸟，就这么点，还真跟你相配！

@dayuoba

还是要提醒你一点，javascript在没有尾递归优化前提下，递归深度过大总会出现堆栈溢出。 这个fibonacci因为每次要调用两个前面的项，我现在认为无法使用尾递归。

我的版本的堆栈极限是：13962。 到13963就该溢出了。当然速度必然胜过某个抄袭书本和我的源码的家伙。

@coordcn

一般的程序员都天然的认为内存很快，但是跟CPU的运算速度比起来，内存的访问速度太慢了。所有最终的优化都将集中在片上缓存的优化上

笑喷了，内存只是寄存和传输数据的，还跟cpu比运算速度。而且要跑到cpu的缓存上了？

1. 你知道cpu的缓存是干吗的吗？
2. 编程所使用的缓存就是内存的一块

@dayuoba

如果你不能适应函数式这种封装变量的方式，可以完全使用C风格编码：

var cache = [0, 1];

function fibonacci(n) {
    var result = cache[n];  // 先从缓存中取值
    if (typeof result !== 'number') {  // 是否是有效值？
        result =  fibonacci(n - 1) + fibonacci(n - 2);  // 不是，做一次fibonacci
        cache[n] = result;  // 把值加入缓存
    }
    return result;  // 返回计算结果
}

exports.fibonacci = fibonacci;

或者面向对象风格：

function Fibonacci() {
    if (!(this instanceof Fibonacci)) {
        return new Fibonacci();
    }
    this._cache = [0, 1];
}

Fibonacci.prototype.todo = function (n) {
    var result = this._cache[n];  
    if (typeof result !== 'number') {  
        result =  this.todo(n - 1) + this.todo(n - 2);  
        this._cache[n] = result;  
    }
    return result;  
};

Fibonacci().todo(6);

闭包是穷人的对象，对象是穷人的闭包

@LongHorn-C

逗比！！！叫爷爷！！！

function memorize(f) {
    var cache = {}; 
    return function(){
        var key = arguments.length + Array.prototype.join.call(arguments,',');      
        if (key in cache) {return cache[key];}
        else  return cache[key]=f.apply(this,arguments);
    }

}

fibonacci =memorize(function(n) {
    if (n === 0) {
         return 0;
        }
    if (n === 1) {
        return 1;
    }
        return fibonacci(n - 1) + fibonacci(n - 2);
});


var start = new Date();
fibonacci(1900);
fibonacci(1910);
fibonacci(1150);
fibonacci(1800);
fibonacci(999);
var end = new Date();
console.log('Time: %dms.', end.getTime() - start.getTime());

// Time: 5ms.

function fibonacci() {
    var cache = [0, 1];  // 0, 1的值是固定值
    return function walk(n) {
        var result = cache[n];  // 先从缓存中取值
        if (typeof result !== 'number') {  // 是否是有效值？
            result =  walk(n - 1) + walk(n - 2);  // 不是，做一次fibonacci
            cache[n] = result;  // 把值加入缓存
        }
        return result;  // 返回计算结果
    };
}

var start = new Date();
var f = fibonacci();
f(1900);
f(1910);
f(1150);
f(1800);
f(999);
var end = new Date();
console.log('Time: %dms.', end.getTime() - start.getTime());

// Time: 1ms.

function fibonacci(n) {
    if (n === 0) {
        return 0;
    }
    if (n === 1) {
        return 1;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

var start = new Date();
fibonacci(40);
var end = new Date();
console.log('Time: %dms.', end.getTime() - start.getTime());

// Time: 1687ms.

function fibonacci() {
    var cache = [0, 1];  
    return function walk(n) {
        var result = cache[n]; 
        if (typeof result !== 'number') {  
            result =  walk(n - 1) + walk(n - 2);  
            cache[n] = result; 
        }
        return result; 
    };
}

var start = new Date();
var f = fibonacci();
f(40);
var end = new Date();
console.log('Time: %dms.', end.getTime() - start.getTime());

// Time: 0ms.