- chunk: 将数组拆分成指定大小的多个数组
javascript
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)
javascript
function compact(array) {
return array.filter(Boolean);
}
- concat: 合并多个数组
javascript
function concat(...arrays) {
return [].concat(...arrays);
}
- difference: 返回第一个数组中与其他数组不同的元素
javascript
function difference(array, ...values) {
const set = new Set([].concat(...values));
return array.filter(item => !set.has(item));
}
- drop: 从数组的开头删除指定数量的元素
javascript
function drop(array, n = 1) {
return array.slice(n);
}
- dropRight: 从数组的末尾删除指定数量的元素
javascript
function dropRight(array, n = 1) {
return array.slice(0, -n);
}
- fill: 使用指定的值填充数组
javascript
function fill(array, value, start = 0, end = array.length) {
return array.map((item, index) => (index >= start && index < end) ? value : item);
}
- findIndex: 返回第一个满足条件的元素的索引
javascript
function findIndex(array, predicate) {
for (let i = 0; i < array.length; i++) {
if (predicate(array[i], i, array)) {
return i;
}
}
return -1;
}
- flatten: 扁平化数组
javascript
function flatten(array) {
return [].concat(...array);
}
- fromPairs: 将键值对数组转换为对象
javascript
function fromPairs(array) {
const result = {};
for (const [key, value] of array) {
result[key] = value;
}
return result;
}
- head: 返回数组的第一个元素
javascript
function head(array) {
return array[0];
}
- indexOf: 返回指定元素在数组中的索引
javascript
function indexOf(array, value, fromIndex = 0) {
for (let i = fromIndex; i < array.length; i++) {
if (array[i] === value) {
return i;
}
}
return -1;
}
- initial: 返回数组中除了最后一个元素的所有元素
javascript
function initial(array) {
return array.slice(0, -1);
}
- intersection: 返回多个数组中共同存在的元素
javascript
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: 将数组转换为字符串并使用指定的分隔符连接
javascript
function join(array, separator = ',') {
return array.join(separator);
}
- last: 返回数组的最后一个元素
javascript
function last(array) {
return array[array.length - 1];
}
- nth: 返回数组中指定索引的元素(支持负数索引)
javascript
function nth(array, n = 0) {
return n >= 0 ? array[n] : array[array.length + n];
}
- pull: 从数组中移除指定的值
javascript
function pull(array, ...values) {
return array.filter(item => !values.includes(item));
}
- reverse: 反转数组的顺序
javascript
function reverse(array) {
return array.reverse();
}
- slice: 返回数组的指定部分
javascript
function slice(array, start = 0, end = array.length) {
return array.slice(start, end);
}
- sortedIndex: 返回指定值在已排序数组中应该插入的索引
javascript
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.: 返回数组除了第一个元素的所有元素
javascript
function tail(array) {
return array.slice(1);
}
- take: 返回数组的前n个元素
javascript
function take(array, n = 1) {
return array.slice(0, n);
}
- union: 返回多个数组的并集
javascript
function union(...arrays) {
return Array.from(new Set([].concat(...arrays)));
}
- uniq: 返回数组中唯一的元素
javascript
function uniq(array) {
return Array.from(new Set(array));
}
- without: 返回数组中除了指定值之外的所有元素
javascript
function without(array, ...values) {
return array.filter(item => !values.includes(item));
}
- xor: 返回多个数组的异或集
javascript
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: 将多个数组按索引合并为一个数组
javascript
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: 根据指定条件对数组进行分组计数
javascript
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: 创建一个防抖函数,延迟执行指定的函数
javascript
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);
}
};
}