专注于WEB前端开发,HTML基础知识,CSS基础知识,HTML5和CSS3,Javascript,Jquery,Jquery插件,移动开发,微信开发等技术话题

当前位置:CSSTOP主页 > JS函数 > 正文

Javascript函数式编程的例子

函数式编程风格

通常来讲,函数式编程的谓词(关系运算符,如大于,小于,等于的判断等),以及运算(如加减乘数等)都会以函数的形式出现,比如:
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。