lodash源码学习(4)

继续学习lodash，依然是数组的方法

“Array” Methods

_.take(array, [n=1])

 创建一个数组片段包含从数组开始获取的n个元素.

//take.js

var baseSlice = require('./_baseSlice'),//同Array.slice（见源码学习（3））
    toInteger = require('./toInteger');//转化为整型

/**
 *
 * @param {Array} array 需要查询的数组.
 * @param {number} [n=1] 需要获取的数量.
 * @param- {Object} [guard] 能够作为遍历器被像_.map这样的方法调用.
 * @returns {Array} 返回切好的数组.
 * @example
 *
 * _.take([1, 2, 3]);
 * // => [1]
 *
 * _.take([1, 2, 3], 2);
 * // => [1, 2]
 *
 * _.take([1, 2, 3], 5);
 * // => [1, 2, 3]
 *
 * _.take([1, 2, 3], 0);
 * // => []
 */
function take(array, n, guard) {
  if (!(array && array.length)) {//如果没有array,或者为空数组，返回空数组
    return [];
  }
  n = (guard || n === undefined) ? 1 : toInteger(n);//n默认为1
  return baseSlice(array, 0, n < 0 ? 0 : n);//调用baseSlice方法并将结果作为返回值返回
}

module.exports = take;

_.takeRight(array, [n=1])

创建一个数组片段包含从数组末尾获取的n个元素..

//takeRight.js

var baseSlice = require('./_baseSlice'),//同Array.slice
    toInteger = require('./toInteger');//转化为整型

/**
 *
 * @param {Array} array 需要查询的数组.
 * @param {number} [n=1] 需要获取的元素数量.
 * @param- {Object} [guard] 能够作为遍历器被像_.map这样的方法调用.
 * @returns {Array} 返回切好的数组片段.
 * @example
 *
 * _.takeRight([1, 2, 3]);
 * // => [3]
 *
 * _.takeRight([1, 2, 3], 2);
 * // => [2, 3]
 *
 * _.takeRight([1, 2, 3], 5);
 * // => [1, 2, 3]
 *
 * _.takeRight([1, 2, 3], 0);
 * // => []
 */
function takeRight(array, n, guard) {
  var length = array == null ? 0 : array.length;
  if (!length) {//如果没有array,或者为空数组，返回空数组
    return [];
  }
  n = (guard || n === undefined) ? 1 : toInteger(n);//n默认为1
  n = length - n;//从末尾开始算
  return baseSlice(array, n < 0 ? 0 : n, length);//调用baseSlice方法并将结果作为返回值返回
}

module.exports = takeRight;

_.takeRightWhile(array, [predicate=_.identity])

 创建一个数组，包含从数组的末尾开始获取元素，直到判断结果为false为止的元素.判断条件接收三个参数（value, index, array）

//takeRightWhile.js

var baseIteratee = require('./_baseIteratee'),//遍历器封装
    baseWhile = require('./_baseWhile');//从第一个不满足predicate 条件的元素开始截取数组（见源码学习（1））

/**
 *
 * @param {Array} array 需要查询的数组.
 * @param {Function} [predicate=_.identity] 判断条件.
 * @returns {Array} 返回切好的数组片段.
 * @example
 *
 * var users = [
 *   { 'user': 'barney',  'active': true },
 *   { 'user': 'fred',    'active': false },
 *   { 'user': 'pebbles', 'active': false }
 * ];
 *
 * _.takeRightWhile(users, function(o) { return !o.active; });
 * // => objects for ['fred', 'pebbles']
 *
 * // The `_.matches` iteratee shorthand.
 * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
 * // => objects for ['pebbles']
 *
 * // The `_.matchesProperty` iteratee shorthand.
 * _.takeRightWhile(users, ['active', false]);
 * // => objects for ['fred', 'pebbles']
 *
 * // The `_.property` iteratee shorthand.
 * _.takeRightWhile(users, 'active');
 * // => []
 */
function takeRightWhile(array, predicate) {//如果没有array或者为空数组，返回空数组，否则调用baseWhile方法，并将判断条件封装，使之支持简写,传入第四个参数为true,从右边开始。
  return (array && array.length)
    ? baseWhile(array, baseIteratee(predicate, 3), false, true)
    : [];
}

module.exports = takeRightWhile;

_.takeWhile(array, [predicate=_.identity])

创建一个数组，包含从数组的开始开始获取元素，直到判断结果为false为止的元素.判断条件接收三个参数（value, index, array）

//takeWhile.js

var baseIteratee = require('./_baseIteratee'),//遍历器封装
    baseWhile = require('./_baseWhile');//从第一个不满足predicate 条件的元素开始截取数组（见源码学习（1））

/**
 *
 * @param {Array} array 需要查询的数组.
 * @param {Function} [predicate=_.identity] 判断条件.
 * @returns {Array} 返回切好的数组片段.
 * @example
 *
 * var users = [
 *   { 'user': 'barney',  'active': false },
 *   { 'user': 'fred',    'active': false },
 *   { 'user': 'pebbles', 'active': true }
 * ];
 *
 * _.takeWhile(users, function(o) { return !o.active; });
 * // => objects for ['barney', 'fred']
 *
 * // The `_.matches` iteratee shorthand.
 * _.takeWhile(users, { 'user': 'barney', 'active': false });
 * // => objects for ['barney']
 *
 * // The `_.matchesProperty` iteratee shorthand.
 * _.takeWhile(users, ['active', false]);
 * // => objects for ['barney', 'fred']
 *
 * // The `_.property` iteratee shorthand.
 * _.takeWhile(users, 'active');
 * // => []
 */
function takeWhile(array, predicate) {//但是，但是没有传入从右边开始
  return (array && array.length)
    ? baseWhile(array, baseIteratee(predicate, 3))
    : [];//
}

module.exports = takeWhile;

_.uniq(array)

创建一个数组包含原数组中的唯一值.

_.uniqBy(array, [iteratee=_.identity])

 和_.uniq很像，除了它接收一个遍历器被数组中的每个元素调用。

_.uniqWith(array, [comparator])

 和_.uniq很像，除了它接收一个比较方法被数组中的每个元素调用，比较方法接收两个参数（arrVal, othVal）

这三个方法依赖于baseUniq方法，先看源码

//_baseUniq.js

var SetCache = require('./_SetCache'),//Set缓存数组
    arrayIncludes = require('./_arrayIncludes'),//同Array.includes
    arrayIncludesWith = require('./_arrayIncludesWith'),//同Array.includes除了它接受一个比较方法
    cacheHas = require('./_cacheHas'),//判断缓存中是否含有某个元素
    createSet = require('./_createSet'),//创建Set对象
    setToArray = require('./_setToArray');//将Set对象转为数组

var LARGE_ARRAY_SIZE = 200;//大数组长度（用于数组过大时优化）

/**
 * _.uniqBy的基本实现，不支持遍历器的简写.
 *
 * @private
 * @param {Array} array 需要处理的数组.
 * @param {Function} [iteratee] 遍历器被每个元素调用.
 * @param {Function} [comparator] 比较器被每个元素 调用.
 * @returns {Array} 返回一个没有重复值得数组.
 */
function baseUniq(array, iteratee, comparator) {
  var index = -1,//数组索引
      includes = arrayIncludes,//是否包含
      length = array.length,//数组长度
      isCommon = true,//是否为常规比较
      result = [],//返回结果
      seen = result;//返回结果的引用（保存被遍历器调用过的值）

  if (comparator) {//如果有比较器,不是常规比较，并且比较方法为arrayIncludesWith
    isCommon = false;
    includes = arrayIncludesWith;
  }
  else if (length >= LARGE_ARRAY_SIZE) {//如果数组过长
    var set = iteratee ? null : createSet(array);
    if (set) {//如果没有传遍历器,只用转为Set对象，再转为数组,并将这个数组返回
      return setToArray(set);
    }
    //传了遍历器的情况

    isCommon = false;//也不是常规比较
    includes = cacheHas;//比较方法为cacheHas
    seen = new SetCache;//创建一个缓存数组
  }
  else {
    seen = iteratee ? [] : result;//如果有遍历器，seen为空数组，否则为result的引用
  }
  outer:
  //遍历数组
  while (++index < length) {
    var value = array[index],//当前元素
        computed = iteratee ? iteratee(value) : value;//如果有遍历器，对当前元素调用

    value = (comparator || value !== 0) ? value : 0;
    if (isCommon && computed === computed) {//常规情况，并且cumputed不为NaN
      var seenIndex = seen.length;//当前结果索引
      //遍历seen
      while (seenIndex--) {
          //如果当前结果中包含computed,跳过
        if (seen[seenIndex] === computed) {
          continue outer;
        }
      }
      if (iteratee) {//如果有遍历器，将computed添加到seen中
        seen.push(computed);
      }
      result.push(value);//将value添加到结果中
    }
    else if (!includes(seen, computed, comparator)) {//非常规比较
      if (seen !== result) {//如果seen为缓存，将computed添加到缓存中
        seen.push(computed);
      }
      result.push(value);//将value添加到结果中
    }
  }
  return result;//返回结果数组
}

module.exports = baseUniq;

对应的方法

uniq

//uniq.js

var baseUniq = require('./_baseUniq');//baseUniq方法

/**
 *
 * @param {Array} array 需要处理的数组.
 * @returns {Array} 返回一个没有重复值得数组.
 * @example
 *
 * _.uniq([2, 1, 2]);
 * // => [2, 1]
 */
function uniq(array) {
  return (array && array.length) ? baseUniq(array) : [];//不解释
}

module.exports = uniq;

uniqBy

//uniqBy.js

var baseIteratee = require('./_baseIteratee'),//遍历器封装
    baseUniq = require('./_baseUniq');//baseUniq方法

/**
 *
 *
 * @param {Array} array 需要处理的数组.
 * @param {Function} [iteratee=_.identity] 遍历器，被每个元素调用.
 * @returns {Array} 返回一个没有重复值得数组.
 * @example
 *
 * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
 * // => [2.1, 1.2]
 *
 * // The `_.property` iteratee shorthand.
 * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
 * // => [{ 'x': 1 }, { 'x': 2 }]
 */
function uniqBy(array, iteratee) {
  return (array && array.length) ? baseUniq(array, baseIteratee(iteratee, 2)) : [];//不解释
}

module.exports = uniqBy;

uniqWith

//uniqWith.js

var baseUniq = require('./_baseUniq');//baseUniq方法

/**
 *
 *
 * @param {Array} array 需要处理的数组.
 * @param {Function} [comparator] 比较方法，被每个元素调用.
 * @returns {Array} 返回一个没有重复值得数组.
 * @example
 *
 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
 *
 * _.uniqWith(objects, _.isEqual);
 * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
 */
function uniqWith(array, comparator) {
  comparator = typeof comparator == 'function' ? comparator : undefined;//比较器不为函数则为空
  return (array && array.length) ? baseUniq(array, undefined, comparator) : [];//不解释
}

module.exports = uniqWith;

_.union([arrays])

创建一个数组，包含给出的所有数组的值的唯一值.

//union.js

var baseFlatten = require('./_baseFlatten'),//数组扁平化（见源码学习（1））
    baseRest = require('./_baseRest'),//创建具备rest参数的方法
    baseUniq = require('./_baseUniq'),//baseUniq方法
    isArrayLikeObject = require('./isArrayLikeObject');//是否是类似数组的对象

/**
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @returns {Array} 返回一个没有重复值得数组.
 * @example
 *
 * _.union([2], [1, 2]);
 * // => [2, 1]
 */
var union = baseRest(function(arrays) {
    //先将给出的数组扁平化一级之后再调用baseUniq方法，并将结果作为返回值返回。
  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
});

module.exports = union;

_.unionBy([arrays], [iteratee=_.identity])

这个方法和_.union很像，除了它接收一个遍历器，被数组中的每个元素调用，遍历器接收一个参数（value）

//unionBy.js

var baseFlatten = require('./_baseFlatten'),//数组扁平化（见源码学习（1））
    baseIteratee = require('./_baseIteratee'),//遍历器封装
    baseRest = require('./_baseRest'),//创建具备rest参数的方法
    baseUniq = require('./_baseUniq'),//baseUniq方法
    isArrayLikeObject = require('./isArrayLikeObject'),//是否是类似数组的对象
    last = require('./last');//取得最后一个元素

/**
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @param {Function} [iteratee=_.identity] 遍历器，对每个元素调用.
 * @returns {Array} 返回一个没有重复值得数组.
 * @example
 *
 * _.unionBy([2.1], [1.2, 2.3], Math.floor);
 * // => [2.1, 1.2]
 *
 * // The `_.property` iteratee shorthand.
 * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
 * // => [{ 'x': 1 }, { 'x': 2 }]
 */
var unionBy = baseRest(function(arrays) {//创建可以使用rest参数的方法
  var iteratee = last(arrays);//遍历器为参数的最后一个
  if (isArrayLikeObject(iteratee)) {//如果是一个数组（就是没传），遍历器为undefined
    iteratee = undefined;
  }
  //先将给出的数组扁平化一级之后，并且将遍历器封装，再调用baseUniq方法，并将结果作为返回值返回。
  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), baseIteratee(iteratee, 2));
});

module.exports = unionBy;

_.unionWith([arrays], [comparator])

这个方法和_.union很像，除了它接收一个比较方法，被数组中的每个元素调用，比较方法接收两个参数（arrVal, othVal）.

//uniqWith.js

var baseFlatten = require('./_baseFlatten'),//数组扁平化（见源码学习（1））
    baseRest = require('./_baseRest'),//创建具备rest参数的方法
    baseUniq = require('./_baseUniq'),//baseUniq方法
    isArrayLikeObject = require('./isArrayLikeObject'),//是否是类似数组的对象
    last = require('./last');//取得最后一个元素

/**
 * 
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @param {Function} [comparator] 比较方法被每个元素调用.
 * @returns {Array} 返回一个没有重复值得数组.
 * @example
 *
 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
 * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
 *
 * _.unionWith(objects, others, _.isEqual);
 * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
 */
var unionWith = baseRest(function(arrays) {//创建可以使用rest参数的方法
  var comparator = last(arrays);//比较方法为最后一个参数
  comparator = typeof comparator == 'function' ? comparator : undefined;//如果不是函数，比较方法为undefined
  //调用baseUniq方法，并将结果作为返回值返回。
  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
});

module.exports = unionWith;

_.unzip(array)

_.zip的逆向，接收一个数组包含组合好的元素，然后创建一个数组重新分组这些元素到展开的状态

//unzip.js

var arrayFilter = require('./_arrayFilter'),//同Array.filter
    arrayMap = require('./_arrayMap'),//同Array.map
    baseProperty = require('./_baseProperty'),//通过key获取对象的value
    baseTimes = require('./_baseTimes'),//调用方法n次，返回包含每次结果的数组
    isArrayLikeObject = require('./isArrayLikeObject');//是否是一个类似数组的对象

var nativeMax = Math.max;//原生最小值方法

/**
 * 
 *
 * @param {Array} array 收起之后的数组.
 * @returns {Array} 返回展开之后的数组.
 * @example
 *
 * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
 * // => [['a', 1, true], ['b', 2, false]]
 *
 * _.unzip(zipped);
 * // => [['a', 'b'], [1, 2], [true, false]]
 */
function unzip(array) {
  if (!(array && array.length)) {//如果没有穿array,或者为空数组，返回空数组
    return [];
  }
  var length = 0;
  array = arrayFilter(array, function(group) {//返回array中，所有是数组的元素，并且取得length为最大的数组的长度
    if (isArrayLikeObject(group)) {
      length = nativeMax(group.length, length);
      return true;
    }
  });
  return baseTimes(length, function(index) {//调用length次方法，每次再调用map获得array中每个元素对应index位置的值得数组，然后将包含这些这些数组的数组返回。
    return arrayMap(array, baseProperty(index));
  });
}

module.exports = unzip;

_.unzipWith(array, [iteratee=_.identity])

这个方法和_.unzip很像，除了它接收一个遍历器决定怎么结合这些重组的元素，遍历器接收一个rest参数，表示每个分组中对应元素（...group）

//unzipWith.js


var apply = require('./_apply'),//同Function.apply
    arrayMap = require('./_arrayMap'),//同Array.map
    unzip = require('./unzip');//unzip方法

/**
 * 
 *
 * @param {Array} array 收起之后的数组.
 * @param {Function} [iteratee=_.identity] 遍历器，决定怎么结合这些元素
 * @returns {Array} 返回展开之后的数组.
 * @example
 *
 * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
 * // => [[1, 10, 100], [2, 20, 200]]
 *
 * _.unzipWith(zipped, _.add);
 * // => [3, 30, 300]
 */
function unzipWith(array, iteratee) {
  if (!(array && array.length)) {//如果没有array或者为空数组，返回空数组
    return [];
  }
  var result = unzip(array);//调用unzip方法执行反压缩
  if (iteratee == null) {//如果没有传入便利器返回result
    return result;
  }
  return arrayMap(result, function(group) {//对结果进行遍历，每次调用iteratee传入每个group的所有元素,然后将处理后的结果作为每个分组的元素。
    return apply(iteratee, undefined, group);
  });
}

module.exports = unzipWith;

_.without(array, [values])

创建一个数组排除所有给定的值

//widthout.js

var baseDifference = require('./_baseDifference'),//取得数组中不包含过滤数组的元素（见源码学习（1））
    baseRest = require('./_baseRest'),//创建具备rest参数的数组
    isArrayLikeObject = require('./isArrayLikeObject');//是否是类似数组的对象

/**
 * 
 *
 * @param {Array} array 需要处理的数组.
 * @param {...*} [values] 需要排除的值.
 * @returns {Array} 返回过滤后的数组.
 * @example
 *
 * _.without([2, 1, 2, 3], 1, 2);
 * // => [3]
 */
var without = baseRest(function(array, values) {//创建具备rest参数的数组
    //如果是类似数组，调用baseDifference并将结果作为返回值返回，否则返回空数组
  return isArrayLikeObject(array)
    ? baseDifference(array, values)
    : [];
});

module.exports = without;

_.xor([arrays])

 创建一个唯一值得数组，包含给定所有数组中symmetric difference的集合（对差等分，{1,2,3}△{2,3,4} => {1,4}）

_.xorBy([arrays], [iteratee=_.identity])

这个方法和_.xor很像，除了它接收一个遍历器对每个元素调用，生成比较标准，遍历器接收一个参数（value）

_.xorWith([arrays], [comparator])

 这个方法和_.xor很像，除了它接收一个比较器对每个元素调用，生成比较标准，比较器接收两个参数（arrVal,othVal）

这三个方法依赖于baseXor方法，先看源码

//_baseXor.js

var baseDifference = require('./_baseDifference'),//取得数组中不包含过滤数组的元素（见源码学习（1））
    baseFlatten = require('./_baseFlatten'),//数组扁平化（见源码学习（1））
    baseUniq = require('./_baseUniq');//得到数组中唯一值

/**
 * _.xor的基本实现，不支持遍历器的简写
 *
 * @private
 * @param {Array} arrays 需要处理的数组.
 * @param {Function} [iteratee] 遍历器被每个元素调用.
 * @param {Function} [comparator] 比较器被每个元素调用.
 * @returns {Array} 返回一个新的数组.
 */
function baseXor(arrays, iteratee, comparator) {
  var length = arrays.length;//数组长度
  if (length < 2) {//如果数组中元素个数小于2
    return length ? baseUniq(arrays[0]) : [];//如果有值得到第一个值得唯一值，否则空数组
  }
  var index = -1,//数组索引
      result = Array(length);//返回结果

  //遍历arrays
  while (++index < length) {
    var array = arrays[index],//当前数组
        othIndex = -1;//用于比较的数组的索引
    //遍历用于比较的数组
    while (++othIndex < length) {
      if (othIndex != index) {//如果比较的数组和当前数组不是同一个数组，调用baseDifference方法取得array中不同于当前用于比较的数组的值
        result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
      }
    }
  }
  //调用baseUiq方法，并且将result扁平化一级，然后将得到的唯一值数组返回
  return baseUniq(baseFlatten(result, 1), iteratee, comparator);
}

module.exports = baseXor;

对应的方法

xor

//xor.js

var arrayFilter = require('./_arrayFilter'),//同Array.filter
    baseRest = require('./_baseRest'),//创建具有rest参数的方法
    baseXor = require('./_baseXor'),//baseXor方法
    isArrayLikeObject = require('./isArrayLikeObject');//是否是类似数组的对象

/**
 *
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @returns {Array} 返回过滤后的数组.
 * @example
 *
 * _.xor([2, 1], [2, 3]);
 * // => [1, 3]
 */
var xor = baseRest(function(arrays) {//创建具有rest参数的方法
  return baseXor(arrayFilter(arrays, isArrayLikeObject));//调用baseXor并将结果作为返回值返回
});

module.exports = xor;

xorBy

//xorBy.js

var arrayFilter = require('./_arrayFilter'),//同Array.filter
    baseIteratee = require('./_baseIteratee'),//遍历器封装
    baseRest = require('./_baseRest'),//创建具备rest参数的方法
    baseXor = require('./_baseXor'),//baseXor方法
    isArrayLikeObject = require('./isArrayLikeObject'),//是否是一个类似数组的对象
    last = require('./last');//取得数组最后一个元素

/**
 *
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @param {Function} [iteratee=_.identity] 遍历器被每个元素调用.
 * @returns {Array} 返回过滤后的数组.
 * @example
 *
 * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
 * // => [1.2, 3.4]
 *
 * // The `_.property` iteratee shorthand.
 * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
 * // => [{ 'x': 2 }]
 */
var xorBy = baseRest(function(arrays) {//转化arrays为rest参数
  var iteratee = last(arrays);//遍历器为最后一个参数
  if (isArrayLikeObject(iteratee)) {//最后一个参数为数组，遍历器为undefined
    iteratee = undefined;
  }
  //调用baseXor并且封装遍历器，然后将结果作为返回值返回
  return baseXor(arrayFilter(arrays, isArrayLikeObject), baseIteratee(iteratee, 2));
});

module.exports = xorBy;

xorWith

//xorWith.js

var arrayFilter = require('./_arrayFilter'),//同Array.filter
    baseRest = require('./_baseRest'),//创建具备rest参数的方法
    baseXor = require('./_baseXor'),//baseXor方法
    isArrayLikeObject = require('./isArrayLikeObject'),//是否是一个类似数组的对象
    last = require('./last');//取得数组最后一个元素

/**
 *
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @param {Function} [comparator] 比较器被每个元素调用.
 * @returns {Array} 返回过滤后的数组.
 * @example
 *
 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
 * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
 *
 * _.xorWith(objects, others, _.isEqual);
 * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
 */
var xorWith = baseRest(function(arrays) {//创建使用rest参数的方法
  var comparator = last(arrays);//比较器为最后一个参数
  comparator = typeof comparator == 'function' ? comparator : undefined;//比较器不是函数则为undefined
  //调用baseXor并且传入比较器，然后将结果作为返回值返回
  return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);
});

module.exports = xorWith;

_.zip([arrays])

创建一个数组包含分组之后的元素，第一个元素为所有给出的数组的第一个元素，第二个元素为所有给出的数组的第二个元素，以此类推。

//zip.js

var baseRest = require('./_baseRest'),//创建具备rest参数的方法
    unzip = require('./unzip');//收起方法

/**
 * 
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @returns {Array} 返回收起之后的数组.
 * @example
 *
 * _.zip(['a', 'b'], [1, 2], [true, false]);
 * // => [['a', 1, true], ['b', 2, false]]
 */
var zip = baseRest(unzip);//创建unzip的rest参数模式

module.exports = zip;

_.zipObject([props=[]], [values=[]])

接收两个数组转化为对象，将第一个数组作为对象的属性，第二个作为对象的值，返回这个对象

这个方法依赖于baseZipObject和assignValue方法，assignValue方法依赖于baseAssignValue方法

baseZipObject

//_baseZipObject.js

/**
 * _.zipObject的基本实现，通过assignFunc进行赋值
 *
 * @param {Array} props 属性名.
 * @param {Array} values 属性值.
 * @param {Function} assignFunc 赋值方法.
 * @returns {Object} 返回新的对象.
 */
function baseZipObject(props, values, assignFunc) {
  var index = -1,//索引值
      length = props.length,//属性名个数
      valsLength = values.length,//属性值个数
      result = {};//返回结果对象

  while (++index < length) {//遍历属性名，如果对应的属性值没有则为undefined
    var value = index < valsLength ? values[index] : undefined;
    assignFunc(result, props[index], value);//使用赋值函数进行赋值
  }
  return result;//返回结果
}

module.exports = baseZipObject;

baseAssignValue

//_baseAssignValue.js

var defineProperty = require('./_defineProperty');//同Object.defineProperty

/**
 * assignValue方法和assignMergeValue的基本实现，不对值进行检查
 *
 * @private
 * @param {Object} object 需要修改的对象.
 * @param {string} key 赋值的key.
 * @param {*} value 赋值的value.
 */
function baseAssignValue(object, key, value) {
  if (key == '__proto__' && defineProperty) {//如果给__proto__赋值，使用defineProperty赋值
    defineProperty(object, key, {
      'configurable': true,
      'enumerable': true,
      'value': value,
      'writable': true
    });
  } else {//直接赋值
    object[key] = value;
  }
}

module.exports = baseAssignValue;

assignValue

//_assignValue.js

var baseAssignValue = require('./_baseAssignValue'),//baseAssignValue方法
    eq = require('./eq');//判断是否相等

var objectProto = Object.prototype;//对象的原型

var hasOwnProperty = objectProto.hasOwnProperty;//原生hasOwnProperty方法

/**
 * 对对象进行赋值，如果这个值不和本身对象中对象属性的值相同的话
 *
 * @private
 * @param {Object} object 需要修改的对象.
 * @param {string} key 辅助的key.
 * @param {*} value 赋值的value.
 */
function assignValue(object, key, value) {
  var objValue = object[key];//对象中对应属性的值
  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
      (value === undefined && !(key in object))) {//如果属性不存在或者和本身的属性不相等，进行赋值操作
    baseAssignValue(object, key, value);
  }
}

module.exports = assignValue;

然后再看zipObject就比较清晰了

//zipObject.js

var assignValue = require('./_assignValue'),//赋值函数
    baseZipObject = require('./_baseZipObject');//baseZipObject方法

/**
 * 接收两个数组转化为对象，将第一个数组作为对象的属性，第二个作为对象的值，返回这个对象
 *
 * @param {Array} [props=[]] 属性名.
 * @param {Array} [values=[]] 属性值.
 * @returns {Object} 返回新的对象.
 * @example
 *
 * _.zipObject(['a', 'b'], [1, 2]);
 * // => { 'a': 1, 'b': 2 }
 */
function zipObject(props, values) {
  return baseZipObject(props || [], values || [], assignValue);//不解释
}

module.exports = zipObject;

_.zipObjectDeep([props=[]], [values=[]])

这个方法和_.zipObject很像，除了它支持使用属性的路径进行赋值

//zipObjectDeep.js

var baseSet = require('./_baseSet'),//赋值函数，支持使用属性路径（暂时不分析）
    baseZipObject = require('./_baseZipObject');//baseZipObject方法

/**
 * 
 *
 * @static
 * @memberOf _
 * @since 4.1.0
 * @category Array
 * @param {Array} [props=[]] 属性名.
 * @param {Array} [values=[]] 属性值.
 * @returns {Object} 返回新的对象.
 * @example
 *
 * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
 * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
 */
function zipObjectDeep(props, values) {
  return baseZipObject(props || [], values || [], baseSet);//不解释
}

module.exports = zipObjectDeep;

_.zipWith([arrays], [iteratee=_.identity])

//zipWith.js

var baseRest = require('./_baseRest'),//创建具备rest参数的方法
    unzipWith = require('./unzipWith');//unzipWith方法。

/**
 * 这个方法和_.zip很像，除了它接收一个遍历器决定怎么结合这些重组的元素，遍历器接收一个rest参数，表示每个分组中对应元素（...group）
 *
 * @param {...Array} [arrays] 需要处理的数组.
 * @param {Function} [iteratee=_.identity] 遍历器，决定怎么结合这些元素
 *  grouped values.
 * @returns {Array} 返回收起之后的数组.
 * @example
 *
 * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
 *   return a + b + c;
 * });
 * // => [111, 222]
 */
var zipWith = baseRest(function(arrays) {//创建使用rest参数的方法
  var length = arrays.length,//参数长度
      iteratee = length > 1 ? arrays[length - 1] : undefined;//如果参数超过一个，遍历器为最后一个参数

  iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;//如果遍历不为function,则为undefined
  return unzipWith(arrays, iteratee);//调用unzipWith方法，并将结果作为返回值返回。
});

module.exports = zipWith;

数组部分完结了，这些方法包含了很多对原生方法的重写，以及对数组的的各种遍历计算重组，通过学习这些方法感觉对数组的使用有了更深刻的认识。所以。。。继续加油吧。。。！