函数式编程风格
通常来讲，函数式编程的谓词(关系运算符，如大于，小于，等于的判断等)，以及运算(如加减乘数等)都会以函数的形式出现，比如：
a > b
通常表示为：
gt(a, b)//great than
因此，可以首先对这些常见的操作进行一些包装，以便于我们的代码更具有“函数式”风格：
function abs(x){ return x>0?x:-x;}
function add(a, b){ return a+b; }
function sub(a, b){ return a-b; }
function mul(a, b){ return a*b; }
function div(a, b){ return a/b; }
function rem(a, b){ return a%b; }
function inc(x){ return x + 1; }
function dec(x){ return x - 1; }
function equal(a, b){ return a==b; }
function great(a, b){ return a>b; }
function less(a, b){ return a<b; }
function negative(x){ return x<0; }
function positive(x){ return x>0; }
function sin(x){ return Math.sin(x); }
function cos(x){ return Math.cos(x); }
如果我们之前的编码风格是这样：
// n*(n-1)*(n-2)*...*3*2*1
function factorial(n){
if(n == 1){
return 1;
}else{
return n * factorial(n - 1);
}
}
在函数式风格下，就应该是这样了：
function factorial(n){
if(equal(n, 1)){
return 1;
}else{
return mul(n, factorial(dec(n)));
}
}
函数式编程的特点当然不在于编码风格的转变，而是由更深层次的意义。比如，下面是另外一个版本的阶乘实现：
/*
* product <- counter * product
* counter <- counter + 1
* */
function factorial(n){
function fact_iter(product, counter, max){
if(great(counter, max)){
return product;
}else{
fact_iter(mul(counter, product), inc(counter), max);
}
}
return fact_iter(1, 1, n);
}
虽然代码中已经没有诸如+/-/*//之类的操作符，也没有>,<,==,之类的谓词，但是，这个函数仍然算不上具有函数式编程风格，我们可以改进一下：
function factorial(n){
return (function factiter(product, counter, max){
if(great(counter, max)){
return product;
}else{
return factiter(mul(counter, product), inc(counter), max);
}
})(1, 1, n);
}
factorial(10);
通过一个立即运行的函数 factiter，将外部的 n 传递进去，并立即参与计算，最终返回运算结果。
Y-结合子
提到递归，函数式语言中还有一个很有意思的主题，即：如果一个函数是匿名函数，能不能进行递归操作呢？如何可以，怎么做？我们还是来看阶乘的例子：
function factorial(x){
return x == 0 ? 1 : x * factorial(x-1);
}
factorial 函数中，如果 x 值为 0，则返回 1，否则递归调用 factorial，参数为 x 减 1，最后当 x 等于 0 时进行规约，最终得到函数值(事实上，命令式程序语言中的递归的概念最早即来源于函数式编程中)。现在考虑：将 factorial 定义为一个匿名函数，那么在函数内部，在代码 x*factorial(x-1)的地方，这个 factorial 用什么来替代呢？
lambda 演算的先驱们，天才的发明了一个神奇的函数，成为 Y-结合子。使用 Y-结合子，可以做到对匿名函数使用递归。关于 Y-结合子的发现及推导过程的讨论已经超出了本部分的范围，有兴趣的读者可以参考附录中的资料。我们来看看这个神奇的 Y-结合子：
var Y = function(f) {
return (function(g) {
return g(g);
})(function(h) {
return function() {
return f(h(h)).apply(null, arguments);
};
});
};
我们来看看如何运用 Y-结合子，依旧是阶乘这个例子：
var factorial = Y(function(func){
return function(x){
return x == 0 ? 1 : x * func(x-1);
}
});
factorial(10);
或者：
Y(function(func){
return function(x){
return x == 0 ? 1 : x * func(x-1);
}
})(10);
不要被上边提到的 Y-结合子的表达式吓到，事实上，在 JavaScript 中，我们有一种简单的方法来实现 Y-结合子：
var fact = function(x){
return x == 0 : 1 : x * arguments.callee(x-1);
}
fact(10);
或者：
(function(x){
return x == 0 ? 1 : x * arguments.callee(x-1);
})(10);//3628800
其中，arguments.callee 表示函数的调用者，因此省去了很多复杂的步骤。
其他实例
下面的代码则颇有些“开发智力”之功效：
//函数的不动点
function fixedPoint(fx, first){
var tolerance = 0.00001;
function closeEnough(x, y){return less( abs( sub(x, y) ), tolerance)};
function Try(guess){//try 是javascript中的关键字，因此这个函数名为大写
var next = fx(guess);
//print(next+" "+guess);
if(closeEnough(guess, next)){
return next;
}else{
return Try(next);
}
};
return Try(first);
}
// 数层嵌套函数，
function sqrt(x){
return fixedPoint(
function(y){
return function(a, b){ return div(add(a, b),2);}(y, div(x, y));
},
1.0);
}
print(sqrt(100));
fiexedPoint 求函数的不动点，而 sqrt 计算数值的平方根。这些例子来源于《计算机程序的构造和解释》，其中列举了大量的计算实例，不过该书使用的是 scheme 语言，在本书中，例子均被翻译为 JavaScript。