JavaScript系列：函数式编程（开篇）

前言：

上一篇介绍了 函数回调，高阶函数以及函数柯里化等高级函数应用，同时，因为正在学习JavaScript·函数式编程，想整理一下函数式编程中，对于我们日常比较有用的部分。

为什么函数式编程很重要？

      学习过C++，java这些面向对象编程语言，我们大概都知道面向对象编程就是把目标问题分成几个部分，实现各部分的功能，再组合成一个更强大的对象。虽说JavaScript不是面向对象编程语言(虽然ES6已经出现了Class类这种对象，在此暂且不说)，但它却是一种完完全全支持函数式编程的语言，利用函数式编程，我们也可以将问题分解成几个部分(函数)来解决。函数式编程也通过组合其他函数构造更加强大的函数，以实现更抽象的行为。

 

1. 以函数为抽象单元

• 比如，我们想自定义打印错误，我们可以将错误，警告等等概念抽象为一个函数

   function fail(err){
   throw new Error(err);
   }
   function warn(err){
   console.log("Warning thing:%s",err);
   }   

封装和隐藏

• Javascript中没有提供直接隐藏数据的方式（也就是没有私有变量），但是可以使用闭包来实现隐藏数据（实现私有变量的定义)

   var Person=function(){
   // 定义私有变量
   var school="SCUT";
   // 定义公共接口方法
   return {
   name:'',
   setName:function(name){
   this.name=name;
   },
   getName:function(){
   return this.name;
   },
   getSchool:function(){
   return school;
   }
   }
   }
   var person1=new Person()
   // => undefined
   person1.school
   // => undefined
   person1.getSchool()
   // => "SCUT"

   var Person=function(){
   this.name='';
     this.school="SCUT";
   this.setName=function(name){
   this.name=name;
   };
   this.getName=function(){
   return this.name;
   };
   this.getSchool=function(){
   return this.school;
   }
   }
   var person1=new Person()
   person1.getSchool()
   //=> "SCUT"
   person1.school
   //=> "SCUT"
   person1.school='JYYz'
   person1.getSchool()
   //=> "JYYz"

  由第一个例子我们可以看到 school 相当于私有变量，无法通过实例访问

   person1.school
   // => undefined

  而第二个例子可以访问，并且可以进行修改。

以函数为行为单位

• 提供一种简单的存储和传递行为的离散单元
• 举一个简单的例子：数组索引行为，称之为nth，简单如下

   nativeNth('hello',2)
   //=> "l"
   nativeNth({},2)
   //=> undefined
   可以看到，当传入不正确的值时候，会发生错误；对之进行修改如下：
   function nativeNth(a,index){
   if(!Number.isInteger(index)) fail("Expected a number as the index");
   if(!Array.isArray(a) && typeof a !=='string')
   fail("Non supported on non-indexed type");
   if((index<0)||(index>a.length-1))
   fail("index value is out of bounds");
   return a[index];
   }

  

   这样子我们构建了nth函数的抽象方式

   

  总结：概括的说，函数式编程包括以下几点：

  确定抽象，并为其构建函数

  利用已有的函数来构建更为复杂的抽象

  通过已有的函数传给其他的函数来构建更加复杂的抽象

   

  通过函数，我们可以把各部分功能封装在各个抽象里面，提供一个接口，实现逻辑的独立性。