Array 数组

alphabetical （按字母顺序排列）

按属性的字母顺序对对象数组进行排序

基本用法

给定一个包含对象的数组和一个回调函数，用于确定用于排序的属性，返回一个按字母顺序排序的新数组。第三个可选参数允许您按降序而不是默认的升序对其进行排序。

对于数字排序，请参见 sort 函数。

import { alphabetical } from "radash";

const gods = [
  {
    name: "Ra",
    power: 100,
  },
  {
    name: "Zeus",
    power: 98,
  },
  {
    name: "Loki",
    power: 72,
  },
  {
    name: "Vishnu",
    power: 100,
  },
];

alphabetical(gods, (g) => g.name); // => [Loki, Ra, Vishnu, Zeus]
alphabetical(gods, (g) => g.name, "desc"); // => [Zeus, Vishnu, Ra, Loki]

boil （沸腾）

将项目列表减少到一个项目

基本用法

给定一个项目数组，返回匹配比较条件的最终项。适用于更复杂的最小/最大值。

import { boil } from "radash";

const gods = [
  {
    name: "Ra",
    power: 100,
  },
  {
    name: "Zeus",
    power: 98,
  },
  {
    name: "Loki",
    power: 72,
  },
];

boil(gods, (a, b) => (a.power > b.power ? a : b));
// => { name: 'Ra', power: 100 }

cluster （集群）

将列表拆分为给定大小的多个列表

基本用法

给定一个项目数组和期望的簇大小 ( n )，返回一个数组的数组。每个子数组包含 n (簇大小) 个项目，尽可能均匀地拆分。

import { cluster } from "radash";

const gods = [
  "Ra",
  "Zeus",
  "Loki",
  "Vishnu",
  "Icarus",
  "Osiris",
  "Thor",
  "Apollo",
  "Artemis",
  "Athena",
];

cluster(gods, 3);
// => [
//   [ 'Ra', 'Zeus', 'Loki' ],
//   [ 'Vishnu', 'Icarus', 'Osiris' ],
//   ['Thor', 'Apollo', 'Artemis'],
//   ['Athena']
// ]

counting（计数）

创建一个具有项目出现次数计数的对象

基本用法

给定一个对象数组和一个身份回调函数来确定每个对象的标识方式。返回一个对象，其中键是回调返回的 id 值，每个值是一个整数，告诉这个 id 出现了多少次。

import { counting } from "radash";

const gods = [
  {
    name: "Ra",
    culture: "egypt",
  },
  {
    name: "Zeus",
    culture: "greek",
  },
  {
    name: "Loki",
    culture: "greek",
  },
];

counting(gods, (g) => g.culture); // => { egypt: 1, greek: 2 }

diff（差异）

创建两个数组之间的差异数组

基本用法

给定两个数组，返回一个数组，其中包含第一个数组中存在但第二个数组中不存在的所有项。

import { diff } from "radash";

const oldWorldGods = ["ra", "zeus"];
const newWorldGods = ["vishnu", "zeus"];

diff(oldWorldGods, newWorldGods); // => ['ra']

first（第一个）

从列表中获取第一个项目

基本用法

给定一个项目数组，如果没有项目存在，则返回第一个项目或默认值。

import { first } from "radash";

const gods = ["ra", "loki", "zeus"];

first(gods); // => 'ra'
first([], "vishnu"); // => 'vishnu'

flat （拍平）

将数组的数组扁平化为一维数组

基本用法

给定一个包含许多数组的数组，返回一个新数组，其中所有子数组中的所有项都出现在顶层。

import { flat } from "radash";

const gods = [["ra", "loki"], ["zeus"]];

flat(gods); // => [ra, loki, zeus]

注意， _.flat 不是递归的，它只会展开第一层。

fork（分叉）

按条件将数组分割成两个数组

基本用法

给定一个项目数组和一个条件，返回两个数组，第一个包含所有通过条件的项目，第二个包含所有未通过条件的项目。

import { fork } from "radash";

const gods = [
  {
    name: "Ra",
    power: 100,
  },
  {
    name: "Zeus",
    power: 98,
  },
  {
    name: "Loki",
    power: 72,
  },
  {
    name: "Vishnu",
    power: 100,
  },
];

const [finalGods, lesserGods] = fork(gods, (f) => f.power > 90); // [[ra, vishnu, zues], [loki]]

group（分组）

对项目数组进行分组排序

基本用法

给定一个项目数组， group 将构建一个对象，其中每个键是属于该组的项目数组。一般来说，这对于对数组进行分类是很有用的。

import { group } from "radash";

const fish = [
  {
    name: "Marlin",
    source: "ocean",
  },
  {
    name: "Bass",
    source: "lake",
  },
  {
    name: "Trout",
    source: "lake",
  },
];

const fishBySource = group(fish, (f) => f.source); // => { ocean: [marlin], lake: [bass, trout] }

intersects（相交）

确定两个数组是否具有共同项

基本用法

给定两个项目数组，如果任何项目存在于两个数组中，则返回 true。

import { intersects } from "radash";

const oceanFish = ["tuna", "tarpon"];
const lakeFish = ["bass", "trout"];

intersects(oceanFish, lakeFish); // => false

const brackishFish = ["tarpon", "snook"];

intersects(oceanFish, brackishFish); // => true

iterate（迭代）

遍历回调函数 n 次

基本用法

有点像 forEach 遇到 reduce 。用于运行函数 n 次以生成一个值。 _.iterate 函数接受计数（运行回调的次数），回调函数和初始值。回调被作为一个减少函数运行计数次，然后累积的值被返回。

import { iterate } from "radash";

const value = iterate(
  4,
  (acc, idx) => {
    return acc + idx;
  },
  0
); // => 10

注意，这不是从零开始索引的。如果你传递一个 5 的 count ，你将在回调函数中得到 1、2、3、4、5 的索引。

last（最后）

从列表中获取最后一个项目

基本用法

给定一个项目数组，如果没有项目存在，则返回最后一个项目或默认值。

import { last } from "radash";

const fish = ["marlin", "bass", "trout"];

const lastFish = last(fish); // => 'trout'
const lastItem = last([], "bass"); // => 'bass'

list（列表）

使用特定项创建一个列表

基本用法

给定一个开始值、结束值、步长和步长大小，返回一个包含从开始到结束值的值的列表。

接口与 range 相同。

Python 的 range 功能致敬

import { list } from "radash";

list(3); // [0, 1, 2, 3]
list(0, 3); // [0, 1, 2, 3]
list(0, 3, "y"); // [y, y, y, y]
list(0, 3, () => "y"); // [y, y, y, y]
list(0, 3, (i) => i); // [0, 1, 2, 3]
list(0, 3, (i) => `y${i}`); // [y0, y1, y2, y3]
list(0, 3, obj); // [obj, obj, obj, obj]
list(0, 6, (i) => i, 2); // [0, 2, 4, 6]

签名

list 功能可以通过不同的参数实现很多功能。

list(size)

在提供单个参数时，它被视为 size 。返回一个值从 0 到 size 的列表。

list(3); // [0, 1, 2, 3]

list(start, end)

当给定两个参数时，它们被视为 start 和 end 。返回一个由 start 到 end 的值组成的列表。

list(2, 6); // [2, 3, 4, 5, 6]

list(start, end, value)

当给定第三个参数时，它被视为要在列表中使用的 value 。如果 value 是一个函数，它将被调用，带有一个索引参数，以创建每个值。

list(2, 4, {}); // [{}, {}, {}]
list(2, 4, null); // [null, null, null]
list(2, 4, (i) => i); // [2, 3, 4]

list(start, end, value, step)

当给定第四个参数时，它被视为 step 大小，从 start 到 end 生成值时要跳过的。

list(2, 4, (i) => i, 2); // [2, 4]
list(25, 100, (i) => i, 25); // [25, 50, 75, 100]

max（最大值）

从数组中获取最大的项

基本用法

给定一个项目数组和一个获取每个项目值的函数，返回具有最大值的项目。在底层使用 _.boil 。

import { max } from "radash";

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

max(fish, (f) => f.weight); // => {name: "Marlin", weight: 105, source: "ocean"}

merge（合并）

组合两个列表，覆盖第一个列表中的项目

基本用法

给定两个项目数组和一个身份函数，返回第一个列表，其中包含第二个列表中所有与之匹配的项目。

import { merge } from "radash";

const gods = [
  {
    name: "Zeus",
    power: 92,
  },
  {
    name: "Ra",
    power: 97,
  },
];

const newGods = [
  {
    name: "Zeus",
    power: 100,
  },
];

merge(gods, newGods, (f) => f.name); // => [{name: "Zeus" power: 100}, {name: "Ra", power: 97}]

min（最小值）

从数组中获取最小的项目

基本用法

给定一个项目数组和一个获取每个项目值的函数，返回具有最小值的项目。在内部使用 _.boil 。

import { min } from "radash";

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

min(fish, (f) => f.weight); // => {name: "Bass", weight: 8, source: "lake"}

objectify（对象化）

将列表转换为字典对象

基本用法

给定一个项目数组，使用给定函数创建一个键和值映射的字典。第一个参数是要映射的数组。第二个参数是确定每个项目键的函数。第三个参数是可选的，确定每个项目的值。

import { objectify } from "radash";

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

objectify(fish, (f) => f.name); // => { Marlin: [marlin object], Bass: [bass object], ... }
objectify(
  fish,
  (f) => f.name,
  (f) => f.weight
); // => { Marlin: 105, Bass: 8, Trout: 13 }

range（范围）

创建一个用于迭代的范围

基本用法

给定一个起始值、结束值、步长和值，返回一个生成器，该生成器将按步长从起始值到结束值产生值。用于将 for (let i = 0) 替换为 for of 。Range 将返回一个生成器， for of 将逐个调用，因此可以安全地创建大范围。

接口与 list 相同。

Python 的 range 功能致敬

import { range } from "radash";

range(3); // yields 0, 1, 2, 3
range(0, 3); // yields 0, 1, 2, 3
range(0, 3, "y"); // yields y, y, y, y
range(0, 3, () => "y"); // yields y, y, y, y
range(0, 3, (i) => i); // yields 0, 1, 2, 3
range(0, 3, (i) => `y${i}`); // yields y0, y1, y2, y3
range(0, 3, obj); // yields obj, obj, obj, obj
range(0, 6, (i) => i, 2); // yields 0, 2, 4, 6

for (const i of range(0, 200, 10)) {
  console.log(i); // => 0, 10, 20, 30 ... 190, 200
}

for (const i of range(0, 5)) {
  console.log(i); // => 0, 1, 2, 3, 4, 5
}

签名

range 函数可以使用不同的参数做很多事情。

range(size)

当给定单个参数时，它被视为 size 。返回一个生成器，该生成器产生从 0 到 size 的值。

range(3); // yields 0, 1, 2, 3

range(start, end)

当给定两个参数时，它们被视为 start 和 end 。返回一个生成器，产生从 start 到 end 的值。

range(2, 6); // yields 2, 3, 4, 5, 6

range(start, end, value)

当给定第三个参数时，它被视为要在生成器中生成的 value 。如果 value 是一个函数，它将被调用，并带有索引参数，以创建每个值。

range(2, 4, {}); // yields {}, {}, {}
range(2, 4, null); // yields null, null, null
range(2, 4, (i) => i); // yields 2, 3, 4

range(start, end, value, step)

当给定第四个参数时，它被视为跳过从 start 到 end 生成值时的 step 大小。

range(2, 4, (i) => i, 2); // yields 2, 4
range(25, 100, (i) => i, 25); // yields 25, 50, 75, 100

replaceOrAppend （替换或追加）

替换数组中的项目，如果没有匹配项则追加

基本用法

给定一个项目数组，一个项目和一个身份函数，返回一个新数组，其中项目要么替换现有项目的索引 - 如果存在，否则将其附加到末尾。

import { replaceOrAppend } from "radash";

const fish = [
  {
    name: "Marlin",
    weight: 105,
  },
  {
    name: "Salmon",
    weight: 19,
  },
  {
    name: "Trout",
    weight: 13,
  },
];

const salmon = {
  name: "Salmon",
  weight: 22,
};

const sockeye = {
  name: "Sockeye",
  weight: 8,
};

replaceOrAppend(fish, salmon, (f) => f.name === "Salmon"); // => [marlin, salmon (weight:22), trout]
replaceOrAppend(fish, sockeye, (f) => f.name === "Sockeye"); // => [marlin, salmon, trout, sockeye]

replace（替换）

替换数组中的一个项目

基本用法

给定一个项目数组，替换与给定条件函数匹配的项目。只替换第一个匹配项。始终返回原始数组的副本。

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]

select（选择）

过滤和映射数组

基本用法

一次性在一个步骤中同时应用过滤器和映射操作。

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]

shift（转移）

将数组项向前或向后移动 n 步

基本用法

给定一个项目列表，返回一个向右移动 n 个位置的数组。

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]

sift（筛选）

从列表中删除所有假值项目

基本用法

给定一个项目列表，返回一个新列表，其中包含所有不为假的项目。

import { sift } from "radash";

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

sift(fish); // => ['salmon', 'sockeye', 'bass']

sort（排序）

按数字属性对对象列表进行排序

基本用法

给定一个对象数组，通过 get 函数指定的数值属性返回一个新的排序数组。第三个可选参数允许您按降序而不是默认的升序排序。

此函数仅支持数字排序。对于字母排序，请参见字母函数。

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]

sum（求和）

将数组中的所有项相加

基本用法

给定一个项目数组，并可选地将每个项目映射到一个数字的函数，将所有项目相加。

import { sum } from "radash";

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

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

toggle（切换）

在数组中切换项目的存在

基本用法

如果列表中已经存在与条件匹配的项目，则将其移除。如果不存在，则将其添加。

import { toggle } from "radash";

const gods = ["ra", "zeus", "loki"];

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

toggle(list, item, identity)

您可以传递一个可选的 toKey 函数来确定非原始值的标识。在处理更复杂的数据类型时非常有用。

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]

toggle(list, item, identity, options)

默认情况下，如果项目不存在，切换将追加该项目。如果您需要替代选项参数中的 strategy ，则可以将项目前置。

import { toggle } from "radash";

const gods = ["ra", "zeus", "loki"];

toggle(gods, "vishnu", (g) => g, { strategy: "prepend" }); // => [vishnu, ra, zeus, loki]

unique （唯一）

从数组中删除重复项

基本用法

给定一个项目数组 -- 可选的，一个确定它们身份的函数 -- 返回一个没有重复项的新数组。

该函数不保留项目的原始顺序。

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' }
// ]

zipToObject

将多个数组合并成集合

基本用法

创建一个对象，将第一个数组中的键映射到第二个数组中相应的值。

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 }

zip

将多个数组合并成集合

基本用法

创建一个分组元素的数组，其中第一个元素包含给定数组的第一个元素，第二个元素包含给定数组的第二个元素，依此类推。

import { zip } from "radash";

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

zip(names, cultures);
// => [
//   [ra, egypt]
//   [zeus, greek]
//   [loki, norse]
// ]

Array 数组 ​

alphabetical （按字母顺序排列） ​

基本用法 ​

boil （沸腾） ​

基本用法 ​

cluster （集群） ​

基本用法 ​

counting（计数） ​

基本用法 ​

diff（差异） ​

基本用法 ​

first（第一个） ​

基本用法 ​

flat （拍平） ​

基本用法 ​

fork（分叉） ​

基本用法 ​

group（分组） ​

基本用法 ​

intersects（相交） ​

基本用法 ​

iterate（迭代） ​

基本用法 ​

last（最后） ​

基本用法 ​

list（列表） ​

基本用法 ​

签名 ​

list(size) ​

list(start, end) ​

list(start, end, value) ​

list(start, end, value, step) ​

max（最大值） ​

基本用法 ​

merge（合并） ​

基本用法 ​

min（最小值） ​

基本用法 ​

objectify（对象化） ​

基本用法 ​

range（范围） ​

基本用法 ​

签名 ​

range(size) ​

range(start, end) ​

range(start, end, value) ​

range(start, end, value, step) ​

replaceOrAppend （替换或追加） ​

基本用法 ​

replace（替换） ​

基本用法 ​

select（选择） ​

基本用法 ​

shift（转移） ​

基本用法 ​

sift（筛选） ​

基本用法 ​

sort（排序） ​

基本用法 ​

sum（求和） ​

基本用法 ​

toggle（切换） ​

基本用法 ​

toggle(list, item, identity) ​

toggle(list, item, identity, options) ​

unique （唯一） ​

基本用法 ​

zipToObject ​

基本用法 ​

zip ​

基本用法 ​

Array 数组

alphabetical （按字母顺序排列）

基本用法

boil （沸腾）

基本用法

cluster （集群）

基本用法

counting（计数）

基本用法

diff（差异）

基本用法

first（第一个）

基本用法

flat （拍平）

基本用法

fork（分叉）

基本用法

group（分组）

基本用法

intersects（相交）

基本用法

iterate（迭代）

基本用法

last（最后）

基本用法

list（列表）

基本用法

签名

list(size)

list(start, end)

list(start, end, value)

list(start, end, value, step)

max（最大值）

基本用法

merge（合并）

基本用法

min（最小值）

基本用法

objectify（对象化）

基本用法

range（范围）

基本用法

签名

range(size)

range(start, end)

range(start, end, value)

range(start, end, value, step)

replaceOrAppend （替换或追加）

基本用法

replace（替换）

基本用法

select（选择）

基本用法

shift（转移）

基本用法

sift（筛选）

基本用法

sort（排序）

基本用法

sum（求和）

基本用法

toggle（切换）

基本用法

toggle(list, item, identity)

toggle(list, item, identity, options)

unique （唯一）

基本用法

zipToObject

基本用法

zip

基本用法