一、js编程特点：
    （1）函数式编程 + 面向对象编程的混编语言
    （2）可扩展性强 ：参数个数不限，参数数据类型不限（js是松散型语言，声明变量时，不用声明数据类型）
    有点： 灵活，易学
    缺点： 不可控

    二、函数式编程与面向对象编程
    函数式编程很常用到，面向对象不一定。前端工程师更倾向函数式编程。
    面向对象所面临的技术： this指向 => call apply bind，this太多会变得混乱。但是也不能解决所有问题，需要用到函数式编程。

    1. // html 
    2. // <div class='button'><div>    
    3. // <p class='p' >123<p>
    4. // script
    5. function Test(){
    6.     this.button = document.getElementByClassName('button')[0];
    7.   this.p = document.getElementByClassName('p')[0];
    8.   this.content = 678;
    9. }
    10. Test.prototype.init = function(){
    11.     this.bindEvent()
    12. }
    13. Test.prototype.bindEvent = function (){
    14.     this.button.addEventListener('click',this.emitEvent.bind(this),false)
    15. }
    16. Test.prototype.emitEvent = function (){
    17.     let text = this.content,
    18.       pInnerHtml = this.p.innerHtml;
    19.   this.pInnerHtml = this.text
    20.   console.log(this) //=> 事件触发dom节点
    21. }
    22. new Test().init()

    什么场景使用面向对象合适呢 : 高度复用，多个地方都会用到新实例的时候。没有高度复用的话，就错失了面向对象的精髓。

    三、函数式编程
    特点：易读、易维护。
    理念：函数式编程中，函数是第一类对象，不依赖其他对象独立存在。

    （1）纯函数：输入有着对应着的输出，不依赖不影响外部环境（不产生副作用）。

    1. let a = 1;
    2. function test(){
    3.     console.log(a)
    4. }
    5. test()
    6. // 上面函数依赖着外部变量
    8. let a = 1;
    9. function test(num){
    10.     console.log(num + 123)
    11. }
    12. test(a)
    13. //输出对应着输入，对外界没有依赖
    1. （2）函数副作用： 可能产生问题的行为<br />数据请求、dom操作、外部数据改变、操作数据存储、console.log（依赖外部函数）<br />splice和slice<br />splice改变原数组，返回删除的元素。不是纯函数，js自身就提供了非纯函数，所以js编程中没有一定要使用纯函数。<br />slice截取范围内元素，返回新数组，不改变原函数。纯函数
    1. function compute(a,b,foo){
    2.   let typeValid = (typeof a) === 'number' && (typeof b) === 'number';
    3.     if( typeValid ){
    4.     return foo(a,b)
    5.   }else{
    6.       console.log('a和b需要都为数字')
    7.   }
    8. }
    9. //这种函数不需要依赖外部变量，所以可移植
    10. function add (a,b){
    11.     return a + b
    12. }
    13. compute(1,6,add)

    纯函数好处：
    （1）可移植，内部对外界的依赖，所以放到哪里都可以执行。
    （2）易读，没有对外界的依赖，所以透明易读。
    （3）可缓存
    实际开发中，没有必要一定用纯函数，可提纯就提纯。

    缓存池

    1. function test(fn){
    2.     let cache = {};
    3.   return function(){
    4.     //普通对象中，不能用引用类型作为箭名。es6中的map可以
    5.       let arg = JSON.stringify(arguments),
    6.             result = cache[arg] ? ( cache[arg] + '来自缓存池' ) : fn(arguments);
    7.     if(!cache[arg]){
    8.         cache[arg] = result
    9.     }
    10.     return result
    11.   }
    12. }
    13. function computation (arguments){
    14.   //这里的形参arguments，是从其他地方传过来的arguments对象
    15.   console.log(arguments)
    16.     let sum = [...arguments].reduce((accumulator,elem)=>{
    17.       return accumulator + elem
    18.   },0)
    19.   return sum
    20. }
    21. var computor = test(computation)
    22. console.log(computor(1,2,3,4,5,6))
    23. console.log(computor(1,2,3,4,5,6))

    函数式编程核心：
    函数提纯：拆分抽象，功能单一，不要太臃肿，参数多了可以传配置项。目的就是，易读，易维护（有修改，直接找到对应函数就可以完成修改）。

    书籍知识点补充：
    晌应式编程,这种编程范式有助于数据流的处理和变化的传递。
    设计程序时，我们应该思考：
    （1）可扩展性 一一 拓展功能的时候，是否需要重构代码？
    （2）模块化 一一 修改一个文件，是否会影响到其他文件？
    （3）可用性 一一 是否有重复代码？
    （4）易测性 一一 能否执行单元测试？
    （5）易读性 一一 阅读起来是否难以理解？