闪亮

一个核心内容明确、效率高、没有依赖关系的公用图书馆

安装 二. 支助 使用量 二. 支助 API 参考 二. 支助 贡献者 二. 支助 许可证

安装

yarn add @devoxa/flocky

使用量

import { sum } from '@devoxa/flocky'
sum([1, 2, 3])
// -> 6

API 参考

平均数( 阵列)

计算数组中的数值平均值.

flocky.average([1, 4, 2, -4, 0])
// -> 0.6

^{来源 • 减少:75 B 减少:77 B}

块( 阵列, 大小)

将一系列元素分成 size。 。 。 . 如果阵列无法平分,则最终块会包含剩余元素.

flocky.chunk([1, 2, 3, 4, 5, 6, 7], 3)
// -> [[1, 2, 3], [4, 5, 6], [7]]

^{来源 • 减少:105 B 减少和减少:101 B}

夹口( 值、 分、 最大)

将最小和最大范围内的值插入(包括).

flocky.clamp(3, 0, 5)
// -> 3

flocky.clamp(10, 0, 5)
// -> 5

flocky.clamp(-10, 0, 5)
// -> 0

^{来源 • 减少:69 B • 减少和减少GZIP:66 B}

克隆( 值)

创建深克隆 value。 。 。 . 这种方法只支持原生到JSON的类型,因此所有原始类型,阵列和对象.

const original = [{ a: 1 }, { b: 2 }]
const clone = flocky.clone(original)
original[0] === clone[0]
// -> false

^{来源 • 减:69 B • 减:69 B}

压缩( 阵列)

创建一个带有所有 falsy () 的阵列undefined, (中文(简体) ), null, (中文(简体) ), false, (中文(简体) ), 0, (中文(简体) ), NaN, (中文(简体) ), '') 数值被删除.

flocky.compact([1, 2, 3, null, 4, false, 0, NaN, 5, ''])
// -> [1, 2, 3, 4, 5]

^{来源 • 减少:61 B • 减少和减少GZIP:64 B}

卸下( 已失效, 等待)

创建延迟引用的已撤销函数 func 直至 wait 毫秒 自上次启用已解开的函数以来已过期.

const func = () => console.log('Heavy processing happening')
const debouncedFunc = flocky.debounce(func, 250)

^{来源 • 减:129 B • 减:112 B}

重复( 阵列, 身份 )

创建一个数组的版本,只保留重复的元素. 结果值的顺序由它们在数组中发生的顺序决定. 可以通过一个可选的 identity 函数来选择对象的标识部分.

flocky.duplicates([1, 1, 2, 4, 2, 1, 6])
// -> [1, 2, 1]

flocky.duplicates(['foo', 'bar', 'foo', 'foobar'])
// -> ['foo']

const input = [{ id: 1, a: 1 }, { id: 1, a: 2 }, { id: 2, a: 3 }, { id: 1, a: 4 }]
flocky.duplicates(input, (element) => element.id)
// -> [{ id: 1, a: 2 }, { id: 1, a: 4 }]

^{来源 • 减少:271 B 减少:145 B}

逃出RegExp( 字符串)

在正则表达式中使用的字符串中逃避特殊字符.

flocky.escapeRegExp('Hey. (1 + 1 = 2)')
// -> 'Hey\\. \\(1 \\+ 1 = 2\\)'

^{来源 • 减:93 B • 减:90 B}

平坦( 对象)

将嵌入对象平分为带有点标记键的对象.

flocky.flatten({ a: { b: 1, c: 2 }, d: { e: { f: 3 } } })
// -> { 'a.b': 1, 'a.c': 2, 'd.e.f': 3 }

^{来源 • 减少:172 B 减少和减少GZIP:136 B}

获取( 对象、 路径、 默认值 ?)

获取值为 a path 一、导 言 object (带有可选内容) defaultValue(中文(简体) )

: 警告: 使用此方法会忽略类型信息, 您将拥有 键入返回类型。 如果你可以的话,总比进入好 属性,例如“可选链”运算符.

const object = {a: {b: {c: 1}}}
flocky.get(object, 'a.b.c')
// -> 1

const object = {a: {b: {c: 1}}}
flocky.get(object, 'x.x.x')
// -> undefined

const object = {a: {b: {c: 1}}}
flocky.get(object, 'x.x.x', 'default')
// -> 'default'

^{来源 二. 支助 基准 • 减少:424 B 减少:266 B}

hash( 数据)

创建一个散列字符串来表示数据中传递的内容.

: 警告: 3⁄4 ̄ ̧漯B Argon2id, (中文(简体) ), scrypt 或者说 bcrypt 任何安全相关的东西.

flocky.hash('some really long string')
// -> 'x1nr7uiv'

flocky.hash({id: 'AAA', name: 'BBB'})
// -> 'x16mynva'

^{来源 二. 支助 基准 • 减少:554 B 减少:334 B}

标识符( )

用 UUID v4 格式生成随机标识符 .

flocky.identifier()
// -> 'bfc8d57e-b9ab-4245-836e-d1fd99602e30'

^{来源 • 减少:275 B 减少:196 B}

匹配全部( regExp, 字符串)

在字符串中查找正则表达式的所有匹配 .

flocky.matchAll(/f(o+)/g, 'foo bar baz foooo bar')
// -> [
// ->   { match: 'foo', subMatches: ['oo'], index: 0 },
// ->   { match: 'foooo', subMatches: ['oooo'], index: 12 },
// -> ]

^{来源 • 减轻:178 B 减轻和减轻全球污染:133 B}

最大( 阵列)

计算数组中数值的最大值.

flocky.max([1, 4, 2, -3, 0])
// -> 4

^{来源 • 减少:58个B 减少和减少GZIP:63个B}

提醒( 关闭, 选项 )

创建一个函数, 记住返回值 func。 。 。 .

const func = (a, b) => a + b
const memoizedFunc = flocky.memoize(func)
const memoizedFuncWithTtl = flocky.memoize(func, { ttl: 30 * 1000 })
memoizedFunc(1, 2)
// -> 3

^{来源 二. 支助 基准 • 减少:956 B 减少:439 B}

分钟( 阵列)

计算数组中数值的最小值.

flocky.min([1, 4, 2, -3, 0])
// -> -3

^{来源 • 减少:58个B 减少和减少GZIP:63个B}

省略( 对象, 密钥)

创建一个由所有未在 keys。 。 。 .

const object = { a: 1, b: 2, c: 3 }
flocky.omit(object, ['a'])
// -> { b: 2, c: 3 }

^{来源 二. 支助 基准 • 减少:143个B 减少:129个B}

百分位数( 阵列, k)

计算数组中数值的千分百分数.

flocky.percentile([90, 85, 65, 72, 82, 96, 70, 79, 68, 84], 0.9)
// -> 90.6

^{来源 • 减:215 B • 减:并减:154 B}

选择( 对象, 密钥)

创建由指定对象组成的对象 keys。 。 。 .

const object = { a: 1, b: 2, c: 3 }
flocky.pick(object, ['a', 'c'])
// -> { a: 1, c: 3 }

^{来源 二. 支助 基准 • 减少:97个B 减少:93个B}

承诺Pool( 保证功能, 限制)

与有限的货币平行运行多个返回承诺函数.

await flocky.promisePool([
  () => Promise.resolve(1),
  () => Promise.resolve(2),
  () => Promise.resolve(3),
  () => Promise.resolve(4),
], 2)
// -> [1, 2, 3, 4]

^{来源 • 减轻:180 B 减轻和减轻全球污染:142 B}

承诺超时( 保证, 超时)

如果承诺不能在内部达成,就拒绝承诺 timeoutMs。 。 。 .

: 警告: 当超时时, 承诺将被拒绝。 不过, 由于承诺无法兑现,承诺本身将继续履行 直至它解决或拒绝.

await flocky.promiseTimeout(Promise.resolve(1), 10)
// -> 1

^{来源 • 减少:301 B 减少:179 B}

随机( 下, 上, 浮?)

生成随机数字 lower 财务报告和审定财务报表 upper (包含). 若为 float 真实或 lower 或者说 upper 是一个浮标,一个浮标是返回而不是整数.

flocky.random(1, 10)
// -> 8

flocky.random(1, 20, true)
// -> 14.94849340769861

flocky.random(2.5, 3.5)
// -> 3.2341312319841373

^{来源 • 减轻损失:219 B 减轻损失:128 B}

随机结构( 长度)

生成一个随机的字母数字字符串 length 字符键.

flocky.randomString(5)
// -> 'tfl0g'

^{来源 • 减少:230 B 减少:201 B}

范围( 启动、 结束、 步骤)

生成数组从 start 最高和包括 end。 。 。 .

flocky.range(0, 5)
// -> [0, 1, 2, 3, 4, 5]

flocky.range(-5, -10)
// -> [-5, -6, -7, -8, -9, -10]

flocky.range(-6, -12, 2)
// -> [-6, -8, -10, -12]

^{来源 • 减少:131 B • 减少和减少GZIP:111 B}

圆通( 数, 精确度)

圆向浮点数 precision 小数位.

flocky.roundTo(3.141592653589, 4)
// -> 3.1416

flocky.roundTo(1.005, 2)
// -> 1.01

flocky.roundTo(1111.1, -2)
// -> 1100

^{来源 • 消化:209 B 消化和GZIP:150 B}

样本( 阵列)

从 array。 。 。 .

flocky.sample([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
// -> 8

^{来源 • 减少:79个B 减少:79个B}

洗牌( 阵列)

创建一系列被洗涤的值 .

flocky.shuffle([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
// -> [3, 7, 2, 1, 10, 4, 6, 9, 5, 8]

^{来源 • 减少:152个B 减少和减少GZIP:131个B}

睡眠( 分钟)

回到一个等待的承诺 ms 解决前的毫秒.

await flocky.sleep(25)

^{来源 • 减:71 B • 减:76 B}

拼写( 字符串)

生成一个字符串的 URL 安全弹片 .

flocky.slugify(' Issue #123 is _important_! :)')
// -> 'issue-123-is-important'

^{来源 • 减少:114 B 减少:104 B}

总数( 阵列)

计算数组中值的总和.

flocky.sum([1, 4, 2, -4, 0])
// -> 3

^{来源 • 减少:58个B 减少:65个B}

节流管( 日出, 等等)

创建调用节奏函数 func 最多每个 wait 毫秒长. 如果引用被节制, func 将在最后提供的论点中援引.

const func = () => console.log('Heavy processing happening')
const throttledFunc = flocky.throttle(func, 250)

^{来源 • 减少:207 B 减少:155 B}

到Map( 阵列、 密钥、 目标? )

创建搜索地图 array 对象列表,并查看 key 和可选 target。 。 。 .

flocky.toMap(
  [
    { id: 1, name: 'Stanley', age: 64 },
    { id: 2, name: 'Juliet', age: 57 },
    { id: 3, name: 'Alex', age: 19 }
  ],
  'id'
)
// -> {
// ->   1: { id: 1, name: 'Stanley', age: 64 },
// ->   2: { id: 2, name: 'Juliet', age: 57 },
// ->   3: { id: 3, name: 'Alex', age: 19 }
// -> }

flocky.toMap(
  [
    { id: 1, name: 'Stanley', age: 64 },
    { id: 2, name: 'Juliet', age: 57 },
    { id: 3, name: 'Alex', age: 19 }
  ],
  'name',
  'age'
)
// -> { Stanley: 64, Juliet: 57, Alex: 19 }

^{来源 • 减:93 B 减:92 B}

未平面( 对象)

将带有点标记键的对象解充为嵌入对象.

flocky.unflatten({ 'a.b': 1, 'a.c': 2, 'd.e.f': 3 })
// -> { a: { b: 1, c: 2 }, d: { e: { f: 3 } } }

^{来源 • 减轻损失:199 B 减轻损失:145 B}

独一无二( 阵列, 身份 )

创建一个数组的无重复版本,其中只保留每个元素的首次出现. 结果值的顺序由它们在数组中发生的顺序决定. 可以通过一个可选的 identity 函数来选择对象的标识部分.

flocky.unique([1, 1, 2, 4, 2, 1, 6])
// -> [1, 2, 4, 6]

flocky.unique(['foo', 'bar', 'foo', 'foobar'])
// -> ['foo', 'bar', 'foobar']

const input = [{ id: 1, a: 1 }, { id: 1, a: 2 }, { id: 2, a: 3 }, { id: 1, a: 4 }]
flocky.unique(input, (element) => element.id)
// -> [{ id: 1, a: 1 }, { id: 2, a: 3 }]

^{来源 二. 支助 基准 • 减少:234 B • 减少和减少:150 B}

贡献者

感谢这些伟大的人emoji 密钥:

大卫·瑞斯 💻 📖 ⚠️

杰夫・哈吉 💻

达尔斯迈姆 💻

本项目遵循 全部贡献者 规格。 任何捐款都欢迎!

许可证

麻省理工学院