30个常用的lodash工具函数

chunk: 将数组拆分成指定大小的多个数组

function chunk(array, size) {const result = [];for (let i = 0; i < array.length; i += size) {result.push(array.slice(i, i + size));}return result;
}

compact: 过滤数组中的假值（false、null、0、“”、undefined 和 NaN）

function compact(array) {return array.filter(Boolean);
}

concat: 合并多个数组

function concat(...arrays) {return [].concat(...arrays);
}

difference: 返回第一个数组中与其他数组不同的元素

function difference(array, ...values) {const set = new Set([].concat(...values));return array.filter(item => !set.has(item));
}

drop: 从数组的开头删除指定数量的元素

function drop(array, n = 1) {return array.slice(n);
}

dropRight: 从数组的末尾删除指定数量的元素

function dropRight(array, n = 1) {return array.slice(0, -n);
}

fill: 使用指定的值填充数组

function fill(array, value, start = 0, end = array.length) {return array.map((item, index) => (index >= start && index < end) ? value : item);
}

findIndex: 返回第一个满足条件的元素的索引

function findIndex(array, predicate) {for (let i = 0; i < array.length; i++) {if (predicate(array[i], i, array)) {return i;}}return -1;
}

flatten: 扁平化数组

function flatten(array) {return [].concat(...array);
}

fromPairs: 将键值对数组转换为对象

function fromPairs(array) {const result = {};for (const [key, value] of array) {result[key] = value;}return result;
}

head: 返回数组的第一个元素

function head(array) {return array[0];
}

indexOf: 返回指定元素在数组中的索引

function indexOf(array, value, fromIndex = 0) {for (let i = fromIndex; i < array.length; i++) {if (array[i] === value) {return i;}}return -1;
}

initial: 返回数组中除了最后一个元素的所有元素

function initial(array) {return array.slice(0, -1);
}

intersection: 返回多个数组中共同存在的元素

function intersection(...arrays) {const set = new Set(arrays[0]);for (const array of arrays) {set.forEach(item => {if (!array.includes(item)) {set.delete(item);}});}return Array.from(set);
}

join: 将数组转换为字符串并使用指定的分隔符连接

function join(array, separator = ',') {return array.join(separator);
}

last: 返回数组的最后一个元素

function last(array) {return array[array.length - 1];
}

nth: 返回数组中指定索引的元素（支持负数索引）

function nth(array, n = 0) {return n >= 0 ? array[n] : array[array.length + n];
}

pull: 从数组中移除指定的值

function pull(array, ...values) {return array.filter(item => !values.includes(item));
}

reverse: 反转数组的顺序

function reverse(array) {return array.reverse();
}

slice: 返回数组的指定部分

function slice(array, start = 0, end = array.length) {return array.slice(start, end);
}

sortedIndex: 返回指定值在已排序数组中应该插入的索引

function sortedIndex(array, value) {let low = 0;let high = array.length;while (low < high) {const mid = Math.floorlow + high) / 2);if (array[mid] < value) {low = mid + 1;} else {high = mid;}return low;
}

22.: 返回数组除了第一个元素的所有元素

function tail(array) {return array.slice(1);
}

take: 返回数组的前n个元素

function take(array, n = 1) {return array.slice(0, n);
}

union: 返回多个数组的并集

function union(...arrays) {return Array.from(new Set([].concat(...arrays)));
}

uniq: 返回数组中唯一的元素

function uniq(array) {return Array.from(new Set(array));
}

without: 返回数组中除了指定值之外的所有元素

function without(array, ...values) {return array.filter(item => !values.includes(item));
}

xor: 返回多个数组的异或集

function xor(...arrays) {const count = {};for (const array of arrays) {for (const item of array) {count[item] = (count[item] || 0) + 1;}}return Object.keys(count).filter(item => count[item] === 1);
}

zip: 将多个数组按索引合并为一个数组

function zip(...arrays) {const maxLength = Math.max(...arrays.map(array => array.length));const result = [];for (let i = 0; i < maxLength; i++) {result.push(arrays.map(array => array[i]));}return result;
}

countBy: 根据指定条件对数组进行分组计数

function countBy(array, iteratee) {const result = {};for (const item of array) {const key = typeof iteratee === 'function' ? iteratee(item) : item[iteratee];result[key] = (result[key] || 0) + 1;}return result;
}

debounce: 创建一个防抖函数，延迟执行指定的函数

function debounce(func, wait, immediate = false) {let timeout;return function(...args) {const later = () => {timeout = null;if (!immediate) {func.apply(this, args);}};const callNow = immediate && !timeout;clearTimeout(timeout);timeout = setTimeout(later, wait);if (callNow) {func.apply(this, args);}};
}