Radashi 简介

欢迎来到 Radashi！我们旨在通过一系列超级便捷的函数，为现代 JavaScript 和 TypeScript 开发者提供更轻松的开发体验。将 Radashi 视为一个友好的工具带，它专注于简洁性、可定制性和社区。

来自我们的前身 Radash？

你需要查看我们的对比文章，了解 Radashi 的优越之处。

主要特性

✨ 为 TypeScript 构建

Radashi 的核心采用 TypeScript 开发。这意味着我们的函数不仅能帮助你编写更好的代码，还能及早捕获错误，使你的开发过程更顺畅、更可靠。

castArray

chain

下面是我们 castArray 的实现。如果你能读懂我们的 CastArray<T> 类型，那你正式成为一名 TypeScript 爱好者了。不过好消息是，我们已经为你写好了，你无需自己动手！

export function castArray<T>(value: T): CastArray<T>
export function castArray(value: unknown): unknown {
  return Array.isArray(value) ? value.slice() : [value]
}

export type CastArray<T> = [T] extends [never]
  ? never[]
  : [unknown] extends [T]
    ? unknown[]
    :
        | (T extends any
            ? T extends readonly (infer U)[]
              ? U[]
              : never
            : never)
        | (Exclude<T, readonly any[]> extends never
            ? never
            : Exclude<T, readonly any[]>[])

我们的 chain 函数也有一个复杂的类型定义。如你所见，我们能做很多事来让你的 TypeScript 生活更轻松。

export function chain<T1 extends any[], T2, T3>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3
): (...arg: T1) => T3
export function chain<T1 extends any[], T2, T3, T4>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4
): (...arg: T1) => T4
export function chain<T1 extends any[], T2, T3, T4, T5>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4,
  f4: (arg: T3) => T5
): (...arg: T1) => T5
export function chain<T1 extends any[], T2, T3, T4, T5, T6>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4,
  f4: (arg: T3) => T5,
  f5: (arg: T3) => T6
): (...arg: T1) => T6
export function chain<T1 extends any[], T2, T3, T4, T5, T6, T7>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4,
  f4: (arg: T3) => T5,
  f5: (arg: T3) => T6,
  f6: (arg: T3) => T7
): (...arg: T1) => T7
export function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4,
  f4: (arg: T3) => T5,
  f5: (arg: T3) => T6,
  f6: (arg: T3) => T7,
  f7: (arg: T3) => T8
): (...arg: T1) => T8
export function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4,
  f4: (arg: T3) => T5,
  f5: (arg: T3) => T6,
  f6: (arg: T3) => T7,
  f7: (arg: T3) => T8,
  f8: (arg: T3) => T9
): (...arg: T1) => T9
export function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4,
  f4: (arg: T3) => T5,
  f5: (arg: T3) => T6,
  f6: (arg: T3) => T7,
  f7: (arg: T3) => T8,
  f8: (arg: T3) => T9,
  f9: (arg: T3) => T10
): (...arg: T1) => T10
export function chain<
  T1 extends any[],
  T2,
  T3,
  T4,
  T5,
  T6,
  T7,
  T8,
  T9,
  T10,
  T11,
>(
  f1: (...arg: T1) => T2,
  f2: (arg: T2) => T3,
  f3: (arg: T3) => T4,
  f4: (arg: T3) => T5,
  f5: (arg: T3) => T6,
  f6: (arg: T3) => T7,
  f7: (arg: T3) => T8,
  f8: (arg: T3) => T9,
  f9: (arg: T3) => T10,
  f10: (arg: T3) => T11
): (...arg: T1) => T11
export function chain(...funcs: ((...args: any[]) => any)[]) {
  return (...args: any[]) => {
    return funcs.slice(1).reduce((acc, fn) => fn(acc), funcs[0](...args))
  }
}

🎯 智能函数选择

我们根据实际需求和流行用例来选择函数。我们的目标是提供你所需的内容，避免冗余，保持一切简单明了。

select

objectify

defer

使用 select 通过过滤和映射另一个数组的项来创建新数组。

import { select } from 'radashi'

// 示例：过滤和转换产品列表
const products = [
  { id: 1, name: 'Laptop', price: 1000, inStock: true },
  { id: 2, name: 'Phone', price: 800, inStock: false },
  { id: 3, name: 'Tablet', price: 500, inStock: true },
  { id: 4, name: 'Headphones', price: 100, inStock: true },
]

// 映射到包含名称和价格的新对象。
// 过滤掉缺货或价格过高的产品。
const affordableInStockProducts = select(
  products,
  product => ({ name: product.name, price: product.price }),
  product => product.inStock && product.price < 600
)
// => [{ name: 'Tablet', price: 500 }, { name: 'Headphones', price: 100 }]

使用 objectify 从数组创建对象。

import { objectify } from 'radashi'

// 员工列表，包含ID和薪水
const employees = [
  { id: 101, name: 'Alice', salary: 75000 },
  { id: 102, name: 'Bob', salary: 82000 },
  { id: 103, name: 'Charlie', salary: 68000 },
]

// 按ID创建员工薪水的字典
const salariesById = objectify(
  employees,
  employee => employee.id,
  employee => employee.salary
)
// => { 101: 75000, 102: 82000, 103: 68000 }

// 快速查找员工薪水
console.log(`Bob's salary: $${salariesById[102]}`)
// 输出 "Bob's salary: $82000"

使用 defer 将清理逻辑与资源创建放在一起。

import { defer } from 'radashi'

async function runDatabaseMigration() {
  await defer(async cleanup => {
    const tempTable = await createTempTable()
    cleanup(async () => dropTable(tempTable))

    const backupFile = await backupExistingData()
    cleanup(async () => deleteFile(backupFile))

    try {
      await migrateData(tempTable)
      await swapTables(tempTable, 'production_table')
    } catch (error) {
      console.error('Migration failed:', error)
      throw error
    }

    console.log('Migration completed successfully')
  })
}

runDatabaseMigration().catch(console.error)

🪶 轻量高效

我们保持简洁，确保你的项目轻快高效。Radashi 完全支持 tree-shaking，因此你只包含使用的函数。这意味着你的代码中没有不必要的臃肿。

radashi

lodash-es

有趣的是，让我们比较一下 Radashi 的 mapValues 函数与 Lodash 的版本。我可以保证，这种巨大的差异并不少见。

export function mapValues(obj, mapFunc) {
  const keys = Object.keys(obj)
  return keys.reduce((acc, key) => {
    acc[key] = mapFunc(obj[key], key)
    return acc
  }, {})
}

这是 Lodash 的 mapValues 函数。打包后的大小经压缩后达到 16.6 kB。显然，我们都想避免这种情况！

// http-url:https://unpkg.com/[email protected]/_freeGlobal.js
var freeGlobal =
  typeof global == 'object' && global && global.Object === Object && global
var freeGlobal_default = freeGlobal

// http-url:https://unpkg.com/[email protected]/_root.js
var freeSelf = typeof self == 'object' && self && self.Object === Object && self
var root = freeGlobal_default || freeSelf || Function('return this')()
var root_default = root

/* 大约1300行代码之后... */

// http-url:https://unpkg.com/[email protected]/mapValues.js
function mapValues(object, iteratee) {
  var result = {}
  iteratee = baseIteratee_default(iteratee, 3)
  baseForOwn_default(object, function (value, key, object2) {
    baseAssignValue_default(result, key, iteratee(value, key, object2))
  })
  return result
}
var mapValues_default = mapValues
export { mapValues_default as mapValues }

🛠️ 易于定制

想要添加自己的风格吗？你可以使用我们的模板仓库轻松扩展 Radashi。让它成为你的，并轻松将你的函数贡献给社区。

🤝 社区驱动

Radashi 依靠贡献和新想法蓬勃发展。我们欢迎每个人加入，分享知识，并帮助库不断发展。我们的开放流程和定期更新使我们与开发者的需求保持一致。

解决常见问题

Radashi 旨在解决工具库中的一些重大问题：

1. 去中心化控制：我们支持去中心化、社区驱动的方法。
2. 可定制性：使用我们的模板仓库轻松扩展 Radashi。
3. 碎片化：我们为分享和采用 TypeScript 工具函数提供了一个统一的平台。

我们的核心价值

• 有目的的设计：遵循我们不断发展的”我们的理念”文档
• 简洁性：保持代码轻量高效
• 实用主义：专注于最实用的内容
• 创新：领先于新兴需求

 

---

Radashi 通过提供一套精选的 TypeScript 工具函数，帮助你编写更清晰、更高效的代码。根据你的需求进行定制，贡献你自己的函数，并与开发者社区合作，共同构建更好的 JavaScript 生态系统。

准备好开始了么？ 选择你在 Radashi 的下一步：

• 安装：在你的项目中尝试 Radashi。
• 函数概述：探索 Radashi 的函数。
• 贡献指南：帮助我们改进 Radashi。