// Internal function that returns an efficient (for current engines) version
  // of the passed-in callback, to be repeatedly applied in other Underscore
  // functions.
  // 内部优化方法，参数：函数，执行上下文，参数个数
  // 返回根据传入函数在不同执行上下文，不同参数个数的情况下执行的函数
  var optimizeCb = function(func, context, argCount) {
      // 如果没有指定执行上下文，返回该函数
      if (context === void 0) return func;
      switch (argCount) {
          case 1:
              return function(value) {
                  return func.call(context, value);
              };
              // The 2-parameter case has been omitted only because no current consumers made use of it.
              // 针对下面的null的问题，已经在github提交了pull request(https://github.com/jashkenas/underscore/pull/2732)，我认为应该是undefined而非null，具体在下面分析中会提到
          // case void 0:
          case null:
              // 在执行上下文中，没有参数个数，执行下面
              // 在undefined情况下_.each(), _.map()内部用到
          case 3:
              return function(value, index, collection) {
                  return func.call(context, value, index, collection);
              };
              // _.reduce(), _.reduceRight()
          case 4:
              return function(accumulator, value, index, collection) {
                  return func.call(context, accumulator, value, index, collection);
              };
      }
      // 其实不用上面的 switch-case 语句，直接执行下面的 return 函数就行了
      // 理由就是充分利用了call的参数格式化优化
      return function() {
          return func.apply(context, arguments);
      };
  };

  // _.each()方法在内部调用时首先进行的就是optimizeCb()方法的优化，把_.each()方法源码放到下面
  _.each([1, 2, 3], function(value, index){
    console.log(value, index); // 1, 2, 3
  }, this);
  // _.each()方法源码
  _.each = _.forEach = function(obj, iteratee, context) {
      // 执行函数分发优化策略，即前面的optimizeCb函数，赋值给局部变量iteratee进行代理执行
      iteratee = optimizeCb(iteratee, context);
      // 执行闭包iteratee方法
      var i, length;
      if (isArrayLike(obj)) {
          // 如果是类数组对象
          for (i = 0, length = obj.length; i < length; i++) {
              iteratee(obj[i], i, obj);
          }
      } else {
          // 普通对象
          var keys = _.keys(obj);
          for (i = 0, length = keys.length; i < length; i++) {
              iteratee(obj[keys[i]], keys[i], obj);
          }
      }
      // 返回该对象，链式操作使用
      return obj;
  };

  // iteratee(obj[i], i, obj);
  return function(value, index, collection) {
      // context == window，value是每个值，index是索引，collection是传入的数组本身，返回函数执行结果
      return func.call(context, value, index, collection);
  };