数组篇

1.compact,就是将数组中的false值去掉

function compact(array) {
  var index = -1,
      length = array ? array.length : 0,
      resIndex = -1,
      result = [];

  while (++index < length) {                      //while循环还是比较好的
    var value = http://www.mamicode.com/array[index];
    if (value) {
      result[++resIndex] = value;
    }
  }
  return result;
}

2.slice 分割数组

function baseSlice(array, start, end) {
var index = -1,
length = array.length;

start = start == null ? 0 : (+start || 0);
if (start < 0) {
start = -start > length ? 0 : (length + start);
}
end = (end === undefined || end > length) ? length : (+end || 0);
if (end < 0) {
end += length;
}
length = start > end ? 0 : ((end - start) >>> 0);
start >>>= 0;

var result = Array(length);
while (++index < length) {
result[index] = array[index + start];
}
return result;
}

在lodash中,对slice方法进行了重写,原生的js方法是ArrayObject(start,end)

3.drop方法
drop方法是用了slice的方法

function drop(array, n, guard) {
  var length = array ? array.length : 0;
  if (!length) {
    return [];
  }
  if (guard ? isIterateeCall(array, n, guard) : n == null) {
    n = 1;
  }
  return baseSlice(array, n < 0 ? 0 : n);
}

4.difference方法,获取到第一个中与第二个的不同的元素,在while循环中,++则要小于一个值,--则直接while(valuesIndex--)  这样是先判断减的值 当valuesIndex为1时,仍通过.

var difference = restParam(function(array, values) {
  return isArrayLike(array)
    ? baseDifference(array, baseFlatten(values, false, true))
    : [];
});

主方法中的baseDifference

function baseDifference(array, values) {
  var length = array ? array.length : 0,
      result = [];

  if (!length) {
    return result;
  }
  var index = -1,
      indexOf = baseIndexOf,
      isCommon = true,
      cache = (isCommon && values.length >= 200) ? createCache(values) : null,
      valuesLength = values.length;

  if (cache) {
    indexOf = cacheIndexOf;
    isCommon = false;
    values = cache;
  }
  outer:
  while (++index < length) {
    var value = http://www.mamicode.com/array[index];

    if (isCommon && value =http://www.mamicode.com/== value) {              //对于引用类型===是不相等的,通过这个来判断是不是引用类型,因为引用地址不同.
      var valuesIndex = valuesLength;
      while (valuesIndex--) {                       //从后向前循环
        if (values[valuesIndex] === value) {
          continue outer;
        }
      }
      result.push(value);
    }
    else if (indexOf(values, value, 0) < 0) {
      result.push(value);
    }
  }
  return result;
}

带标签的break和continue的终端层数问题:这里的标签是break outermost是停止外面的主循环(如果没有标签咱们在内存不能停掉外面主循环的),continue outer是指停掉外面的本次的主循环,下次主循环又从i=3开始.
带标签是为了从内部控制主循环.

//--------------------------------------------
var iNum = 0;
var inum = 0;
outermost:
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (i == 2 && j == 2) {
                break outermost;
            }
            iNum++;
        }
        inum++;
    }
console.log(iNum,inum);    //10 2
//---------------------------------------------
var Num = 0;
var num = 0;
outer:
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (i == 2 && j == 2) {
                continue outer;
            }
            Num++;
        }
        num++;
    }
console.log(Num,num);    //14 3
//---------------------------------------------

本身与本身不相等情况:NaN不与NaNx相等

var arr = [{},function(){},undefined,null,‘‘,NaN,/.^/,[]];
var length = arr.length;
while(length--){
    var value = http://www.mamicode.com/arr[length];
    console.log(value =http://www.mamicode.com/== value);      //其中只有NaN不相等
}

5.fill是指的替换

_.fill([4, 6, 8], ‘*‘, 1, 2);
// => [4, ‘*‘, 8]
核心算法如下:这个方法的目的是将数组内的值进行替换.
>>>0 为无符号右移0位,如果是负数,则是取补码,如果是正数则不会改变值.
-1 >>> 0   //4294967295  因为1的2^32 = 4294967296
1 >>> 0    //1

length = start > end ? 0 : (end >>> 0);
start >>>= 0;

while (start < length) {
  array[start++] = value;
}
return array;

数组的原声的替换如下:

arrayObject.splice(index,howmany,item1,.....,itemX)

var arr = [‘George‘,‘John‘,‘Thomas‘,‘James‘,‘Adrew‘,‘Martin‘]
var arr2 = arr.splice(2,1,‘77‘)
//arr2  [‘George‘,‘John‘,‘77‘,‘James‘,‘Adrew‘,‘Martin‘]

index=2的值是Thomas,替换1个,替换值是‘77‘

lodash的源码