函数式编程范式 ( 高阶函数，闭包，纯函数，函数的组合 )

文章说明：文章只是个人学习记录，以便于以后回看。

一：函数式编程

(1) 什么是函数式编程

函数式编程中的函数指的不是程序中的函数(方法)，而是数学中的函数即映射关系。
纯函数：相同的输入始终得到相同的输出。
函数式编程：用来描述数据(函数)之间的映射

我们常用的编程范式有：面向过程，面向对象，函数式编程：
例子：
(1) 面向过程：

	let num1=1;
    let num2=2;
    let sum=num1+num2

(2) 面向对象：

	class obj{
          fun(n1,n2){
             return n1 + n2
			}
	}
	var newObj = new obj()
	console.log(newObj.fun(1,2))

（3）函数式编程：(函数式编程就是把具体的运算过程抽象化成方法)

 	function fun(n1 , n2){
             return n1 + n2
	}
	let count = fun(1 , 2)
	console.log(count)

二：高阶函数

1.函数作为参数

 function foreach(arr,fn){
        for(let i=0;i<arr.length;i++){
          fn( arr[i] )
		}
 }
 var array = [1,2,4,5,6]
 foreach(array,function(item){
	console.log(item)
 })

2.函数作为返回值

 function mackFun(){
       let msg = 'hello world'
        return function(){
            console.log(msg)
       }
   }
   var fun = mackFun()    // fun指向，mackFun() 方法里的 return function 方法
   //运算：
   fun()  =  mackFun()()   //打印结果：hello world

  //只会执行一次
  function once(fn){
          let isOpen=true
          return function(){
             if(isOpen){
                 isOpen=false
                 return fn(...arguments)
            }
        }
   }
   let pay = once(function(money){
   		console.log(money)
    	console.log(`支付${money}元`)
   })
  pay([5,6,7])  //只会执行这一次
  pay(5)
  pay(5)

3.常用的高阶函数

   const arr = [1, 2, 3, 4] // map
   const map = (arr, fn) => {
      let result = []
      for( let item of arr ) {
         result.push( fn(item) )
     }
     return result
   }
   console.log(map(arr, val => val * val)) // [ 1, 4, 9, 16 ]

三：闭包

哈哈哈，闭包，永恒不变的面试必问，每次都回答的摩登两可的
外部参数在内部 return 方法中引用，捆绑在一起形成闭包。
本质官方解答：函数在执行的时候会放在栈上执行，当函数执行完毕了，就从栈中移除，但如果外部函数的参数在内部方法进行引用，则无法释放，因此形成了闭包。

 function mackPower(power){
          return function (x) {
             return power * x
          }
 }
 let power2 = mackPower(2)
 let power3 = mackPower(3)
 console.log( power2(2) )   // 4
 console.log( power3(3) )   // 9

四：纯函数

1. 相同的输入永远会得到相同的输出
2. 没有任何可观察的副作用
3. lodash 库是一个纯函数的功能库，提供了对数组，对象，字符串，函数等相关操作
4. 数组的slice纯函数，splice不纯的函数
   slice返回数组中的指定部分，不改变原数组
   splice对数组进行操作返回操作后的数组，改变原数组

	let arr = [1,2,3,4,5,7,6]
	//slice 纯函数
	console.log(arr.slice(0,3)) //结果：1,2,3
	console.log(arr.slice(0,3)) //结果：1,2,3
	console.log(arr.slice(0,3)) //结果：1,2,3
	// splice 不纯的函数 -> (相同的输入，却产生不同的输出结果)
	console.log(arr.splice(0,3)) //结果：1,2,3
	console.log(arr.splice(0,3)) //结果：4,5,7

5. 纯函数的好处：(没有任何可观察的副作用)
   **可缓存：**因为相同的输入始终是相同的结果，所以可以把纯函数的结果缓存起来
   **易测试：**纯函数运行和上下代码没有任何关系
   **并行处理：**在多线程操作共享的内存数据很容易出错，但是纯函数不需要访问共享的内存数据，所以在并行环境下可以任意运行纯函数

(1) lodash纯函数库

就是一个js工具库。提供了封装好的柯里化，组合函数等。用法查看官方文档即可，没啥可记的 https://www.lodashjs.com/
lodash 引入：

import _ from 'lodash'

五：函数的组合

如果一个函数要经过多个函数处理才能得到最终结果，这时候就可以把中间过程的函数组合成一个函数
**

函数组合默认从右到左执行

**

function reverse(arr){
    return arr.reverse()  //数组反转
}
function toUpperCase(arr){
    let text = arr[0]
    if(isNaN(text)){ //判断是否是数字
        return text.toLocaleUpperCase()  // 不是数字转成大写
    }else{
        return '这是个数字'
    }
}
function compare(f1,f2){
    return function(val){
        return f1(f2(val))
    }
}
let fn = compare(toUpperCase,reverse) //先执行reverse 数组反转，再执行toUpperCase
let arrs = [1,2,3,'tom']
let c = fn(arrs)
console.log(c) // 输出结果：TOM