抱歉之前的版本过于含糊。有人决定同情这位新手并帮助我重新修改问题——以下是我希望能够澄清问题的更新（感谢所有一直以来慷慨解囊的人）：
问题
我是一名计算机科学专业的新生，正在大学的第一年。在我们的算法课程中，我们可以选择任何语言，并实现一种“优化”算法，这种算法在其他语言中具有本地实现（内部实现？），但在我们选择的语言中缺失。
我们最近刚学习了递归，我的教授简要提到 JavaScript 没有实现尾调用优化。根据我在网上的研究，新的 ECMAScript 6 规范包括这个特性，但目前没有在任何/大多数 JavaScript 版本/引擎中实现（如果我不确定哪个是哪个...我是新手）。
我的任务是提供两个解决方法以弥补这种缺失。因此，我的问题是... 是否有比我更聪明、更有经验的人对如何实现以下内容有任何想法或示例：
如何解决尾递归优化不足的问题？
递归的一种优化方式是进行惰性求值，也就是返回一个“计算”（=函数），该函数将返回一个值，而不是立即计算并返回它。
考虑一个将数字相加的函数（以相当愚蠢的方式实现）：
function sum(n) {
return n == 0 ? 0 : n + sum(n - 1)
}
如果您使用n = 100000 调用它，它会超出堆栈（至少在我的Chrome中是这样）。要应用所述的优化，首先将其转换为真正的尾递归，使函数仅返回对自身的调用而不再有其他内容：
如果您使用n = 100000 调用它，它会超出堆栈（至少在我的Chrome中是这样）。要应用所述的优化，首先将其转换为真正的尾递归，使函数仅返回对自身的调用而不再有其他内容：
function sum(n, acc) {
return n == 0 ? acc : sum(n - 1, acc + n)
}
并将这个直接的自调用函数包装在一个“惰性”函数中：
function sum(n, acc) {
return n == 0 ? acc : function() { return sum(n - 1, acc + n) }
}
f = sum(100000, 0)
while(typeof f == "function")
f = f()
这个版本在 n = 100000、1000000 等情况下没有问题。
function foldl(f, a, xs) {
if (xs.length === 0) return a;
else return foldl(f, f(a, xs[0]), xs.slice(1));
}
很明显，这是一个尾递归函数。所以我们需要做的第一件事是将其转换为续传风格，这非常简单：
function foldl(f, a, xs, k) {
if (xs.length === 0) k(a);
else foldl(f, f(a, xs[0]), xs.slice(1), k);
}
就这样。我们的函数现在已经采用了连续传递风格。然而，仍然存在一个大问题——没有尾调用优化。不过，可以通过使用异步函数轻松解决这个问题：
function async(f, args) {
setTimeout(function () {
f.apply(null, args);
}, 0);
}
foldl函数现在可以写成：function foldl(f, a, xs, k) {
if (xs.length === 0) k(a);
else async(foldl, [f, f(a, xs[0]), xs.slice(1), k]);
}
foldl(function (a, b) {
return a + b;
}, 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function (sum) {
alert(sum); // 55
});
function async(f, args) {
setTimeout(function () {
f.apply(null, args);
}, 0);
}
function foldl(f, a, xs, k) {
if (xs.length === 0) k(a);
else async(foldl, [f, f(a, xs[0]), xs.slice(1), k]);
}
foldl(function (a, b) {
return a + b;
}, 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function (sum) {
alert(sum); // 55
});async = (f, args) ->
setTimeout ->
f.apply null, args
, 0
foldl = (f, a, xs, k) ->
if xs.length == 0 then k a
else async foldl, [f, (f a, xs.0), (xs.slice 1), k]
do
sum <- foldl (+), 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
alert sum
是的，这是一种编译成JavaScript的新语言，但它值得学习。特别是因为回调函数（即<-）使您可以轻松地编写不需要嵌套函数的回调。
int factorial(int x) {
return factTail(x,1);
}
int factTail(int x, int accum) {
if(x == 0) {
return accum;
} else {
return(factTail (x-1, x * accum);
}
}
...是一个对factorial()进行了定制的实现，以确保最后一条语句返回递归调用的结果。如果引擎了解尾递归优化（TCO），它将对此进行优化。
一个按照相同顺序执行操作的迭代版本：
int factorial(int x) {
int accum = 1;
for(int i=x; i>0; i--) {
accum *= i;
}
return accum;
}
我让它倒数以近似递归版本的执行顺序 -- 实际上，对于阶乘，你可能不会这样做。
如果您知道递归深度不会很大（在此示例中，x 的值很大），则可以使用递归调用。
通常，递归会导致解决方案非常优雅的规范。为了获得尾调用而摆弄算法会削弱这一点。请看上面的 factorial 比经典的难以理解的例子：
int factorial(int x) {
if(x == 1) {
return 1;
} else {
return factorial(x-1) * x;
}
}
...然而这种经典形式需要大量的堆栈空间，对于不需要堆栈的任务来说，这是不必要的。因此，可以认为迭代形式是解决这个特定问题最清晰的方法。
由于编程教学的方式，今天大多数程序员比起递归方法更喜欢迭代形式。你是否有特定困难的递归算法？
switch是其中之一；另一种是在设计模式中描述的面向对象方法。 - slim