Radash

Appearance

Object 对象 ​

assign（分配） ​

递归合并两个对象

基本用法 ​

将两个对象递归地合并到一个新对象中，从右到左应用值。递归仅适用于子对象属性。

ts
import { assign } from "radash";

const ra = {
  name: "Ra",
  power: 100,
};

assign(ra, { name: "Loki" });
// => { name: Loki, power: 100 }

clone（克隆） ​

创建给定对象/值的浅拷贝。

基本用法 ​

创建给定对象/值的浅拷贝。

ts
import { clone } from "radash";

const ra = {
  name: "Ra",
  power: 100,
};

const gods = [ra];

clone(ra); // => copy of ra
clone(gods); // => copy of gods

construct（构建） ​

从键路径和值构建对象

基本用法 ​

相反的是压扁，给定一个被压扁成关键路径和值的对象，会返回重建原始对象。

ts
import { construct } from "radash";

const flat = {
  name: "ra",
  power: 100,
  "friend.name": "loki",
  "friend.power": 80,
  "enemies.0.name": "hathor",
  "enemies.0.power": 12,
};

construct(flat);
// {
//   name: 'ra',
//   power: 100,
//   friend: {
//     name: 'loki',
//     power: 80
//   },
//   enemies: [
//     {
//       name: 'hathor',
//       power: 12
//     }
//   ]
// }

crush（压碎） ​

将深层对象压平为单一维度

基本用法 ​

将深层对象压平为单个维度。深层键将在新对象中转换为点符号表示法。

ts
import { crush } from "radash";

const ra = {
  name: "ra",
  power: 100,
  friend: {
    name: "loki",
    power: 80,
  },
  enemies: [
    {
      name: "hathor",
      power: 12,
    },
  ],
};

crush(ra);
// {
//   name: 'ra',
//   power: 100,
//   'friend.name': 'loki',
//   'friend.power': 80,
//   'enemies.0.name': 'hathor',
//   'enemies.0.power': 12
// }

get（获取） ​

使用深路径获取任何属性或子属性

基本用法 ​

给定任何值和一个选择函数来获取所需的属性，如果找不到所需的值，则返回所需的值或默认值。

ts
import { get } from "radash";

const fish = {
  name: "Bass",
  weight: 8,
  sizes: [
    {
      maturity: "adult",
      range: [7, 18],
      unit: "inches",
    },
  ],
};

get(fish, "sizes[0].range[1]"); // 18
get(fish, "sizes.0.range.1"); // 18
get(fish, "foo", "default"); // 'default'

invert（反转） ​

反转对象的键和值

基本用法 ​

给定一个对象，返回一个将键和值颠倒的新对象。

ts
import { invert } from "radash";

const powersByGod = {
  ra: "sun",
  loki: "tricks",
  zeus: "lighning",
};

invert(gods); // => { sun: ra, tricks: loki, lightning: zeus }

keys（键） ​

从对象中深入获取所有的键

基本用法 ​

给定一个对象，返回其所有键和子键作为一个扁平字符串列表。

ts
import { keys } from "radash";

const ra = {
  name: "ra",
  power: 100,
  friend: {
    name: "loki",
    power: 80,
  },
  enemies: [
    {
      name: "hathor",
      power: 12,
    },
  ],
};

keys(ra);
// => [
//   'name',
//   'power',
//   'friend.name',
//   'friend.power',
//   'enemies.0.name',
//   'enemies.0.power'
// ]

这是一个你可能想要与 get 一起使用的函数，它动态地查找对象中给定字符串路径的值。将这两者结合使用，你可以做类似将深层对象展平的操作。

ts
import { keys, get, objectify } from "radash";

objectify(
  keys(ra),
  (key) => key,
  (key) => get(ra, key)
);
// => {
//   'name': 'ra'
//   'power': 100
//   'friend.name': 'loki'
//   'friend.power': 80
//   'enemies.0.name': 'hathor'
//   'enemies.0.power': 12
// }

从 v10.5.0+开始，您可以通过 crush 函数获得这种行为

listify（列表化） ​

将对象转换为列表

基本用法 ​

给定一个对象和一个映射函数，返回一个数组，其中每个条目对应对象中的每个条目。

ts
import { listify } from "radash";

const fish = {
  marlin: {
    weight: 105,
  },
  bass: {
    weight: 8,
  },
};

listify(fish, (key, value) => ({ ...value, name: key })); // => [{ name: 'marlin', weight: 105 }, { name: 'bass', weight: 8 }]

lowerize（小写化） ​

将所有对象键转换为小写

基本用法 ​

将对象中的所有键转换为小写。用于标准化属性键大小写。例如，标头。

ts
import { lowerize } from "radash";

const ra = {
  Mode: "god",
  Power: "sun",
};

lowerize(ra); // => { mode, power }

The _.lowerize function is a shortcut for _.mapKeys(obj, k => k.toLowerCase())

mapEntries（映射条目） ​

映射对象的键和值

基本用法 ​

迭代对象的条目，调用给定的 toEntry 回调函数来生成新的条目。它是 _.mapValues 和 _.mapKeys 的结合体。 toEntry 回调函数应该返回一个包含两个项目 [key, value] （也就是新条目）的数组。

ts
import { mapEntries } from "radash";

const ra = {
  name: "Ra",
  power: "sun",
  rank: 100,
  culture: "egypt",
};

mapEntries(ra, (key, value) => [key.toUpperCase(), `${value}`]); // => { NAME: 'Ra', POWER: 'sun', RANK: '100', CULTURE: 'egypt' }

mapKeys（映射键） ​

在对象的键上进行映射

基本用法 ​

给定一个对象和 toKey 回调函数，返回一个新对象，其中所有键都经过 toKey 函数映射。回调函数为每个条目同时提供键和值。

ts
import { mapKeys } from "radash";

const ra = {
  mode: "god",
  power: "sun",
};

mapKeys(ra, (key) => key.toUpperCase()); // => { MODE, POWER }
mapKeys(ra, (key, value) => value); // => { god: 'god', power: 'power' }

mapValues（映射值） ​

映射对象的键

基本用法 ​

给定一个对象和一个 toValue 回调函数，通过 toValue 函数映射所有值后返回一个新对象。回调函数会为每个条目提供值和键。

ts
import { mapValues } from "radash";

const ra = {
  mode: "god",
  power: "sun",
};

mapValues(ra, (value) => value.toUpperCase()); // => { mode: 'GOD', power: 'SUN' }
mapValues(ra, (value, key) => key); // => { mode: 'mode', power: 'power' }

omit（省略） ​

从对象中省略不需要的属性

基本用法 ​

给定一个对象和对象中的一个键列表，返回一个不包含任何给定键的新对象。

ts
import { omit } from "radash";

const fish = {
  name: "Bass",
  weight: 8,
  source: "lake",
  brackish: false,
};

omit(fish, ["name", "source"]); // => { weight, brackish }

pick（挑选） ​

从对象中仅选择所需的属性

基本用法 ​

给定一个对象和对象中的键列表，返回一个只包含给定键的新对象。

ts
import { pick } from "radash";

const fish = {
  name: "Bass",
  weight: 8,
  source: "lake",
  barckish: false,
};

pick(fish, ["name", "source"]); // => { name, source }

set（设置） ​

使用路径键在对象上设置一个值

基本用法 ​

相反于 get，动态地使用键路径将嵌套值设置到对象中。不修改给定的初始对象。

ts
import { set } from "radash";

set({}, "name", "ra");
// => { name: 'ra' }

set({}, "cards[0].value", 2);
// => { cards: [{ value: 2 }] }

shake（摇动） ​

从对象中删除不需要的值

基本用法 ​

有点像 _.sift ，但适用于对象。默认情况下，它将返回一个新对象，其中移除了所有未定义的属性。您可以传递第二个函数参数，根据自定义条件移除任何属性。

ts
import { shake } from "radash";

const ra = {
  mode: "god",
  greek: false,
  limit: undefined,
};

shake(ra); // => { mode, greek }
shake(ra, (a) => !a); // => { mode }

upperize（使字母大写） ​

将所有对象键转换为大写

基本用法 ​

将对象中的所有键转换为大写。

ts
import { upperize } from "radash";

const ra = {
  Mode: "god",
  Power: "sun",
};

upperize(ra); // => { MODE, POWER }

_.upperize 函数是 _.mapKeys(obj, k => k.toUpperCase()) 的快捷方式