JavaScript函数式写法消灭顺序，分支，循环语句

顺序语句1:

var a=1;

var b=2;

var c=2;

顺序语句消灭1：

var a=1, b=c=2;

 

顺序语句2：

var a= -1.11;

a=Math.abs(a);

a=Math.round(a);

顺序语句消灭2：

a.wsc(Math.abs).wsc(Math.round);

 

分支语句1：

if(a==1){b=2;}

分支语句消灭1：

(a==1) && b=2;

抑或

(a==1) ? b=2 :null;//其实if语句的大括号里面，可以throw，可以return，可以多条语句。但三目运算?:不能，可以通过封装个function，然后调用即可。因为函数是对多个表达式运算的封装。表达式运算是求值运算。

 

分支语句2:

if(a != undefined){

c = a;

}

else if(a == undefined && b !== undefined){

c = b;

}

消灭分支语句2：

var c = a || b;

 

循环语句1：

for(var i=0;i<10;i++){

alert(i);

}

循环语句消灭1：

void function(i){

var tempArg = arguments;

function temp(){

alert(i);tempArg.callee(++i);

}

(i<10) ? temp() : null;

}(0);

//注意点1，this和arguments都是跟function环境有关，不同function环境，this和arguments的值不同。

//注意点2，普通递归由于把处理结果放在堆栈里，天生的强生的，比处理结果放在固定变量里的for循环慢。但是，用尾递归，把处理结果直接传到下个函数的参数列表里，可以提高递归速度。

//举个例子，for循环，普通递归，尾递归的例子

function fibonacci1(n) { //尾递归，把执行结果传递到下一次执行的函数
    return (function(n1, n2, i) { 
        return ( i < n ) ? arguments.callee(n2, n1+n2, i+1) : n1;
    })(1,1,1);
}
    
function fibonacci2(n) { //普通for循环
    var n1 = n2 = s = i = 1;
    for(; i<n; i++){
        s = n1 + n2;
        n1 = n2;
        n2 = s;
    }
    return n1;
}

function fibonacci3(n) { //普通递归，把执行结果存储到堆栈
    return (function(n) { 
        if (n == 1 || n == 2) 
            return 1;
        return arguments.callee(n - 1) + arguments.callee(n - 2);
    })(n);
}

 

函数式语言的函数，有三特性。

1.函数是运算元，只能被调用。可以往函数的参数列表里面传入函数，当然传入不了地址。

2.在函数内保存数据。通过闭包啦。

var set, get;
function MyFunc() {
// 初值
var value = 100;
// 内部的函数, 用于该问 MyValue
function set_value(v) {
value = v;
}
function get_value() {
return value;
}
// 将内部函数公布到全局
set = set_value;
get = get_value;
}
// 测试一
// 显示输出值: 100
MyFunc();
alert( get() );
// 测试二
// 显示输出值: 300
set(300);
alert( get() );

因为闭包，所以同个函数的不同实例有各自的闭包，各自里面的数据不打扰。

function MyObject() {
var value = 100;
this.setValue = function(v) {
value = v;
}
this.showValue = function() {
alert(value);
}
}
var
obj1 = new MyObject();
obj2 = new MyObject();
// 测试: obj2 的置值不会影响到 obj1
// 显示结果值: 100;
obj2.setValue(300);
obj1.showValue();

3.函数内的运算对函数外无副作用。

函数使用入口参数进行运算，而不修改它(也就是作为值参数)

在运算过程中不会修改函数外部的其他数据的值，比如全局变量。

运算结束后通过函数向外部系统传值。

但是，JavaScript天生能修改全局变量，还能声明全局变量呢。所以要靠我们的习惯来保证。面向对象的世界里，通过读写器访问对象属性，通过接口向外暴露对象方法，套用在函数外无副作用，就很好。

综上所述，当函数只存在值含义，并且没有副作用，函数才能作为表达式运算的运算元才与运算。//可能递归函数，作为for循环，是个例外。给一个确定的唯一外部变量，递归函数只修改它。