纯函数：
    对于相同的输入，永远会得到相同的输出，而且没有任何可观察的副作用，也不依赖外部环境的状态。

    1. var arr = [1,2,3,4,5];
    3. //纯函数arr.slice(0,3);   //=> [1,2,3]
    4. arr.slice(0,3);   //=> [1,2,3]
    6. //非纯函数
    7. arr.splice(0,3);  //=> [1,2,3]
    8. arr.splice(0,3);  //=> [4,5]

    定定义
    函数式编程为何排斥不纯的函数：
    非纯函数中，函数的行为需要由外部的系统环境决定。也就是说此函数行为不仅取决于输入的参数 age，还取决于一个外部的变量 timeOfLife。这种对于外部状态的依赖，是造成系统复杂性大大提高的主要原因。

    1. var timeOfLife = 20;
    3. //纯函数function test(age){
    4.   return age > 20;
    5. }
    7. //非纯函数
    8. function test(age){
    9.   return age > timeOfLife;
    10. }

    函数柯里化（Currying）
    向函数传递一部分参数来调用它，让它返回一个函数去处理剩下的参数。
    事实上柯里化是一种“预加载”函数的方法，通过传递较少的参数，得到一个已经记住了这些参数的新函数，某种意义上讲，这是一种对参数的“缓存”，是一种非常高效的编写函数的方法。

    1. var timeOfLife = 20;
    3. function test(timeOfLife){
    4.   return function(age){
    5.    return age > timeOfLife;
    6.  }
    7. }
    8. var testing = test(20);
    9. testing(18);   // => false

    函数组合
    为避免写出不优雅的包菜式代码 h ( g ( f ( x ) ) ) ？我们需要用到函数组合。
    我们定义的compose就像双面胶一样，可以把任何两个纯函数结合到一起，也可以扩展出组合N个函数的N面胶。
    这种灵活的组合，让我们可以像拼积木一样优雅地组合函数式代码。

    1. //两个函数的组合
    2. var compose = function(f, g){
    3.  return function(x){
    4.     return f(g(x));
    5.  };
    6. };
    7. var mult = function(x){
    8.  return x*5;
    9. }
    10. var add = function(x){
    11.  return x+1;
    12. }
    13. compose(mult, add)(2);   //=> 15

    命令式代码：
    通过编写一条又一条指令，让计算机执行一些动作，其中一般会涉及许多繁杂的细节。

    声明式代码：
    通过写表达式的方式，声明我们想干什么，而不是通过一步一步的指示。
    声明式代码，是函数式编程的一个明显好处——编写、优化代码时能更专注。

    1. //命令式
    2. var rest = [];
    3. var arr = [4,9,16,25,4,16];
    4. for(var i = 0; i < arr.length; i++){
    5.   if(rest.indexOf(arr[i]) === -1){
    6.      rest.push(arr[i]);
    7.   }
    8. }
    10. //声明式
    11. var rest = arr.map(Math.sqrt);

    函数式编程的一个明显的好处就是这种声明式的代码，对于无副作用的纯函数，我们完全可以不考虑函数内部是如何实现的，专注于编写业务代码。优化代码时，目光只需要集中在这些稳定坚固的函数内部即可。
    相反，不纯的不函数式的代码会产生副作用或者依赖外部系统环境，使用它们的时候总是要考虑这些副作用。

    总结：

    • 函数对于外部状态的依赖，是造成系统复杂性大大提高的主要原因。
    • 代码书写中让函数尽可能地纯净。
    • 函数式编程不是万能的，它与OOP 一样，只是一种编程范式。
    • 为降低软件复杂度，OOP 的方式是靠良好的封装、继承、多态以及接口定义。函数式编程则是靠纯函数以及它们的组合、柯里化等技术。

    underscore整体结构：
    通过对下面文章的学习可以对underscore有一个初步的学习和认识。
    https://www.html.cn/archives/4728

    • underscore结构

    • 面向对象风格支持

      1. 虽然underscore推崇函数式编程，但也支持面向对象风格的函数调用，仅需要通过_()来包裹对象。

    • mixin

      1. mixin（混入）模式也是增加代码复用度的一个广泛使用的设计模式。

    • 链接式调用

    1. var data = {
    2.             name: 'Max',
    3.             age: 21,
    4.             change: function(){
    6.             }
    7.         };
    9. // var d1 = _.unique([21, 12, 10, 21, 'a', 'A'], function(value) {
    10. //    return typeof value === 'string' ? value.toLowerCase() : value;
    11. // });
    12. // console.log(d1);
    14. var d2 = _([1,2,1,2,3,6,5,'A',6,'a']).chain().unique().map().value();
    15. console.log(d2);
    1. (function(root) {
    2.    var push = Array.prototype.push;
    4.    var _ = function(obj) {
    5.       if(obj instanceof _) {
    6.         return obj;
    7.       }
    9.       // 第一次调用时，this指向window，所以会执行new _(obj)
    10.       // 第二次调用时，this指向当前underscore对象，所以会跳过这一步执行
    11.       if(!(this instanceof _)) {
    12.         return new _(obj);
    13.       }
    15.       // 将对象引用封装在_wrapped属性中
    16.       this._wrapped = obj;
    17.    };
    19.    _.unique = function(arr, callback) {
    20.       var ret = [];
    21.       var i = 0, target;
    23.       for(; i < arr.length; i++) {
    24.         target = callback ? callback(arr[i]) : arr[i];
    25.         if(ret.indexOf(target) === -1) {
    26.             // push arr[i]比target 更好
    27.             ret.push(arr[i]);
    28.         }
    29.       }
    31.       return ret;
    32.    }
    34.    //开启链式调用
    35.    _.chain = function(obj){
    36.       var instance = _(obj);
    37.       instance._chain = true;
    39.       return instance;
    40.    };
    42.    //辅助函数
    43.    var result = function(instance, obj) {
    44.       return instance._chain ? _(obj).chain() : obj;
    45.    };
    47.    _.prototype.value = function() {
    48.       return this._wrapped;
    49.    }
    51.    _.functions = function (obj) {
    52.        var result = [];
    53.        var key;
    55.        for(key in obj) {
    56.          result.push(key);
    57.        }
    59.        return result;
    60.    };
    62.    _.map = function(args){
    63.      args.push('David');
    64.      return args;
    65.    };
    67.    //类型检测
    68.    _.isArray = function(obj){
    69.       return toString.call(obj) === '[object Array]';
    70.    };
    72.    _.each = function(target, callback){
    73.       var key,i=0;
    75.       if(_.isArray(target)) {
    76.          var length = target.length;
    77.          for(; i < length; i++) {
    78.             callback.call(target, target[i], i);
    79.          }
    80.       }
    81.       else {
    82.         for(key in target) {
    83.             callback.call(target, key, target[key]);
    84.         }
    85.       }
    86.    };
    88.    _.mixin = function(obj) {
    89.       _.each(_.functions(obj), function(name) {
    90.          var func = obj[name];
    92.          _.prototype[name] = function() {
    93.            var args = [this._wrapped];
    94.            push.apply(args, arguments);
    96.            return result(this, func.apply(this, args));
    97.          };
    98.       });
    99.    }
    101.    _.mixin(_);
    103.    root._ = _;
    104. })(this);

    undefined 的处理和 iteratee

    1. var obj = {name: 'Max', age: 21};
    3. console.log(_.map([1, 2, 3], function(value, index, object){
    4.   return value * 3;
    5. }, obj));
    1. //默认迭代器
    2.    _.identity = function(value) {
    3.       return value;
    4.    }
    6.   function cb(iteratee, context) {
    7.      if(!iteratee) {
    8.        return _.identity;
    9.      }
    11.      if(_.isFunction(iteratee)) {
    12.        console.log(2222);
    13.        return optimizeCb(iteratee, context);
    14.      }
    16.   }
    18.   //optimizeCb 优化迭代器
    19.   var optimizeCb = function(func, context, count) {
    20.      if(context == void 0) {
    21.        return func;
    22.      }
    24.      // count 为 undefined，则默认值为3
    25.      switch(count == null ? 3 : count) {
    26.         case 1:
    27.           return function(value) {
    28.              return func.call(context, value);
    29.           };
    30.         case 3:
    31.           return function(value, index, obj) {
    32.             return func.call(context, value, index, obj);
    33.           };
    34.      }
    35.   }
    37.    _.map = function(obj, iteratee, context){
    38.      //生成不同功能的迭代器
    39.      var iteratee = cb(iteratee, context);
    41.      // 区分数组和对象
    42.      var keys = !_.isArray(obj) && Object.keys(obj);
    43.      var length = (keys || obj).length;
    44.      var i = 0;
    46.      var result = Array(length);
    48.      for(i; i< length;i++) {
    49.        var currentKey = keys ? keys[i] : i;
    50.        result[i] = iteratee(obj[currentKey], i, obj);
    51.      }
    53.      return result;
    54.    };

    rest参数：

    1. function test(count1, count2, rest){
    2.            console.log(count1);
    3.            console.log(count2);
    4.            console.log(rest);
    5.         }
    7.         var myTest = _.restAuguments(test);
    9.         myTest(1, 2, 3, 4, 5, 6, 7);
    1. _.restAuguments = function(func) {
    2.       // rest参数位置
    3.       var startIndex = func.length - 1;
    5.       return function() {
    6.         var index = 0;
    7.         var length = arguments.length - startIndex;
    8.         var rest = Array(length);
    10.         for(; index < length; index++) {
    11.           rest[index] = arguments[index + startIndex];
    12.         }
    14.         var args = Array(func.length);
    15.         for(index=0; index < startIndex; index++) {
    16.           args[index] = arguments[index];
    17.         }
    19.         args[startIndex] = rest;
    21.         return func.apply(this, args);
    22.       };
    23.    }

    Object.create **polyfill：**

    polyfill（聚酯填充物），这里可以理解为Object.create 的补丁

    1. // Object.create polyfill
    2.    var baseCreate = function(prototype){
    3.       if(!_.isObject(prototype)) return {};
    5.       if(Object.create) {
    6.          return Object.create(prototype);
    7.       }
    9.       Ctor.prototype = prototype;
    10.       var res = new Ctor;
    11.       Ctor.prototype = null;
    13.       return res;
    14.    };

    reduce和真值检测函数：

    1. // reduce
    2.    var createReduce = function(dir){
    3.       var reduce = function(obj, iteratee, memo, init) {
    4.         // 判断obj为数组或对象
    5.          var keys = !_.isArray(obj) && Object.keys(obj);
    6.          var length = (keys || obj).length;
    7.          var index = dir > 0 ? 0 : length-1;
    9.         // 如果没传memo的默认值，则从第一个元素开始
    10.         if(!init) {
    11.            memo = obj[keys ? keys[index] : index];
    12.            index += dir;
    13.         }
    15.         // dir为1，表示从头到尾；尾-1则表示从尾到头
    16.         for(; index >= 0 && index < length; index += dir) {
    17.           var currentKey = keys ? keys[index] : index;
    18.           memo = iteratee(memo, obj[currentKey], currentKey, obj);
    19.         }
    21.         return memo;
    23.       };
    25.       //返回函数
    26.       return function(obj, iteratee, memo, context) {
    27.         var init = arguments.length >= 3;
    28.         return reduce(obj, optimizeCb(iteratee, context, 4), memo, init);
    29.       };
    30.    };
    32.    _.reduce = createReduce(1);  // 1 or -1，1表示从头开始，-1表示从尾开始
    34.    _.filter = _.select = function(obj, predict, context){
    35.       var results = [];
    36.       predict = cb(predict, context);
    37.       _.each(obj, function(value, index){
    38.         if(predict(value, index)) {
    39.           results.push(value);
    40.         }
    41.       });
    43.       return results;
    44.    };

    index和lastIndexOf:

    1. _.sortedIndex = function(array, obj, iteratee, context) {
    2.     // 如果iteratee是null， 则cb返回 function(value){ return value;}
    3.     iteratee = cb(iteratee, context, 1);
    4.     value = iteratee(obj);
    6.     var low = 0;
    7.     var high = array.length-1;   // 长度减一
    9.     while(low < high) {
    10.         var mid = Math.floor((low+high)/2);
    12.         if(array[mid] < value) {
    13.           low = mid + 1;
    14.         }
    15.         else {
    16.           high = mid;
    17.         }
    18.     }
    20.     // 返回low或high都可
    21.     return low;
    22.   }
    24.   // 1：正向查找，-1：反向查找
    25.   function createPredicateIndexFinder(dir) {
    26.      return function(array, predicate, context) {
    27.        predicate = cb(predicate, context);
    28.        var length = array.length;
    30.        var index = dir > 0 ? 0 : length-1;
    31.        for(; index>=0 && index < length; index+=dir) {
    32.           if(predicate(array[index], index, array)) {
    33.             return index;
    34.           }
    35.        }
    37.        return -1;
    38.      };
    39.   }
    41.    // 1为正向查找，-1为反向查找
    42.    _.findIndex = createPredicateIndexFinder(1);
    43.    _.findLastIndex = createPredicateIndexFinder(-1);
    45.   function createIndexFinder(dir, predicateFind, sortedIndex) {
    46.     // 调用形式：array, item, idx，idx表示是否已经为有序
    47.     return function(array, item, idx){
    48.        var i = 0;
    49.        var length = array.length;
    51.        //如果已经为正序，则调用折半查找
    52.        if(idx && _.isBoolean(idx) && length) {
    53.          idx = sortedIndex(array, item);
    54.          return array[idx] === item ? idx : -1;
    55.        }
    57.        // 特殊情况，要查找的元素是NaN
    58.        if(item !== item) {
    59.           idx = predicateFind(slice.call(array, 0, length), _.isNaN);
    60.           return idx >=0 ? idx : -1;
    61.        }
    63.        //正常遍历
    64.        for(idx = (dir > 0 ? i : length-1); idx >= 0 && idx < length; idx +=dir) {
    65.          if(array[idx] === item) {
    66.             return idx;
    67.          }
    68.        }
    70.        return -1;
    71.     };
    72.   }
    74.   _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
    75.   _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);

    洗牌算法：

    1. console.log(_.sample([1,2,3,4,5,6,7,8,9,10],5));
    2. console.log(_.shuffle([1,2,3,4,5,6,7,8,9,10]));
    1. _.clone = function(obj) {
    2.     return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    3.   };
    5.   //随机数函数
    6.   _.random = function(min, max) {
    7.     // 如果最大值不传，则取0到最小值之间的数
    8.      if(max == null) {
    9.       max = min;
    10.       min = 0;
    11.      }
    13.      // Math.random()为取0到1之间的随机数，可以等于0，但是一定小于1
    14.      // 返回的随机数可能等于最大值或最小值
    15.      return min + Math.floor((Math.random() * (max - min + 1)));
    16.   };
    18.   _.shuffle = function(array) {
    19.      return _.sample(array, Infinity);
    20.   };
    22.   _.sample = function(array, n) {
    23.      // 判断是否是Array
    24.      if(!_.isArray(array)) {
    25.         return array;
    26.      }
    27.      //判断n的合法性
    28.      if(n == null) {
    29.        return  array[_.random(array.length-1)];
    30.      }
    32.      var length = array.length;
    33.      var tempArray = _.clone(array);
    34.      var last = array.length -1;
    35.      // 获取n和length的最小值，为什么不这样：n = n>length ? length : n;
    36.      n = Math.max(Math.min(n, length),0);
    37.      for(var index = 0; index < n; index++) {
    38.         var ran = _.random(index, last);
    39.         var temp = tempArray[index];
    40.         tempArray[index] = tempArray[ran];
    41.         tempArray[ran] = temp;
    42.      }
    44.      return tempArray.slice(0, n);
    45.   };

    非纯函数中，函
    数的行为需要由外部的系统环境决定。也就是说此函数行为不仅取决于输入的参
    数 age，还取决于一个外部的变量 timeOfLife。
    ：：
    对于相同的输入，永远会得到相同的输出，而且没有任何可观察的副作用，也不依赖外部环境的状态。
    义：
    对于相同的输入，永远会得到相同的输出，而且没有任何可观察的副作用，也不依赖外部环境的状态。