<script>/*函数式编程*/function f1(){var n=999;nAdd=function(){n+=1;};var f2 = function(){console.log(n);};return f2;}var result=f1();result(); // 999
　　nAdd();result(); // 1000/*面向对象编程1之json写法*/var obj1 = {n:999,nAdd:function(){this.n += 1;},getN:function(){console.log(this.n);}};obj1.getN();//999
    obj1.nAdd();obj1.getN();//1000/*面向对象编程2之工厂模式*/var obj2 = function(){var obj = new Object;obj.n = 999;obj.nAdd = function(){this.n += 1;};obj.getN = function(){console.log(this.n);}return obj;};var objins = new obj2();objins.getN();//999
    objins.nAdd();objins.getN();//1000/*面向对象编程3之原型prototype*/function obj3(n) {this.n = n;}obj3.prototype.nAdd = function() {this.n+=1;};obj3.prototype.getN = function() {console.log(this.n);}var objins2 = new obj3(999);objins2.getN();//999
    objins2.nAdd();objins2.getN();//1000
</script>

var xs = [1,2,3,4,5];
// 纯的
xs.slice(0,3);
//=> [1,2,3]
xs.slice(0,3);
//=> [1,2,3]
xs.slice(0,3);
//=> [1,2,3]// 不纯的
xs.splice(0,3);
//=> [1,2,3]
xs.splice(0,3);
//=> [4,5]
xs.splice(0,3);
//=> []

                /*一般写法：两数相加*/var add = function(x,y){return x + y;}/*2+1和2+10*/add(2,1);//3add(2,10);//12/*柯里化写法*///es5var add = function(x) {return function(y) {return x + y;};};//es6var add = x => (y => x + y);//定义+1和+10函数var increment = add(1);//柯里化后得到的+1函数var addTen = add(10);//柯里化后得到的+10函数increment(2);  // 3addTen(2);  // 12

var arr = [1,2,3,4,5];/*ES6写法*/var reducer = (prevalue,curvalue)=>prevalue + curvalue;console.log(arr.reduce(reducer));//15/*ES5写法*/var reducer = function(prevalue,curvalue){return prevalue + curvalue;};console.log(arr.reduce(reducer));//15/*解析*/数组的reduce方法有两个参数：callback，prevalue；对于第一个参数callback，里面有4个参数prevalue、curvalue、index、array；index是当前迭代时的curvalue的索引（数组中的索引），array当然是操作的数组了；着重看另外两个参数，prevalue和curvalue（上一个值和当前值）；如果reduce方法没有第二个参数的话，那么callback回调将数组第一个值作为prevalue，第二个值作为curvalue；如果reduce方法有第二个参数，那么将第二个参数值作为prevalue，将数组第一个值作为curvalue；每一次的操作结果将变为下一次操作的prevalue，而curvalue的值教上一次往后推一位；/*实例解析*/针对上述数组相加；没有第二个参数，只有一个回调callback，那么他的过程是这样的；第一次运算：prevalue为1，curvalue为2，运算结果为1+2=3，并将结果作为下次运算的prevalue；第二次运算：prevalue为3（上一次运算的结果），curvalue为3,运算结果为3+3=4，以此类推；如果有第二个参数，假设为5，arr.reduce(reducer，5)，那么将是这么计算的；第一次运算：prevalue为5（第二个参数），curvalue为1，运算结果为5+1=6，并将结果作为下次运算的prevalue；第二次运算：prevalue为6（上一次运算的结果），curvalue为2,运算结果为6+2=8，以此类推；reduceRight和reduce类似，只不过他是从右边开始迭代的。

        var compose = (...args) => x => args.reduceRight((prevalue, curvalue) => curvalue(prevalue), x);var toUpperCase = x => x.toUpperCase();var exclaim = x => x + '!';var shout = compose(exclaim, toUpperCase);console.log(shout("my name is echo"));

        var compose = function (...args){return function (x){return args.reduceRight(function(prevalue, curvalue){return curvalue(prevalue);},x)}};var toUpperCase = function(x){return x.toUpperCase();};var exclaim = function(x){return x + '!';};var shout = compose(exclaim, toUpperCase);console.log(shout("my name is echo"));

        var shout == compose(exclaim, toUpperCase)== function (x) {return [exclaim, toUpperCase].reduceRight(function(prevalue, curvalue){return curvalue(prevalue);},x)};shout("my name is echo") == [exclaim, toUpperCase].reduceRight(function(prevalue, curvalue){return curvalue(prevalue);},"my name is echo");/*前面说过，如果reduce/reduceRight传了第二个参数，那么该第二个参数将作为prevalue给callback调用。*//*运算过程如下（reduceRight从右往左）curvalue(prevalue)：*/1.toUpperCase("my name is echo");并将结果作为prevalue供下次调用；2.exclaim(toUpperCase("my name is echo"));如此实现了先转大写再加感叹号。