30个常用的lodash工具函数

1. 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;
}

2. compact: 过滤数组中的假值（false、null、0、""、undefined 和 NaN）

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

3. concat: 合并多个数组

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

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

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

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

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

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

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

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

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

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

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

9. flatten: 扁平化数组

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

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

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

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

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

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

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

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

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

14. 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);
}

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

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

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

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

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

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

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

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

19. reverse: 反转数组的顺序

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

20. slice: 返回数组的指定部分

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

21. 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);
}

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

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

24. union: 返回多个数组的并集

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

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

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

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

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

27. 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);
}

28. 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;
}

29. 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;
}

30. 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);
    }
  };
}