数组篇
1.compact,就是将数组中的false值去掉
function compact(array) {
var index = -1,
length = array ? array.length : 0,
resIndex = -1,
result = [];
while (++index < length) { //while循环还是比较好的
var value = array[index];
if (value) {
result[++resIndex] = value;
}
}
return result;
}
2.slice 分割数组,禁用了原生的slice方法,重写了slice方法.但是对于重写的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.slice(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 = array[index];
if (isCommon && value === value) { //对于NaN是不等于本身的.
var valuesIndex = valuesLength;
while (valuesIndex--) { //从后向前循环
if (values[valuesIndex] === value) {
continue outer; //注意continue以后就不会执行result.push(value),而是将会这一次循环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 = arr[length];
console.log(value === 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'