lodash源码学习-数组篇
1，chunk
function slice(array, start, end) {
// 1, 对参数进行处理
let length = array == null ? 0 : array.length
if (!length) {
return []
}
// 1.1 对开始参数进行初步处理
start = start == null ? 0 : start
end = end === undefined ? length : end
// 1.2 对开始参数再次进行负数异常处理
if (start < 0) {
start = -start > length ? 0 : (length + start)
}
// 1.3 对结束参数进行初步处理
end = end > length ? length : end
// 1.4 对结束参数再次进行负数异常处理
if (end < 0) {
end += length
}
//x >>> 0本质上就是保证x有意义（为数字类型），且为正整数，在有效的数组范围内（0 ～ 0xFFFFFFFF）
//，且在无意义的情况下缺省值为0。一个小小的表达式，隐藏着着多重的异常处理。js真是诡异啊。
length = start > end ? 0 : ((end - start) >>> 0)
start >>>= 0
let index = -1
const result = new Array(length)
while (++index < ßlength) {
result[index] = array[index + start]
}
return result
}
function chunk(array, size) {
// size默认值为1
// 如果size小于0，取0处理，大于0，则取size值
size = Math.max(size, 0)
// 如果array为null，length取0，否则取array.length
const length = array == null ? 0 : array.length
// 如果length为0或者size小于1，返回一个空数组
if (!length || size < 1) {
return []
}
let index = 0
let resIndex = 0
// 用数组的长度除以size并向上取整以得到分块的个数，新建一个长度为分块个数的数组result
const result = new Array(Math.ceil(length / size))
// 下面的while循环主要做的事情是遍历array数组，每次截取array中的size个元素并将截取结果添加到result数组中
// while循环中index从0开始，每次增加size大小，直到index大于等于length时跳出循环
// 每次循环时，result数组中的索引resIndex加1
// 在每次循环体中，从array中截取索引为index到（index+size）之间的元素返回一个数组，并将返回结果添加到result数组中
// 截取array元素时使用的方法slice实现可以查看slice对应的源码分析
while (index < length) {
result[resIndex++] = slice(array, index, (index += size))
}
// 返回最终结果result
return result
}
2，compact
// false, null, 0, "", undefined, 和 NaN 都是被认为是“假值”。
// compact去除数组的假值
function compact(array) {
let resIndex = 0
const result = []
// 处理参数异常
if (array == null) {
return result
}
for (const value of array) {
if (value) { // 利用 if() 隐式计算来排除假值
result[resIndex++] = value
}
}
return result
}
export default compact3，concat
// array (Array): 被连接的数组。
// [values] (...*): 连接的值。
function concat(...rest){
let [array,...values] = rest;
let result = JSON.parse(JSON.stringify(array));
values.forEach(v=>{
if(v instanceof Array ){
v.forEach(i=>{
result = [...result,i]
})
}else{
result = [...result,v]
}
})
return result;
}
export default concat4，difference
// 参数
// array (Array): 要检查的数组。
// [values] (...Array): 排除的值。
// 返回值
// (Array): 返回一个过滤值后的新数组。
function isObjectLike(value) {
// 是否是一个不为null的对象
return typeof value === 'object' && value !== null
}
function isArrayLike(value) {
// 是否 是一个对象 并且不是函数 并且有长度
return value != null && typeof value !== 'function' && isLength(value.length)
}
function isArrayLikeObject(value) {
// 是否会返回一个有长度的数组
return isObjectLike(value) && isArrayLike(value)
}
function baseDifference(array, values, iteratee, comparator) {
let includes = arrayIncludes
let isCommon = true
const result = []
const valuesLength = values.length
if (!array.length) {
return result
}
if (iteratee) {
values = map(values, (value) => iteratee(value))
}
if (comparator) {
includes = arrayIncludesWith
isCommon = false
}
else if (values.length >= LARGE_ARRAY_SIZE) {
includes = cacheHas
isCommon = false
values = new SetCache(values)
}
outer:
for (let value of array) {
const computed = iteratee == null ? value : iteratee(value)
value = (comparator || value !== 0) ? value : 0
if (isCommon && computed === computed) {
let valuesIndex = valuesLength
while (valuesIndex--) {
if (values[valuesIndex] === computed) {
continue outer
}
}
result.push(value)
}
else if (!includes(values, computed, comparator)) {
result.push(value)
}
}
return result
}
function baseFlatten(array, depth, predicate, isStrict, result) {
predicate || (predicate = isFlattenable)
// result 不存在， 默认为空数组
result || (result = [])
if (array == null) {
return result
}
for (const value of array) {
if (depth > 0 && predicate(value)) {
if (depth > 1) {
// Recursively flatten arrays (susceptible to call stack limits).
baseFlatten(value, depth - 1, predicate, isStrict, result)
} else {
result.push(...value)
}
} else if (!isStrict) {
result[result.length] = value
}
}
return result
}
function difference(array, ...values) {
return isArrayLikeObject(array) // 如果是一个有长度的数组继续程序否则返回 空数组
? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
: []
}
export default difference5. differenceBy
// array (Array): 要检查的数组。
// [values] (...Array): 排除的值。
// [iteratee=_.identity] (Array|Function|Object|string): iteratee 调用每个元素。
// iteratee 会调用一个参数：(value)。（首先使用迭代器分别迭代array 和 values中的每个元素，返回的值作为比较值）。
/**
* Gets the last element of `array`.
*
* @since 0.1.0
* @category Array
* @param {Array} array The array to query.
* @returns {*} Returns the last element of `array`.
* @example
*
* last([1, 2, 3])
* // => 3
*/
function last(array) {
const length = array == null ? 0 : array.length
return length ? array[length - 1] : undefined
}
function differenceBy(array, ...values) {
let iteratee = last(values)
if (isArrayLikeObject(iteratee)) { // 如果是个数组那么 那么赋值 undefined
iteratee = undefined
}
return isArrayLikeObject(array)
? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), iteratee)
: []
}
export default differenceBy6， differenceWith
// array (Array): 要检查的数组。
// [values] (...Array): 排除的值。
// [comparator] (Function): comparator 调用每个元素。
// 这个方法类似 _.difference ，除了它接受一个 comparator （比较器），它调用比较array，values中的元素。 结果值是从第一数组中选择。comparator 调用参数有两个：(arrVal, othVal)。
// 用于比较处理对象数组
function differenceWith(array, ...values) {
let comparator = last(values)
if (isArrayLikeObject(comparator)) {
comparator = undefined
}
return isArrayLikeObject(array)
? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
: []
}
export default differenceWith7，drop
const INFINITY = 1 / 0
const MAX_INTEGER = 1.7976931348623157e+308
function toFinite(value) {
if (!value) {
return value === 0 ? value : 0
}
value = toNumber(value)
if (value === INFINITY || value === -INFINITY) {
const sign = (value < 0 ? -1 : 1)
return sign * MAX_INTEGER
}
// NaN处理 NaN === NaN 为 false
return value === value ? value : 0
}
function toInteger(value) {
// 合理化数值 做边际处理
const result = toFinite(value)
// 把 小数通过余数的方式取出来
const remainder = result % 1
return remainder ? result - remainder : result
}
function drop(array, n=1) {
const length = array == null ? 0 : array.length
return length
? slice(array, n < 0 ? 0 : toInteger(n), length)
: []
}
export default drop