1. Toy模板网首页
  2. > Toy博客

lodash已死？radash最全使用介绍（附源码说明）—— Array方法篇（4）

5月前 作者：雾散声声慢 分类：Toy博客 阅读(30) 违法举报

这篇具有很好参考价值的文章主要介绍了lodash已死？radash最全使用介绍（附源码说明）—— Array方法篇（4）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

写在前面

tips：点赞 + 收藏 = 学会！

  • 我们已经介绍了radash的相关信息和部分Array相关方法，详情可前往主页查看。
  • 本篇我们继续介绍radash中Array的相关方法的剩余方法。
  • 本期文章发布后，作者也会同步整理出Array方法的使用目录，包括文章说明和脑图说明。
    • 因为方法较多，后续将专门发布一篇Array篇总结文档，方便大家查阅使用。

replace ：查找指定项，并用传入的去替换；

  1. 使用说明
    • 参数：对象数组1、用于替换的对象、条件函数。
    • 返回值：替换目标项后的原始素组副本（新数组）。
  2. 使用代码示例
    import { replace } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105
  },
  {
    name: 'Bass',
    weight: 8
  },
  {
    name: 'Trout',
    weight: 13
  }
]

const salmon = {
  name: 'Salmon',
  weight: 22
}

// read: replace fish with salmon where the name is Bass
replace(fish, salmon, f => f.name === 'Bass') // => [marlin, salmon, trout]
  3. 源码解析
    // 定义一个泛型函数 `replace`。
export const replace = <T>(
  // 第一个参数是一个具有只读属性的泛型数组 `list`。
  list: readonly T[],
  // 第二个参数是一个新元素 `newItem`，它将用来替换数组中的一个现有元素。
  newItem: T,
  // 第三个参数是一个 `match` 函数，它接受一个数组元素和它的索引，
  // 返回一个布尔值来指示是否找到了要被替换的元素。
  match: (item: T, idx: number) => boolean
): T[] => {
  // 如果传入的数组 `list` 不存在，则返回一个空数组。
  if (!list) return []
  // 如果新元素 `newItem` 是未定义的，则返回 `list` 数组的副本。
  if (newItem === undefined) return [...list]
  // 遍历 `list` 数组，寻找一个匹配的元素。
  for (let idx = 0; idx < list.length; idx++) {
    const item = list[idx]
    // 使用 `match` 函数检查当前元素 `item` 是否是要被替换的元素。
    if (match(item, idx)) {
      // 如果找到匹配的元素，创建并返回一个新数组，该数组是通过以下方式构建的：
      // 1. `list` 的开始到匹配位置之前的部分（不包括匹配位置）。
      // 2. 新元素 `newItem`。
      // 3. 匹配位置之后的 `list` 的剩余部分。
      return [
        ...list.slice(0, idx),
        newItem,
        ...list.slice(idx + 1, list.length)
      ]
    }
  }
  // 如果没有找到匹配的元素，返回 `list` 数组的副本。
  return [...list]
}
    • 方法流程说明：
      1. 检查 list 是否存在。如果不存在，返回一个空数组。
      2. 检查 newItem 是否是未定义的。如果是，返回 list 的副本。
      3. 遍历 list 数组。对于每个元素，使用 match 函数检查该元素是否是要被替换的元素。
      4. 如果 match 函数返回 true，则在该位置用 newItem 替换现有元素，并返回新构建的数组。
      5. 如果遍历结束后没有任何元素匹配，返回 list 的副本。
      6. 注意：这个 replace 函数可以用于更新数组中的元素，而不改变原始数组，因为它总是返回一个新的数组。

select ：对数组同时进行过滤和映射，筛选和转换数组中的元素；

  1. 使用说明
    • 参数：对象数组、映射条件函数、过滤条件函数。
    • 返回值：过滤完后的映射值组成的数组。
  2. 使用代码示例
    import { select } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105,
    source: 'ocean'
  },
  {
    name: 'Bass',
    weight: 8,
    source: 'lake'
  },
  {
    name: 'Trout',
    weight: 13,
    source: 'lake'
  }
]

select(
  fish,
  f => f.weight,
  f => f.source === 'lake'
) // => [8, 13]
  3. 源码解析
    // 定义一个泛型函数 `select`。
export const select = <T, K>(
  // 第一个参数是一个具有只读属性的泛型数组 `array`。
  array: readonly T[],
  // 第二个参数是一个 `mapper` 函数，它接受一个数组元素和它的索引，
  // 返回一个新类型 `K` 的值。
  mapper: (item: T, index: number) => K,
  // 第三个参数是一个 `condition` 函数，它也接受一个数组元素和它的索引，
  // 返回一个布尔值来指示元素是否满足选择条件。
  condition: (item: T, index: number) => boolean
) => {
  // 如果传入的数组 `array` 不存在，则返回一个空数组。
  if (!array) return []
  // 使用数组的 `reduce` 方法来构建一个新数组，该数组仅包含满足 `condition` 的元素，
  // 并且这些元素已经通过 `mapper` 函数转换。
  return array.reduce((acc, item, index) => {
    // 使用 `condition` 函数检查当前元素 `item` 是否满足条件。
    if (!condition(item, index)) return acc
    // 如果元素满足条件，则使用 `mapper` 函数对其进行转换，并将结果添加到累加器 `acc`。
    acc.push(mapper(item, index))
    // 返回更新后的累加器 `acc`。
    return acc
  }, [] as K[]) // 初始化累加器 `acc` 为一个空数组。
}
    • 方法流程说明：
      1. 检查 array 是否存在。如果不存在，返回一个空数组。
      2. 使用 reduce 方法遍历 array 数组。reduce 方法的累加器 acc 是一个新数组，用于存储转换后的元素。
      3. 对于数组中的每个元素，使用 condition 函数检查该元素是否满足选择条件。
      4. 如果 condition 函数返回 true，则使用 mapper 函数对该元素进行转换，并将转换后的结果添加到累加器 acc 中。
      5. 继续处理数组的下一个元素，直到所有元素都被处理完毕。
      6. 返回累加器 acc，它现在是一个包含所有已转换且满足条件的元素的新数组。
      7. 这个 select 函数可以用于在不改变原始数组的情况下，筛选和转换数组中的元素。

shift ：把目标数组向右循环移动 n 个位置返回为一个新数组；

  1. 使用说明
    • 参数：目标数组、移动步数。
    • 返回值：移动后的新数组。
  2. 使用代码示例
    import { shift } from 'radash'
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
shift(arr, 3) // => [7, 8, 9, 1, 2, 3, 4, 5, 6]
  3. 源码解析
    // 定义一个泛型函数 `select`。
export const select = <T, K>(
  // 第一个参数是一个具有只读属性的泛型数组 `array`。
  array: readonly T[],
  // 第二个参数是一个 `mapper` 函数，它接受一个数组元素和它的索引，
  // 返回一个新类型 `K` 的值。
  mapper: (item: T, index: number) => K,
  // 第三个参数是一个 `condition` 函数，它也接受一个数组元素和它的索引，
  // 返回一个布尔值来指示元素是否满足选择条件。
  condition: (item: T, index: number) => boolean
) => {
  // 如果传入的数组 `array` 不存在，则返回一个空数组。
  if (!array) return []
  // 使用数组的 `reduce` 方法来构建一个新数组，该数组仅包含满足 `condition` 的元素，
  // 并且这些元素已经通过 `mapper` 函数转换。
  return array.reduce((acc, item, index) => {
    // 使用 `condition` 函数检查当前元素 `item` 是否满足条件。
    if (!condition(item, index)) return acc
    // 如果元素满足条件，则使用 `mapper` 函数对其进行转换，并将结果添加到累加器 `acc`。
    acc.push(mapper(item, index))
    // 返回更新后的累加器 `acc`。
    return acc
  }, [] as K[]) // 初始化累加器 `acc` 为一个空数组。
}
    • 方法流程说明：
      1. 检查 array 是否存在。如果不存在，返回一个空数组。
      2. 使用 reduce 方法遍历 array 数组。reduce 方法的累加器 acc 是一个新数组，用于存储转换后的元素。
      3. 对于数组中的每个元素，使用 condition 函数检查该元素是否满足选择条件。
      4. 如果 condition 函数返回 true，则使用 mapper 函数对该元素进行转换，并将转换后的结果添加到累加器 acc 中。
      5. 继续处理数组的下一个元素，直到所有元素都被处理完毕。
      6. 返回累加器 acc，它现在是一个包含所有已转换且满足条件的元素的新数组。
      7. 这个 select 函数可以用于在不改变原始数组的情况下，筛选和转换数组中的元素。

sift：过滤调列表中值为false的项，返回剩余为true的项组成的数组；

  1. 使用说明
    • 参数：数组。
    • 返回值：过滤后的新数组。
  2. 使用代码示例
    import { sift } from 'radash'

const fish = ['salmon', null, false, NaN, 'sockeye', 'bass']

sift(fish) // => ['salmon', 'sockeye', 'bass']
  3. 源码解析
    // 定义一个泛型函数 `sift`，它接收一个参数 `list`，这是一个包含泛型 `T` 或假值的只读数组。
export const sift = <T>(list: readonly (T | Falsy)[]): T[] => {
  // 使用 `filter` 方法遍历数组 `list`，移除所有假值。
  // `x => !!x` 是一个函数，它将每个元素强制转换为布尔值，然后再次强制转换回来，
  // 以确保只有真值（Truthy values）被保留。
  // `as T[]` 是一个类型断言，它告诉 TypeScript 编译器过滤后的数组只包含类型 `T` 的元素。
  return (list?.filter(x => !!x) as T[]) ?? []
}
    • 方法流程说明：
      1. 检查 list 是否存在。如果不存在，返回一个空数组 []。
      2. 使用 filter 方法遍历数组 list，对于每个元素 x，使用 !!x 将它转换为一个布尔值。这样做的结果是，如果 x 是一个假值（如 false、0、""、null、undefined 或 NaN），它将被转换为 false，如果 x 是一个真值，它将被转换为 true。
      3. filter 方法根据这个布尔值决定是否保留元素。只有那些转换为 true 的元素会被保留在新数组中。
      4. 使用类型断言 as T[] 告诉 TypeScript 编译器，经过过滤后的数组将只包含类型 T 的元素。
      5. 如果 list 是 null 或 undefined，list?.filter(x => !!x) 将产生 undefined。这时，通过使用空值合并运算符 ??，函数将返回一个空数组 []。
      6. 最终返回过滤后的数组，其中仅包含真值元素。

sort ：把数组按照条件函数指定的项的数值大小排序，支持升序和降序；

  1. 使用说明
    • 参数：对象数组、指定标识符的条件函数、是否降序（Boolean值，不传为false）。
    • 返回值：排序后的数组。
  2. 使用代码示例
    import { sort } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105
  },
  {
    name: 'Bass',
    weight: 8
  },
  {
    name: 'Trout',
    weight: 13
  }
]

sort(fish, f => f.weight) // => [bass, trout, marlin]
sort(fish, f => f.weight, true) // => [marlin, trout, bass]
  3. 源码解析
    // 定义一个泛型函数 `sort`。
export const sort = <T>(
  // 第一个参数 `array` 是一个具有只读属性的泛型数组。
  array: readonly T[],
  // 第二个参数 `getter` 是一个函数，它从每个数组元素中提取一个数字，用于比较大小。
  getter: (item: T) => number,
  // 第三个参数 `desc` 是一个布尔值，指定排序方向。默认为 `false`，表示升序排序。
  desc = false
) => {
  // 如果传入的数组 `array` 不存在，则返回一个空数组。
  if (!array) return []
  // 定义一个升序比较函数 `asc`，它使用 `getter` 函数的返回值进行比较。
  const asc = (a: T, b: T) => getter(a) - getter(b)
  // 定义一个降序比较函数 `dsc`，它也使用 `getter` 函数的返回值进行比较，但顺序相反。
  const dsc = (a: T, b: T) => getter(b) - getter(a)
  // 使用数组的 `slice` 方法创建数组的一个副本，然后使用 `sort` 方法对这个副本进行排序。
  // 根据 `desc` 参数的值选择使用 `dsc` 或 `asc` 比较函数。
  return array.slice().sort(desc === true ? dsc : asc)
}
    • 方法流程说明：
      1. 检查 array 是否存在。如果不存在，返回一个空数组。
      2. 定义两个比较函数，asc 用于升序排序，dsc 用于降序排序。这两个函数都使用 getter 函数从元素中提取比较值。
      3. 使用 slice 方法创建数组的一个浅副本，以避免修改原始数组。
      4. 使用 sort 方法对数组副本进行排序。sort 方法接受一个比较函数，该函数根据 desc 参数的值决定使用 asc 还是 dsc。
      5. 返回排序后的数组副本。

sum：数组对象根据条件函数指定想的数组求和；

  1. 使用说明

    • 参数：对象数组、指定标识符的条件函数。
    • 返回值：符合条件的项的和。

  2. 使用代码示例

    import { sum } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 100
  },
  {
    name: 'Bass',
    weight: 10
  },
  {
    name: 'Trout',
    weight: 15
  }
]

sum(fish, f => f.weight) // => 125

  3. 源码解析

    // 这是 `sum` 函数的第一种声明，用于处理数组直接包含数字的情况。
export function sum<T extends number>(array: readonly T[]): number

// 这是 `sum` 函数的第二种声明，用于处理数组包含对象的情况。
// 需要一个额外的函数 `fn` 来从每个对象中提取数值。
export function sum<T extends object>(
  array: readonly T[],
  fn: (item: T) => number
): number

// 这是 `sum` 函数的实现，它可以处理上述两种情况。
export function sum<T extends object | number>(
  array: readonly any[],
  fn?: (item: T) => number
): number {
  // 使用数组的 `reduce` 方法来累积所有元素的总和。
  // 如果数组不存在，使用空数组 `[]` 作为默认值。
  // `reduce` 的回调函数将累加器 `acc` 和当前元素 `item` 相加。
  // 如果提供了函数 `fn`，则使用 `fn(item)` 获取数值；如果没有提供 `fn`，则直接使用 `item`。
  return (array || []).reduce((acc, item) => acc + (fn ? fn(item) : item), 0)
}
    • 方法流程说明：
      1. 检查 array 是否存在。如果不存在，使用空数组 [] 作为默认值。
      2. 使用 reduce 方法遍历数组。reduce 方法的累加器 acc 初始化为0。
      3. 对于数组中的每个元素 item，如果提供了函数 fn，则调用 fn(item) 来获取元素的数值；如果没有提供 fn，则直接使用 item 作为数值。
      4. 将每个元素的数值累加到 acc 上。
      5. 返回累加器 acc 的最终值，即数组中所有元素的总和。

toggle：查找数组中是否有我们给定的项，有则删除，没有则添加；

  1. 使用说明
    • 参数：目标数组、条件值（可以是条件函数）、在前面添加还是在后边添加。
    • 返回值：处理后的新数组。
  2. 使用代码示例
    import { toggle } from 'radash'

// 基本用法
const gods = ['ra', 'zeus', 'loki']

toggle(gods, 'ra')     // => [zeus, loki]
toggle(gods, 'vishnu') // => [ra, zeus, loki, vishnu]


// 切换（数组、条件项、指定标识符的条件函数）
import { toggle } from 'radash'

const ra = { name: 'Ra' }
const zeus = { name: 'Zeus' }
const loki = { name: 'Loki' }
const vishnu = { name: 'Vishnu' }

const gods = [ra, zeus, loki]

toggle(gods, ra, g => g.name)     // => [zeus, loki]
toggle(gods, vishnu, g => g.name) // => [ra, zeus, loki, vishnu]


// 切换（数组、条件项、条件函数，覆盖项）
import { toggle } from 'radash'

const gods = ['ra', 'zeus', 'loki']

toggle(gods, 'vishnu', g => g, { strategy: 'prepend' }) // => [vishnu, ra, zeus, loki]
  3. 源码解析
    // 定义一个泛型函数 `toggle`。
export const toggle = <T>(
  // 第一个参数 `list` 是一个具有只读属性的泛型数组。
  list: readonly T[],
  // 第二个参数 `item` 是一个类型为 `T` 的元素，它将被切换（添加或移除）。
  item: T,
  // 第三个可选参数 `toKey` 是一个函数，用于将元素转换为可比较的键。
  toKey?: null | ((item: T, idx: number) => number | string | symbol),
  // 第四个可选参数 `options` 是一个对象，允许指定添加元素的策略（追加或前置）。
  options?: {
    strategy?: 'prepend' | 'append'
  }
) => {
  // 如果 `list` 和 `item` 都不存在或为空，则返回一个空数组。
  if (!list && !item) return []
  // 如果 `list` 不存在或为空，返回一个只包含 `item` 的数组。
  if (!list) return [item]
  // 如果 `item` 不存在或为空，返回 `list` 数组的副本。
  if (!item) return [...list]
  // 定义一个 `matcher` 函数，用于检查元素是否与 `item` 匹配。
  // 如果提供了 `toKey` 函数，则使用它来获取比较的键；如果没有，则直接比较元素。
  const matcher = toKey
    ? (x: T, idx: number) => toKey(x, idx) === toKey(item, idx)
    : (x: T) => x === item
  // 使用 `find` 方法检查 `list` 中是否存在与 `item` 匹配的元素。
  const existing = list.find(matcher)
  // 如果存在匹配的元素，使用 `filter` 方法移除它。
  if (existing) return list.filter((x, idx) => !matcher(x, idx))
  // 根据 `options` 中的 `strategy` 决定是追加还是前置新元素。
  const strategy = options?.strategy ?? 'append'
  // 如果策略是 'append'，将 `item` 追加到 `list` 的末尾。
  if (strategy === 'append') return [...list, item]
  // 否则，将 `item` 前置到 `list` 的开头。
  return [item, ...list]
}
    • 方法流程说明：
      1. 进行一系列的检查，如果 list 和 item 都不存在或为空，或者只有 list 不存在或为空，或者只有 item 不存在或为空，则返回相应的结果。
      2. 定义 matcher 函数，用于检查元素是否与 item 匹配。如果存在 toKey 函数，则使用它来比较转换后的键。
      3. 检查 list 中是否存在与 item 匹配的元素。
      4. 如果存在匹配的元素，使用 filter 方法创建一个新数组，其中不包含匹配的元素。
      5. 如果不存在匹配的元素，根据 options 中的 strategy 决定是将 item 追加到数组末尾还是添加到数组开头，并返回新数组。

unique：数组去重，去除数组中重复的项；

  1. 使用说明

    • 参数：目标数组、指定唯一标识符的条件函数。
    • 返回值：去重后的数组。

  2. 使用代码示例

    import { unique } from 'radash'

const fish = [
  {
    name: 'Marlin',
    weight: 105,
    source: 'ocean'
  },
  {
    name: 'Salmon',
    weight: 22,
    source: 'river'
  },
  {
    name: 'Salmon',
    weight: 22,
    source: 'river'
  }
]

unique( fish, f => f.name )
// [
//     { name: 'Marlin', weight: 105, source: 'ocean' },
//     { name: 'Salmon', weight: 22, source: 'river' }
// ]
``

  3. 源码解析

    // 定义一个泛型函数 `unique`。
export const unique = <T, K extends string | number | symbol>(
  // 第一个参数 `array` 是一个具有只读属性的泛型数组。
  array: readonly T[],
  // 第二个可选参数 `toKey` 是一个函数，用于将数组元素转换为可比较的键。
  toKey?: (item: T) => K
): T[] => {
  // 使用数组的 `reduce` 方法来构建一个记录对象 `valueMap`，该对象的键是元素的键，值是元素本身。
  const valueMap = array.reduce((acc, item) => {
    // 使用 `toKey` 函数获取元素的键。如果 `toKey` 未提供，直接将元素作为键。
    const key = toKey ? toKey(item) : (item as any as string | number | symbol)
    // 如果 `key` 已存在于 `acc` 中，表示该元素已经出现过，跳过它。
    if (acc[key]) return acc
    // 如果 `key` 不存在，将元素添加到 `acc` 中。
    acc[key] = item
    // 返回更新后的累加器 `acc`。
    return acc
  }, {} as Record<string | number | symbol, T>)
  // 使用 `Object.values` 方法从 `valueMap` 中提取所有的值，这些值是唯一的元素。
  return Object.values(valueMap)
}
    • 方法流程说明：
      1. 使用 reduce 方法遍历 array 数组，构建一个记录对象 valueMap。
      2. 对于数组中的每个元素 item，如果提供了 toKey 函数，则调用它来获取元素的键；如果没有提供 toKey 函数，则直接使用元素本身作为键。
      3. 检查键是否已经存在于 valueMap 中。如果存在，这意味着元素已经在之前出现过，因此跳过它。
      4. 如果键不存在，将元素添加到 valueMap 中，使用键作为索引。
      5. 继续处理数组的下一个元素，直到所有元素都被处理完毕。
      6. 使用 Object.values 方法提取 valueMap 中的所有值，因为 valueMap 中的键是唯一的，所以这些值也是唯一的。
      7. 返回包含所有唯一元素的新数组。

zipToObject：将第一个数组中的键映射到第二个数组中对应的值；

  1. 使用说明
    • 参数：数组1、数组2（或者是传入一个函数）。
    • 返回值：映射后的对象。
  2. 使用代码示例
    import { zipToObject } from 'radash'

const names = ['ra', 'zeus', 'loki']
const cultures = ['egypt', 'greek', 'norse']

zipToObject(names, cultures)
// => { ra: egypt, zeus: greek, loki: norse }

zipToObject(names, (k, i) => k + i)
// => { ra: ra0, zeus: zeus1, loki: loki2 }

zipToObject(names, null)
// => { ra: null, zeus: null, loki: null }
  3. 源码解析
    // 定义一个泛型函数 `zipToObject`。
export function zipToObject<K extends string | number | symbol, V>(
  // 第一个参数 `keys` 是一个数组，包含类型为 `K` 的键。
  keys: K[],
  // 第二个参数 `values` 可以是一个单一的值，一个返回值的函数，或者一个值的数组。
  values: V | ((key: K, idx: number) => V) | V[]
): Record<K, V> {
  // 如果 `keys` 不存在或 `keys` 的长度为0，返回一个空对象。
  if (!keys || !keys.length) {
    return {} as Record<K, V>
  }
  // ...（函数的其余部分）
}
    • 方法流程说明：

      1. 首先检查 keys 数组是否存在且长度不为零。如果 keys 不存在或为空数组，则函数返回一个空对象。

      2. 如果 keys 存在且不为空，函数将继续执行（这部分代码在这段代码之外）。

      3. 相关说明：文章来源地址https://www.toymoban.com/news/detail-856855.html

        • 这个函数预期的行为是，对于 keys 数组中的每个键，它会从 values 中取出相应的值（或者使用提供的函数计算出的值），并创建一个对象，其中每个键都映射到一个值。
        • 由于代码片段没有提供函数的完整实现，我们不能确定函数如何处理 values 参数。如果 values 是一个数组，它可能会将 keys 数组中的每个键与 values 数组中的相应值关联起来。如果 values 是一个函数，它可能会对每个键调用这个函数来生成值。如果 values 是单一的值，它可能会将这个值分配给 keys 数组中的每个键。
        • 这个函数的返回类型是 Record<K, V>，这是 TypeScript 中的一个工具类型，表示一个对象，其中键的类型为 K，值的类型为 V。在这个上下文中，K 被限制为 string、number 或 symbol 类型，这是对象键的有效类型。

zip：把两个数组变为二维数组，二维数组中的每个数组包含两个项分别为两个传入数组的相同位置的项。

  1. 使用说明
    • 参数：数组1、数组2.
    • 返回值：映射后的二维数组。
  2. 使用代码示例
    import { zip } from 'radash'

const names = ['ra', 'zeus', 'loki']
const cultures = ['egypt', 'greek', 'norse']

zip(names, cultures)
// => [
//   [ra, egypt]
//   [zeus, greek]
//   [loki, norse]
// ]
  3. 源码解析
    // 这是 `zip` 函数的实现部分，它使用剩余参数 `...arrays` 来接收任意数量的数组。
export function zip<T>(...arrays: T[][]): T[][] {
  // 检查传入的 `arrays` 是否存在且长度不为零，如果不是，则返回一个空数组。
  if (!arrays || !arrays.length) return []
  // 使用 `Math.max` 和 `map` 方法找出传入数组中长度最大的值。
  return new Array(Math.max(...arrays.map(({ length }) => length)))
    // 使用 `fill` 方法填充一个新数组，初始填充值为 `[]`（空数组）。
    .fill([])
    // 使用 `map` 方法遍历新数组的每个位置 `idx`。
    .map((_, idx) => arrays.map(array => array[idx]))
    // 对于每个位置 `idx`，从 `arrays` 中的每个数组 `array` 获取 `idx` 位置的元素。
    // 这样就组合成了一个元组，包含来自每个数组的元素。
}
    • 方法流程说明：
      1. 检查是否有数组传入，如果没有，则返回空数组。
      2. 创建一个新数组，长度是传入数组中最长的那个数组的长度。
      3. 遍历新数组的每个索引位置 idx。
      4. 对于每个位置 idx，遍历传入的所有数组，并从每个数组中取出该索引位置的元素。
      5. 将所有取出的元素组成一个元组，并将这个元组放入新数组的相应位置。
      6. 返回这个新数组，它包含了所有组合的元组。

写在后面

  • 等所有方法更新完毕，作者会整理一份radash完整方法目录上传，包括思维导图和使用目录。
  • 下期我们会整理分享Array方法的使用说明目录，同样包括思维导图。
  • 大家有任何问题或见解，欢迎评论区留言交流和批评指正！！！
  • 你的每一个收藏都是作者写作的动力！！！
  • 点击访问：radash官网

到了这里，关于lodash已死？radash最全使用介绍（附源码说明）—— Array方法篇（4）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 史上最全OpenCV常用方法及使用说明汇总，建议收藏！

    史上最全OpenCV常用方法及使用说明汇总，建议收藏！

    前言 ： Hello大家好，我是小哥谈。 计算机视觉的基础首先是处理图像、视频这些非结构化的数据，而图像处理库比较常用和强大的有PIL、OpenCV模块，本节课主要讲述 OpenCV常用的方法及使用说明。  🌈      目录 🚀一、基本操作  🚀二、绘图 🚀三、阈值处理 🚀四、几何

    2024年02月11日
    浏览(32)
  • clickhouse的嵌套数据结构Tuple、Array与Nested类型介绍和使用示例

    clickhouse的嵌套数据结构Tuple、Array与Nested类型介绍和使用示例

    Tuple 是 ClickHouse 数据库中的一种数据类型，它允许在一个字段中存储由不同数据类型组成的元组(tuple)。 元组可以包含任意数量的值，并且每个值可以是不同的数据类型，如 int 、 float 、 string 、 date 等。 例如，以下是一个 clickhouse Tuple 类型的例子： (1, \\\'John\\\', 12.5, Date(\\\'2021-0

    2024年02月14日
    浏览(37)

  • lodash之cloneDeep()源码阅读笔记

    基本上都在写业务代码，没有机会写库，还是想了解一下lodash的库源码是怎么样的，平时用的最多的就是cloneDeep()方法了，终于有空详细看看其中的源码。 本文基于lodash@5.0.0版本的源码进行阅读。 /cloneDeep.js cloneDeep入口函数 调用了一个内部的方法，传入的参数中有一个 CLON

    2024年02月13日
    浏览(26)

  • js工具类Lodash、功能介绍、用法

    Lodash 是一个非常流行的 JavaScript 实用工具库，它提供了一系列优化后可重复使用的函数，简化了 JS 开发中各种常见任务的编写。 以下是 Lodash 常用功能及用法的详细介绍： 1.复制数组： clone(array) 用法举例： 2.合并多个数组： concat(...arrays) 用法举例： 3.删除数组中所有符合

    2024年02月11日
    浏览(29)
  • 医学影像PACS系统源码: 三维重建基本后处理方法的介绍和说明

    医学影像PACS系统源码: 三维重建基本后处理方法的介绍和说明

    多层面重建（MPR） 最大密度投影（MIP） 最小密度投影（MinIP） 表面阴影遮盖（SSD） 容积漫游技术（VRT） 曲面重建（CPR） 虚拟内镜技术（VE）   1、MPR MPR(Multi-Planar Reformatting)，多平面重建，是将扫描范围内所有的轴位图像叠加起来再对某些标线标定的重组线所指定的组织进行

    2024年02月09日
    浏览(39)

  • valgrind基本功能介绍、基础使用方法说明 valgrind基本功能介绍、基础使用方法说明

    valgrind基本功能介绍、基础使用方法说明_valgrind使用方法_HNU Latecomer的博客-CSDN博客 拷贝效果不好，请看原文。 1、Valgrind概述 Valgrind是一套Linux下，开放源代码（GPL V2）的仿真调试工具的集合。 Valgrind由内核（core）以及基于内核的其他调试工具组成。内核类似于一个框架（f

    2024年02月07日
    浏览(50)

  • 【VxWorks】VxWorks系统详细介绍说明，环境搭建说明，使用场景，使用实例

    目录 1.VxWorks 概述 2.详细介绍 2.环境搭建说明 3.使用场景 4.使用实例         VxWorks 是一款实时操作系统（RTOS），广

    2024年02月15日
    浏览(28)
  • Mediapipe框架介绍及使用说明

    Mediapipe框架介绍及使用说明

            Mediapipe是Google开发的一款开源的跨平台框架，用于构建基于机器学习的应用程序，特别是涉及到计 算机视觉、音频处理、姿势估计 等领域。Mediapipe库提供了一系列预训练模型和工具，可以帮助开发者快速构建和部署计算机视觉和音频处理应用。它提供了一套易于

    2024年01月20日
    浏览(28)

  • [npm] npx 介绍与使用说明

    说到 npm 就离不开社区文化，那什么是社区文化？ 社区文化的意思是：拥有共同职业或兴趣的人群，自发组织在一起，通过分享信息和资源进行合作与交流。虚拟社区的参与者经常会在线讨论相关话题，或访问某些网站。 世界上最大的社区应该就是 GitHub。通过 GitHub 来分享源

    2024年02月07日
    浏览(26)
  • TensorFlow 决策森林详细介绍和使用说明

    TensorFlow 决策森林详细介绍和使用说明

    使用TensorFlow训练、调优、评估、解释和部署基于树的模型的完整教程 两年前TensorFlow (TF)团队开源了一个库来训练基于树的模型，称为TensorFlow决策森林(TFDF)。经过了2年的测试，他们在上个月终于宣布这个包已经准备好发布了，也就是说我们可以真正的开始使用了。所以这篇文

    2023年04月24日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包