data-utils-grok/src/arrayUtils.js

A comprehensive JavaScript utility library for data processing, organized by data types (arrays, objects, strings, forms, tables)

// src/arrayUtils.js
/**
 * 数组类型处理工具函数
 */

/**
 * 数组去重
 * @param {Array} arr - 输入数组
 * @param {string} [key] - 可选的对象键，用于对象数组去重
 * @returns {Array} 去重后的数组
 */
function uniqueArray(arr, key) {
  if (!Array.isArray(arr)) {
    throw new TypeError('Input must be an array');
  }
  if (key) {
    const seen = new Set();
    return arr.filter(item => {
      const value = item[key];
      if (seen.has(value)) return false;
      seen.add(value);
      return true;
    });
  }
  return [...new Set(arr)];
}

/**
 * 按条件过滤数组
 * @param {Array} arr - 输入数组
 * @param {Function} callback - 过滤函数
 * @returns {Array} 过滤后的数组
 */
function filterArray(arr, callback) {
  if (!Array.isArray(arr)) {
    throw new TypeError('Input must be an array');
  }
  return arr.filter(callback);
}

/**
 * 按键分组
 * @param {Array} arr - 输入数组
 * @param {string|Function} key - 分组键或函数
 * @returns {Object} 分组后的对象
 */
function groupBy(arr, key) {
  if (!Array.isArray(arr)) {
    throw new TypeError('Input must be an array');
  }
  return arr.reduce((result, item) => {
    const groupKey = typeof key === 'function' ? key(item) : item[key];
    result[groupKey] = result[groupKey] || [];
    result[groupKey].push(item);
    return result;
  }, {});
}

/**
 * 按键排序
 * @param {Array} arr - 输入数组
 * @param {string} key - 排序键
 * @param {boolean} [ascending=true] - 是否升序
 * @returns {Array} 排序后的数组
 */
function sortBy(arr, key, ascending = true) {
  if (!Array.isArray(arr)) {
    throw new TypeError('Input must be an array');
  }
  return [...arr].sort((a, b) => {
    const valueA = a[key];
    const valueB = b[key];
    if (valueA < valueB) return ascending ? -1 : 1;
    if (valueA > valueB) return ascending ? 1 : -1;
    return 0;
  });
}

/**
 * 计算数组的统计信息（仅限数值数组）
 * @param {Array<number>} arr - 输入数值数组
 * @returns {Object} 统计结果 { sum, average, min, max }
 */
function stats(arr) {
  if (!Array.isArray(arr) || !arr.every(item => typeof item === 'number')) {
    throw new TypeError('Input must be an array of numbers');
  }
  if (arr.length === 0) return { sum: 0, average: 0, min: null, max: null };
  const sum = arr.reduce((acc, val) => acc + val, 0);
  const min = Math.min(...arr);
  const max = Math.max(...arr);
  return {
    sum,
    average: sum / arr.length,
    min,
    max,
  };
}

/**
 * 数组分块
 * @param {Array} arr - 输入数组
 * @param {number} size - 每块的大小
 * @returns {Array} 分块后的二维数组
 */
function chunk(arr, size) {
  if (!Array.isArray(arr)) {
    throw new TypeError('Input must be an array');
  }
  if (size <= 0) {
    throw new TypeError('Size must be positive');
  }
  const result = [];
  for (let i = 0; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size));
  }
  return result;
}

/**
 * 数组扁平化
 * @param {Array} arr - 输入数组
 * @param {number} [depth=1] - 扁平化深度
 * @returns {Array} 扁平化后的数组
 */
function flatten(arr, depth = 1) {
  if (!Array.isArray(arr)) {
    throw new TypeError('Input must be an array');
  }
  if (depth <= 0) return arr;
  return arr.reduce((result, item) => {
    if (Array.isArray(item) && depth > 0) {
      result.push(...flatten(item, depth - 1));
    } else {
      result.push(item);
    }
    return result;
  }, []);
}

module.exports = {
  uniqueArray,
  filterArray,
  groupBy,
  sortBy,
  stats,
  chunk,
  flatten,
};