array.js

/**
 * wjs-js-toolkit - 数组处理工具函数库
 * 
 * 包含数组操作、转换、查找等常用功能
 * 
 * @module array
 * @memberof wjs-js-toolkit
 */

/**
 * 数组去重
 * @param {Array} arr - 原数组
 * @returns {Array} 去重后的数组
 * 
 * wjs created by 2015-09-01
 */
function wjs_unique(arr) {
  if (!Array.isArray(arr)) return []
  return [...new Set(arr)]
}

/**
 * 数组扁平化
 * @param {Array} arr - 原数组
 * @param {number} depth - 扁平化深度
 * @returns {Array} 扁平化后的数组
 * 
 * wjs created by 2015-09-10
 */
function wjs_flatten(arr, depth = 1) {
  if (!Array.isArray(arr)) return []
  if (depth === 0) return arr
  return arr.reduce((acc, item) => {
    return acc.concat(Array.isArray(item) ? wjs_flatten(item, depth - 1) : item)
  }, [])
}

/**
 * 数组扁平化（无限深度）
 * @param {Array} arr - 原数组
 * @returns {Array} 扁平化后的数组
 * 
 * wjs created by 2015-09-15
 */
function wjs_flattenDeep(arr) {
  return wjs_flatten(arr, Infinity)
}

/**
 * 按属性分组
 * @param {Array} arr - 原数组
 * @param {string|function} key - 分组键或函数
 * @returns {Object} 分组结果
 * 
 * wjs created by 2015-10-01
 */
function wjs_groupBy(arr, key) {
  if (!Array.isArray(arr)) return {}
  const fn = typeof key === 'function' ? key : item => item[key]
  return arr.reduce((acc, item) => {
    const groupKey = fn(item)
    if (!acc[groupKey]) acc[groupKey] = []
    acc[groupKey].push(item)
    return acc
  }, {})
}

/**
 * 按属性排序
 * @param {Array} arr - 原数组
 * @param {string} key - 排序键
 * @param {string} order - 排序顺序（asc/desc）
 * @returns {Array} 排序后的数组
 * 
 * wjs created by 2015-10-10
 */
function wjs_sortBy(arr, key, order = 'asc') {
  if (!Array.isArray(arr)) return []
  return [...arr].sort((a, b) => {
    const valA = a[key]
    const valB = b[key]
    if (valA < valB) return order === 'asc' ? -1 : 1
    if (valA > valB) return order === 'asc' ? 1 : -1
    return 0
  })
}

/**
 * 获取数组第一个元素
 * @param {Array} arr - 数组
 * @returns {*} 第一个元素
 * 
 * wjs created by 2015-11-01
 */
function wjs_first(arr) {
  return Array.isArray(arr) && arr.length > 0 ? arr[0] : undefined
}

/**
 * 获取数组最后一个元素
 * @param {Array} arr - 数组
 * @returns {*} 最后一个元素
 * 
 * wjs created by 2015-11-05
 */
function wjs_last(arr) {
  return Array.isArray(arr) && arr.length > 0 ? arr[arr.length - 1] : undefined
}

/**
 * 获取数组指定位置的元素
 * @param {Array} arr - 数组
 * @param {number} index - 索引
 * @returns {*} 指定位置的元素
 * 
 * wjs created by 2015-11-10
 */
function wjs_nth(arr, index) {
  if (!Array.isArray(arr)) return undefined
  if (index < 0) index = arr.length + index
  return arr[index]
}

/**
 * 数组切片
 * @param {Array} arr - 数组
 * @param {number} start - 开始索引
 * @param {number} end - 结束索引
 * @returns {Array} 切片后的数组
 * 
 * wjs created by 2015-11-15
 */
function wjs_slice(arr, start, end) {
  return Array.isArray(arr) ? arr.slice(start, end) : []
}

/**
 * 数组截取
 * @param {Array} arr - 数组
 * @param {number} start - 开始索引
 * @param {number} deleteCount - 删除数量
 * @param {...*} items - 插入元素
 * @returns {Array} 截取后的数组
 * 
 * wjs created by 2015-12-01
 */
function wjs_splice(arr, start, deleteCount, ...items) {
  if (!Array.isArray(arr)) return []
  const result = [...arr]
  result.splice(start, deleteCount, ...items)
  return result
}

/**
 * 数组拼接
 * @param {Array} arr1 - 第一个数组
 * @param {Array} arr2 - 第二个数组
 * @returns {Array} 拼接后的数组
 * 
 * wjs created by 2015-12-05
 */
function wjs_concat(arr1, arr2) {
  return [...(Array.isArray(arr1) ? arr1 : []), ...(Array.isArray(arr2) ? arr2 : [])]
}

/**
 * 数组反转
 * @param {Array} arr - 数组
 * @returns {Array} 反转后的数组
 * 
 * wjs created by 2015-12-10
 */
function wjs_reverse(arr) {
  return Array.isArray(arr) ? [...arr].reverse() : []
}

/**
 * 数组过滤
 * @param {Array} arr - 数组
 * @param {function} predicate - 过滤函数
 * @returns {Array} 过滤后的数组
 * 
 * wjs created by 2015-12-15
 */
function wjs_filter(arr, predicate) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return []
  return arr.filter(predicate)
}

/**
 * 数组映射
 * @param {Array} arr - 数组
 * @param {function} transform - 映射函数
 * @returns {Array} 映射后的数组
 * 
 * wjs created by 2016-01-01
 */
function wjs_map(arr, transform) {
  if (!Array.isArray(arr) || typeof transform !== 'function') return []
  return arr.map(transform)
}

/**
 * 数组归约
 * @param {Array} arr - 数组
 * @param {function} reducer - 归约函数
 * @param {*} initialValue - 初始值
 * @returns {*} 归约结果
 * 
 * wjs created by 2016-01-05
 */
function wjs_reduce(arr, reducer, initialValue) {
  if (!Array.isArray(arr) || typeof reducer !== 'function') return initialValue
  return arr.reduce(reducer, initialValue)
}

/**
 * 数组查找
 * @param {Array} arr - 数组
 * @param {function} predicate - 查找函数
 * @returns {*} 找到的元素
 * 
 * wjs created by 2016-01-10
 */
function wjs_find(arr, predicate) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return undefined
  return arr.find(predicate)
}

/**
 * 数组查找索引
 * @param {Array} arr - 数组
 * @param {function} predicate - 查找函数
 * @returns {number} 找到的索引
 * 
 * wjs created by 2016-01-15
 */
function wjs_findIndex(arr, predicate) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return -1
  return arr.findIndex(predicate)
}

/**
 * 判断数组是否包含指定元素
 * @param {Array} arr - 数组
 * @param {*} element - 元素
 * @returns {boolean} 是否包含
 * 
 * wjs created by 2016-02-01
 */
function wjs_includes(arr, element) {
  return Array.isArray(arr) && arr.includes(element)
}

/**
 * 获取元素在数组中的索引
 * @param {Array} arr - 数组
 * @param {*} element - 元素
 * @returns {number} 索引
 * 
 * wjs created by 2016-02-05
 */
function wjs_indexOf(arr, element) {
  return Array.isArray(arr) ? arr.indexOf(element) : -1
}

/**
 * 获取元素在数组中最后出现的索引
 * @param {Array} arr - 数组
 * @param {*} element - 元素
 * @returns {number} 索引
 * 
 * wjs created by 2016-02-10
 */
function wjs_lastIndexOf(arr, element) {
  return Array.isArray(arr) ? arr.lastIndexOf(element) : -1
}

/**
 * 判断数组是否为空
 * @param {Array} arr - 数组
 * @returns {boolean} 是否为空
 * 
 * wjs created by 2016-02-15
 */
function wjs_isEmpty(arr) {
  return !Array.isArray(arr) || arr.length === 0
}

/**
 * 获取数组长度
 * @param {Array} arr - 数组
 * @returns {number} 长度
 * 
 * wjs created by 2016-03-01
 */
function wjs_length(arr) {
  return Array.isArray(arr) ? arr.length : 0
}

/**
 * 数组填充
 * @param {*} value - 填充值
 * @param {number} length - 长度
 * @returns {Array} 填充后的数组
 * 
 * wjs created by 2016-03-05
 */
function wjs_fill(value, length) {
  return Array(length).fill(value)
}

/**
 * 数组填充（指定范围）
 * @param {Array} arr - 数组
 * @param {*} value - 填充值
 * @param {number} start - 开始索引
 * @param {number} end - 结束索引
 * @returns {Array} 填充后的数组
 * 
 * wjs created by 2016-03-10
 */
function wjs_fillRange(arr, value, start = 0, end) {
  if (!Array.isArray(arr)) return []
  const result = [...arr]
  result.fill(value, start, end)
  return result
}

/**
 * 数组遍历
 * @param {Array} arr - 数组
 * @param {function} callback - 回调函数
 * 
 * wjs created by 2016-03-15
 */
function wjs_forEach(arr, callback) {
  if (Array.isArray(arr) && typeof callback === 'function') {
    arr.forEach(callback)
  }
}

/**
 * 判断数组中所有元素是否满足条件
 * @param {Array} arr - 数组
 * @param {function} predicate - 判断函数
 * @returns {boolean} 是否全部满足
 * 
 * wjs created by 2016-04-01
 */
function wjs_every(arr, predicate) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return false
  return arr.every(predicate)
}

/**
 * 判断数组中是否有元素满足条件
 * @param {Array} arr - 数组
 * @param {function} predicate - 判断函数
 * @returns {boolean} 是否有元素满足
 * 
 * wjs created by 2016-04-05
 */
function wjs_some(arr, predicate) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return false
  return arr.some(predicate)
}

/**
 * 数组求和
 * @param {Array} arr - 数组
 * @returns {number} 和
 * 
 * wjs created by 2016-04-10
 */
function wjs_sum(arr) {
  if (!Array.isArray(arr)) return 0
  return arr.reduce((acc, val) => acc + (parseFloat(val) || 0), 0)
}

/**
 * 数组求平均值
 * @param {Array} arr - 数组
 * @returns {number} 平均值
 * 
 * wjs created by 2016-04-15
 */
function wjs_average(arr) {
  if (!Array.isArray(arr) || arr.length === 0) return 0
  return wjs_sum(arr) / arr.length
}

/**
 * 获取数组最大值
 * @param {Array} arr - 数组
 * @returns {number} 最大值
 * 
 * wjs created by 2016-05-01
 */
function wjs_max(arr) {
  if (!Array.isArray(arr) || arr.length === 0) return -Infinity
  return Math.max(...arr.map(val => parseFloat(val) || -Infinity))
}

/**
 * 获取数组最小值
 * @param {Array} arr - 数组
 * @returns {number} 最小值
 * 
 * wjs created by 2016-05-05
 */
function wjs_min(arr) {
  if (!Array.isArray(arr) || arr.length === 0) return Infinity
  return Math.min(...arr.map(val => parseFloat(val) || Infinity))
}

/**
 * 数组去重（根据对象属性）
 * @param {Array} arr - 数组
 * @param {string} key - 属性名
 * @returns {Array} 去重后的数组
 * 
 * wjs created by 2016-05-10
 */
function wjs_uniqueBy(arr, key) {
  if (!Array.isArray(arr)) return []
  const seen = new Set()
  return arr.filter(item => {
    const value = item[key]
    if (seen.has(value)) return false
    seen.add(value)
    return true
  })
}

/**
 * 数组交集
 * @param {Array} arr1 - 第一个数组
 * @param {Array} arr2 - 第二个数组
 * @returns {Array} 交集
 * 
 * wjs created by 2016-06-01
 */
function wjs_intersection(arr1, arr2) {
  if (!Array.isArray(arr1) || !Array.isArray(arr2)) return []
  const set2 = new Set(arr2)
  return [...new Set(arr1.filter(item => set2.has(item)))]
}

/**
 * 数组并集
 * @param {Array} arr1 - 第一个数组
 * @param {Array} arr2 - 第二个数组
 * @returns {Array} 并集
 * 
 * wjs created by 2016-06-05
 */
function wjs_union(arr1, arr2) {
  return wjs_unique([...(Array.isArray(arr1) ? arr1 : []), ...(Array.isArray(arr2) ? arr2 : [])])
}

/**
 * 数组差集
 * @param {Array} arr1 - 第一个数组
 * @param {Array} arr2 - 第二个数组
 * @returns {Array} 差集
 * 
 * wjs created by 2016-06-10
 */
function wjs_difference(arr1, arr2) {
  if (!Array.isArray(arr1) || !Array.isArray(arr2)) return []
  const set2 = new Set(arr2)
  return arr1.filter(item => !set2.has(item))
}

/**
 * 数组对称差集
 * @param {Array} arr1 - 第一个数组
 * @param {Array} arr2 - 第二个数组
 * @returns {Array} 对称差集
 * 
 * wjs created by 2016-06-15
 */
function wjs_symmetricDifference(arr1, arr2) {
  return wjs_union(wjs_difference(arr1, arr2), wjs_difference(arr2, arr1))
}

/**
 * 数组打乱顺序
 * @param {Array} arr - 数组
 * @returns {Array} 打乱后的数组
 * 
 * wjs created by 2016-07-01
 */
function wjs_shuffle(arr) {
  if (!Array.isArray(arr)) return []
  const result = [...arr]
  for (let i = result.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1))
    ;[result[i], result[j]] = [result[j], result[i]]
  }
  return result
}

/**
 * 数组分块
 * @param {Array} arr - 数组
 * @param {number} size - 块大小
 * @returns {Array} 分块后的数组
 * 
 * wjs created by 2016-07-10
 */
function wjs_chunk(arr, size) {
  if (!Array.isArray(arr)) return []
  const result = []
  for (let i = 0; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size))
  }
  return result
}

/**
 * 数组初始化
 * @param {number} length - 长度
 * @param {function} callback - 回调函数
 * @returns {Array} 初始化后的数组
 * 
 * wjs created by 2016-07-15
 */
function wjs_initArray(length, callback) {
  const result = []
  for (let i = 0; i < length; i++) {
    result.push(typeof callback === 'function' ? callback(i) : undefined)
  }
  return result
}

/**
 * 获取数组中指定数量的元素
 * @param {Array} arr - 数组
 * @param {number} count - 数量
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-08-01
 */
function wjs_take(arr, count) {
  if (!Array.isArray(arr)) return []
  return arr.slice(0, count)
}

/**
 * 获取数组中从指定位置开始的元素
 * @param {Array} arr - 数组
 * @param {number} start - 开始索引
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-08-05
 */
function wjs_drop(arr, start) {
  if (!Array.isArray(arr)) return []
  return arr.slice(start)
}

/**
 * 获取数组中除最后一个元素外的所有元素
 * @param {Array} arr - 数组
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-08-10
 */
function wjs_initial(arr) {
  if (!Array.isArray(arr)) return []
  return arr.slice(0, -1)
}

/**
 * 数组插入元素
 * @param {Array} arr - 数组
 * @param {number} index - 插入位置
 * @param {...*} items - 插入元素
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-09-01
 */
function wjs_insert(arr, index, ...items) {
  if (!Array.isArray(arr)) return []
  const result = [...arr]
  result.splice(index, 0, ...items)
  return result
}

/**
 * 数组移除指定索引的元素
 * @param {Array} arr - 数组
 * @param {number} index - 索引
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-09-05
 */
function wjs_removeAt(arr, index) {
  if (!Array.isArray(arr)) return []
  return arr.filter((_, i) => i !== index)
}

/**
 * 数组移除指定元素
 * @param {Array} arr - 数组
 * @param {*} element - 元素
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-09-10
 */
function wjs_remove(arr, element) {
  if (!Array.isArray(arr)) return []
  return arr.filter(item => item !== element)
}

/**
 * 数组移除满足条件的元素
 * @param {Array} arr - 数组
 * @param {function} predicate - 判断函数
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-09-15
 */
function wjs_removeIf(arr, predicate) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return []
  return arr.filter(item => !predicate(item))
}

/**
 * 数组更新指定索引的元素
 * @param {Array} arr - 数组
 * @param {number} index - 索引
 * @param {*} value - 新值
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-10-01
 */
function wjs_updateAt(arr, index, value) {
  if (!Array.isArray(arr)) return []
  const result = [...arr]
  result[index] = value
  return result
}

/**
 * 数组查找并更新元素
 * @param {Array} arr - 数组
 * @param {function} predicate - 判断函数
 * @param {*} value - 新值
 * @returns {Array} 结果数组
 * 
 * wjs created by 2016-10-05
 */
function wjs_findAndUpdate(arr, predicate, value) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return []
  return arr.map(item => predicate(item) ? value : item)
}

/**
 * 数组转换为对象
 * @param {Array} arr - 数组
 * @param {string|function} key - 键
 * @param {string|function} value - 值
 * @returns {Object} 结果对象
 * 
 * wjs created by 2017-01-01
 */
function wjs_arrayToObject(arr, key, value) {
  if (!Array.isArray(arr)) return {}
  const keyFn = typeof key === 'function' ? key : item => item[key]
  const valueFn = typeof value === 'function' ? value : item => item[value]
  return arr.reduce((acc, item) => {
    acc[keyFn(item)] = valueFn ? valueFn(item) : item
    return acc
  }, {})
}

/**
 * 对象转换为数组
 * @param {Object} obj - 对象
 * @returns {Array} 结果数组
 * 
 * wjs created by 2017-01-05
 */
function wjs_objectToArray(obj) {
  if (typeof obj !== 'object' || obj === null) return []
  return Object.keys(obj).map(key => ({ key, value: obj[key] }))
}

/**
 * 数组按属性提取
 * @param {Array} arr - 数组
 * @param {string} key - 属性名
 * @returns {Array} 结果数组
 * 
 * wjs created by 2017-02-01
 */
function wjs_pluck(arr, key) {
  if (!Array.isArray(arr)) return []
  return arr.map(item => item[key])
}

/**
 * 数组按属性提取并去重
 * @param {Array} arr - 数组
 * @param {string} key - 属性名
 * @returns {Array} 结果数组
 * 
 * wjs created by 2017-02-05
 */
function wjs_pluckUnique(arr, key) {
  return wjs_unique(wjs_pluck(arr, key))
}

/**
 * 数组分组并统计数量
 * @param {Array} arr - 数组
 * @param {string|function} key - 分组键
 * @returns {Object} 统计结果
 * 
 * wjs created by 2017-03-01
 */
function wjs_countBy(arr, key) {
  if (!Array.isArray(arr)) return {}
  const fn = typeof key === 'function' ? key : item => item[key]
  return arr.reduce((acc, item) => {
    const groupKey = fn(item)
    acc[groupKey] = (acc[groupKey] || 0) + 1
    return acc
  }, {})
}

/**
 * 数组按属性排序（数字）
 * @param {Array} arr - 数组
 * @param {string} key - 属性名
 * @param {string} order - 排序顺序
 * @returns {Array} 排序后的数组
 * 
 * wjs created by 2017-04-01
 */
function wjs_sortByNumber(arr, key, order = 'asc') {
  if (!Array.isArray(arr)) return []
  return [...arr].sort((a, b) => {
    const valA = parseFloat(a[key]) || 0
    const valB = parseFloat(b[key]) || 0
    return order === 'asc' ? valA - valB : valB - valA
  })
}

/**
 * 数组按属性排序（日期）
 * @param {Array} arr - 数组
 * @param {string} key - 属性名
 * @param {string} order - 排序顺序
 * @returns {Array} 排序后的数组
 * 
 * wjs created by 2017-05-01
 */
function wjs_sortByDate(arr, key, order = 'asc') {
  if (!Array.isArray(arr)) return []
  return [...arr].sort((a, b) => {
    const valA = new Date(a[key]).getTime()
    const valB = new Date(b[key]).getTime()
    return order === 'asc' ? valA - valB : valB - valA
  })
}

/**
 * 数组分页
 * @param {Array} arr - 数组
 * @param {number} page - 当前页
 * @param {number} pageSize - 每页大小
 * @returns {Object} 分页结果
 * 
 * wjs created by 2018-01-01
 */
function wjs_paginate(arr, page = 1, pageSize = 10) {
  if (!Array.isArray(arr)) return { list: [], total: 0, page, pageSize, totalPages: 0 }
  const total = arr.length
  const totalPages = Math.ceil(total / pageSize)
  const start = (page - 1) * pageSize
  const end = start + pageSize
  return {
    list: arr.slice(start, end),
    total,
    page,
    pageSize,
    totalPages
  }
}

/**
 * 数组批量更新
 * @param {Array} arr - 数组
 * @param {function} predicate - 判断函数
 * @param {function} updater - 更新函数
 * @returns {Array} 结果数组
 * 
 * wjs created by 2018-03-01
 */
function wjs_updateIf(arr, predicate, updater) {
  if (!Array.isArray(arr) || typeof predicate !== 'function' || typeof updater !== 'function') return []
  return arr.map(item => predicate(item) ? updater(item) : item)
}

/**
 * 数组分组并转换为数组
 * @param {Array} arr - 数组
 * @param {string|function} key - 分组键
 * @returns {Array} 分组结果数组
 * 
 * wjs created by 2018-05-01
 */
function wjs_groupByToArray(arr, key) {
  const groups = wjs_groupBy(arr, key)
  return Object.keys(groups).map(groupKey => ({
    key: groupKey,
    items: groups[groupKey]
  }))
}

/**
 * 数组获取唯一值的统计信息
 * @param {Array} arr - 数组
 * @returns {Object} 统计信息
 * 
 * wjs created by 2019-01-01
 */
function wjs_uniqueStats(arr) {
  if (!Array.isArray(arr)) return { unique: [], counts: {}, total: 0 }
  const counts = {}
  arr.forEach(item => {
    counts[item] = (counts[item] || 0) + 1
  })
  return {
    unique: Object.keys(counts),
    counts,
    total: arr.length
  }
}

/**
 * 数组合并多个数组
 * @param {...Array} arrs - 多个数组
 * @returns {Array} 合并后的数组
 * 
 * wjs created by 2020-01-01
 */
function wjs_merge(...arrs) {
  return arrs.reduce((acc, arr) => acc.concat(Array.isArray(arr) ? arr : []), [])
}

/**
 * 数组获取随机元素
 * @param {Array} arr - 数组
 * @returns {*} 随机元素
 * 
 * wjs created by 2021-01-01
 */
function wjs_randomElement(arr) {
  if (!Array.isArray(arr) || arr.length === 0) return undefined
  return arr[Math.floor(Math.random() * arr.length)]
}

/**
 * 数组获取多个随机元素
 * @param {Array} arr - 数组
 * @param {number} count - 数量
 * @returns {Array} 随机元素数组
 * 
 * wjs created by 2022-01-01
 */
function wjs_randomElements(arr, count) {
  if (!Array.isArray(arr) || arr.length === 0) return []
  const shuffled = wjs_shuffle(arr)
  return shuffled.slice(0, Math.min(count, arr.length))
}

/**
 * 数组按指定条件拆分
 * @param {Array} arr - 数组
 * @param {function} predicate - 判断函数
 * @returns {Object} 拆分结果
 * 
 * wjs created by 2023-01-01
 */
function wjs_partition(arr, predicate) {
  if (!Array.isArray(arr) || typeof predicate !== 'function') return { pass: [], fail: [] }
  return arr.reduce((acc, item) => {
    if (predicate(item)) {
      acc.pass.push(item)
    } else {
      acc.fail.push(item)
    }
    return acc
  }, { pass: [], fail: [] })
}

/**
 * 数组获取指定范围的元素
 * @param {Array} arr - 数组
 * @param {number} start - 开始索引
 * @param {number} end - 结束索引
 * @returns {Array} 结果数组
 * 
 * wjs created by 2024-01-01
 */
function wjs_range(arr, start, end) {
  if (!Array.isArray(arr)) return []
  return arr.slice(start, end + 1)
}

/**
 * 数组判断是否包含所有指定元素
 * @param {Array} arr - 数组
 * @param {Array} elements - 元素数组
 * @returns {boolean} 是否包含所有元素
 * 
 * wjs created by 2025-01-01
 */
function wjs_includesAll(arr, elements) {
  if (!Array.isArray(arr) || !Array.isArray(elements)) return false
  return elements.every(element => arr.includes(element))
}

/**
 * 数组判断是否包含任一指定元素
 * @param {Array} arr - 数组
 * @param {Array} elements - 元素数组
 * @returns {boolean} 是否包含任一元素
 * 
 * wjs created by 2026-01-01
 */
function wjs_includesAny(arr, elements) {
  if (!Array.isArray(arr) || !Array.isArray(elements)) return false
  return elements.some(element => arr.includes(element))
}

// ============================================================
// 导出模块
// ============================================================
if (typeof module !== 'undefined' && module.exports) {
  module.exports = {
    wjs_unique,
    wjs_flatten,
    wjs_flattenDeep,
    wjs_groupBy,
    wjs_sortBy,
    wjs_first,
    wjs_last,
    wjs_nth,
    wjs_slice,
    wjs_splice,
    wjs_concat,
    wjs_reverse,
    wjs_filter,
    wjs_map,
    wjs_reduce,
    wjs_find,
    wjs_findIndex,
    wjs_includes,
    wjs_indexOf,
    wjs_lastIndexOf,
    wjs_isEmpty,
    wjs_length,
    wjs_fill,
    wjs_fillRange,
    wjs_forEach,
    wjs_every,
    wjs_some,
    wjs_sum,
    wjs_average,
    wjs_max,
    wjs_min,
    wjs_uniqueBy,
    wjs_intersection,
    wjs_union,
    wjs_difference,
    wjs_symmetricDifference,
    wjs_shuffle,
    wjs_chunk,
    wjs_initArray,
    wjs_take,
    wjs_drop,
    wjs_initial,
    wjs_insert,
    wjs_removeAt,
    wjs_remove,
    wjs_removeIf,
    wjs_updateAt,
    wjs_findAndUpdate,
    wjs_arrayToObject,
    wjs_objectToArray,
    wjs_pluck,
    wjs_pluckUnique,
    wjs_countBy,
    wjs_sortByNumber,
    wjs_sortByDate,
    wjs_paginate,
    wjs_updateIf,
    wjs_groupByToArray,
    wjs_uniqueStats,
    wjs_merge,
    wjs_randomElement,
    wjs_randomElements,
    wjs_partition,
    wjs_range,
    wjs_includesAll,
    wjs_includesAny
  }
}