前言

今天讲的是difference()、differenceBy()、differenceWith()函数。

difference()

创建一个新数组，这个数组中的值，为第一个数组（array）排除了给定数组（values）中的值。

我的实现是

function difference(array, values){
    if(!array || !Array.isArray(array) || array.length<=0){
        return [];
    }
    var except=Array.from(arguments).slice(1);
    if(!except || except.length<=0){
        return array.concat();
    }
   return array.filter(function(value){
        return except.indexOf(value) < 0;
    });
}

我只是调用了es6语法中Array的filter()和indexOf()，实现起来比较简单

lodash的实现是：

var difference = baseRest(function(array, values) {
  return isArrayLikeObject(array)
    ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
    : [];
});

lodash写的更加的严密。

一开始会调用baseRest()方法，这个函数主要是对剩余参数的处理，它不用验证参数或者强制输入参数。我的实现是用arguments,而lodash相对复杂，但更通用吧。主要逻辑都在baseDifference()方法里。baseDifference()后面再说。

不过，我的实现可以做到difference([3, 2, 1],1,2,8)的调用，而lodash貌似还不行，这我还是挺高兴的。

differenceBy()

这个方法类似difference() ，额外的接受一个iteratee（迭代器）参数，首先使用迭代器分别迭代array 和 values中的每个元素，返回的值作为比较值。 结果值是从第一数组中选择。

我的实现是

function differenceBy(array) {
    if (!array || !Array.isArray(array) || array.length <= 0) {
        return [];
    }
    var except = arguments[1];
    if (!except  || !Array.isArray(except) || except.length <= 0) {
        return array.concat();
    }
    var func = arguments[2];
    if (!func) {
        func = x => x;
    } else if (typeof func === 'string') {
        var key = func;
        func = data => data[key];
    }
    var exc = except.map(function (value) {
        return func(value);
    });
    return array.filter(function (value) {
        return exc.indexOf(func(value)) < 0;
    });

}

类似于与different()实现基本一致，仅仅加了一个函数的转换而已。由于函数的限制，不能再函数后边直接填写参数了，只能包装成数组传递。

lodash的实现是：

var differenceBy = baseRest(function(array, values) {
  var iteratee = last(values);
  if (isArrayLikeObject(iteratee)) {
    iteratee = undefined;
  }
  return isArrayLikeObject(array)
    ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), baseIteratee(iteratee, 2))
    : [];
});

和difference()基本一致。不同的是diffence()默认是调用_.identity()迭代器，baseDifference()最后是传入了baseIteratee(iteratee, 2)迭代器。

differenceWith()

这个方法类似difference() ，它额外接受一个 comparator（比较器），它调用比较array，values中的元素。 结果值是从第一数组中选择。comparator 调用参数有两个：(arrVal, othVal)。

我的实现是：

function differenceWith(array){
    if (!array || !Array.isArray(array) || array.length <= 0) {
        return [];
    }
    var except = arguments[1];
    if (!except  || !Array.isArray(except) || except.length <= 0) {
        return array.concat();
    }
    var comparator = arguments[2];
    if (!comparator || typeof comparator !== 'function') {
        comparator = (arrVal, othVal)=>arrVal===othVal;
    }
    return array.filter(function (value) {
        var flag=true;
        except.forEach(element => {
            if(comparator(value,element)){
                flag=false;
                return;
            }
        });
        return flag;
    });
}

结构也差不多吧，最后filter回调函数里的是遍历要except,当前的value与except里的每一个元素做比较，comparator()函数返回true代表相等，false代表不等。如果找到一个相等的，filter就返回false，遍历结束了还没有找到，说明就没有相等的，返回true。

lodash的实现

var differenceWith = baseRest(function(array, values) {
  var comparator = last(values);
  if (isArrayLikeObject(comparator)) {
    comparator = undefined;
  }
  return isArrayLikeObject(array)
    ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
    : [];
});

可以看出，和其他两个也都差不多。baseDifference()最后多了一个比较器。我们可以看下具体的实现:

baseDifference()

function baseDifference(array, values, iteratee, comparator) {
  var index = -1,
      includes = arrayIncludes,
      isCommon = true,
      length = array.length,
      result = [],
      valuesLength = values.length;

  if (!length) {
    return result;
  }
  if (iteratee) {
    values = arrayMap(values, baseUnary(iteratee));
  }
  if (comparator) {
    includes = arrayIncludesWith;
    isCommon = false;
  }
  else if (values.length >= LARGE_ARRAY_SIZE) {
    includes = cacheHas;
    isCommon = false;
    values = new SetCache(values);
  }
  outer:
  while (++index < length) {
    var value = array[index],
        computed = iteratee == null ? value : iteratee(value);

    value = (comparator || value !== 0) ? value : 0;
    if (isCommon && computed === computed) {
      var valuesIndex = valuesLength;
      while (valuesIndex--) {
        if (values[valuesIndex] === computed) {
          continue outer;
        }
      }
      result.push(value);
    }
    else if (!includes(values, computed, comparator)) {
      result.push(value);
    }
  }
  return result;
}

lodash通过这个函数，把三个功能封装到一块了, lodash没有使用原生array的实例方法，而是使用两个while循环的嵌套，实现difference的功能。