让开源，少一点语言距离。
npm包中文文档

@cabloy/type-fest

中文文档
5.3.1发布于 2025/12/03(MIT OR CC0-1.0)TypeScriptES Module近 30 天下载 6115

基本类型文件集

中文使用文档
中文原文
文档目录23 节
  1. 安装
  2. 使用量
  3. API 密码
  4. 基础
  5. 公用事业
  6. 类型警卫
  7. 贾森
  8. 结构克隆
  9. 自动同步
  10. 字符串
  11. 阵列
  12. 数字
  13. 变化大小写
  14. 杂项
  15. 改进内置
  16. 减少类型
  17. 替代类型名称
  18. 提示
  19. 扩展现有类型
  20. 相关
  21. 内建类型
  22. 维护者
  23. 许可证


npm dependents npm downloads

这里的许多类型应该是内置的. 你可以通过建议一些他们 类型脚本工程。 。 。 .

要么添加此软件包作为依赖性,要么复制所需的类型。 无需信贷

PR欢迎其他共同需要的类型和文件改进。 读取 提供指南 先说.

需要帮助进行审查 建议 财务报告和审定财务报表 拖动请求。 。 。 .

安装

npm install type-fest

需要类型脚本% 5.9, 无害环境管理,以及 {strict: true} 在您的tsconfig.

[注] 此读取显示当前开发版本 。 关于最新版本的文件,请参见: npm 页。 。 。 .

你也会喜欢我的 ts-extras 为其中一些类型提供运行时函数的软件包.

使用量

import type {Except} from 'type-fest';

type Foo = {
    unicorn: string;
    rainbow: boolean;
};

type FooWithoutRainbow = Except<Foo, 'rainbow'>;
//=> {unicorn: string}

API 密码

单击类型名称以获取完整的文件.

基础

公用事业

  • EmptyObject - 代表一个完全空的平原对象 {} 数值.
  • NonEmptyObject - 至少是一个非可选密钥的对象.
  • UnknownRecord - 表示对象为: unknown 数值。 你可能想要这个而不是 {}。 。 。 .
  • UnknownArray - 一个阵列: unknown 数值.
  • UnknownMap - 代表地图: unknown 键和值.
  • UnknownSet - 一组: unknown 数值.
  • Except - 在没有特定密钥的情况下从对象类型创建类型。 这是更严格的版本 Omit。 。 。 .
  • Writable - 创建可以剥离的类型 readonly 从给定的类型。 反转 Readonly<T>。 。 。 .
  • WritableDeep - 创建一个非常可变的版本 object编号 :ReadonlyMap编号 :ReadonlySet编号 :ReadonlyArray 类型。 反之则 ReadonlyDeep<T>启用 Writable<T> 如果你只需要一个深层.
  • Merge - 将两种类型合并为新类型。 第二类密钥会覆盖第一类密钥.
  • MergeDeep - 将两个对象或两个数组/数组相继合并成一个新类型.
  • MergeExclusive - 创建一个有相互排斥的键的类型.
  • OverrideProperties - 只覆盖给定类型的现有属性。 类似 Merge,但强制要求原类型具有您想要覆盖的属性.
  • RequireAtLeastOne - 创建一个需要至少一个给定密钥的类型.
  • RequireExactlyOne - 创建一个需要给定的密钥完全单一的类型, 并允许更多.
  • RequireAllOrNone - 创建一个需要所有给定密钥或没有给定密钥的类型.
  • RequireOneOrNone - 创建一个需要给定密钥中完全一个密钥的类型,并允许更多,或者没有给定密钥.
  • SingleKeyObject - 创建一个只接受单一密钥对象的类型.
  • RequiredDeep - 创建一个非常需要的另一种类型的版本。 使用 Required<T> 如果你只需要一个深层.
  • PickDeep - 从深沉的物体中选择属性。 使用 Pick<T> 如果你只需要一个深层.
  • OmitDeep - 来自深沉物体的奥米特属性 使用 Omit<T> 如果你只需要一个深层.
  • OmitIndexSignature - 关闭给定对象类型的索引签名,只留下明确定义的属性.
  • PickIndexSignature - 仅从给定对象类型中选择索引签名,将所有明确定义的属性排除在外.
  • PartialDeep - 创建另一种类型的深度可选版本。 使用 Partial<T> 如果你只需要一个深层.
  • PartialOnUndefinedDeep - 创建一个深层版本的另一类型,所有密钥都接受 undefined 类型设置为可选.
  • UndefinedOnPartialDeep - 创建一个深层版本的另一种类型,其中所有可选密钥被设定为也接受 undefined。 。 。 .
  • ReadonlyDeep - 创造出一个不可改变的版本 object编号 :Map编号 :Set编号 :Array 类型。 使用 Readonly<T> 如果你只需要一个深层.
  • LiteralUnion - 结合原始类型和文字类型创建联盟类型,而不牺牲独立实体中的自动补全,用于联盟的文字类型部分。 工作间 微软/ TypeScript# 29729。 。 。 .
  • Tagged - 创建一个 标记类型 能够支持 多个标签 财务报告和审定财务报表 每个目标元数据. (这取代了上一个 Opaque 类型,现在已贬值。 )
  • UnwrapTagged - 获取标记类型中未标记的部分 Tagged. (这取代了上一个 UnwrapOpaque 类型,现在已贬值。 )
  • InvariantOf - 创建一个 变化类型,该类型不接受超类型和子类型.
  • SetOptional - 创建一个使给定的密钥具有可选性的类型.
  • SetReadonly - 创建一个使给定的密钥只读的类型.
  • SetRequired - 创建一个类型,使给定的密钥成为必要的.
  • SetRequiredDeep - 喜欢 SetRequired 但它会深刻选择密钥.
  • SetNonNullable - 创建一个类型,使给定的密钥不可创建.
  • SetNonNullableDeep - 创建一个类型,使指定的密钥不可创建(删除) null 财务报告和审定财务报表 undefined),支持深嵌密钥路径,并保留所有其他密钥不变.
  • ValueOf - 创建给定对象值的结合,并选择指定从中获取值的密钥.
  • ConditionalKeys - 从值延伸给定的形状中提取密钥 Condition 类型.
  • ConditionalPick - 喜欢 Pick 但它从值延伸给定的形状中选择属性 Condition 类型.
  • ConditionalPickDeep - 喜欢 ConditionalPick 但它会深刻选择属性.
  • ConditionalExcept - 喜欢 Omit 但它会从值延伸给定的形状去除属性 Condition 类型.
  • UnionToIntersection - 将联盟类型转换为交叉类型.
  • LiteralToPrimitive - 转换一个 文字类型 页:1 原始类型 属于它.
  • LiteralToPrimitiveDeep - 喜欢 LiteralToPrimitive 但它会在对象或阵列内深刻地转换文字类型.
  • Stringified - 用给定类型的密钥创建类型 string 类型.
  • IterableElement - 获取元素类型 Iterable编号 :AsyncIterable。例如, Array, (中文(简体) ), Set, (中文(简体) ), Map,生成器,流等.
  • Entry - 创建一个代表收藏条目类型的类型.
  • Entries - 创建一个代表收藏品条目类型的类型.
  • SetReturnType - 创建一个函数类型,其中包含您所选择的返回类型和与给定的函数类型相同的参数.
  • SetParameterType - 创建用给定参数替换一些参数的函数.
  • Simplify - 用于平整类型输出,以改善编辑器中显示的类型提示。 并且将一个接口转换为具有可分配性的辅助类型.
  • SimplifyDeep - 深度简化对象类型.
  • Get - 使用密钥路径从物体中获取深沉的属性,比如 罗达什的 .get() 函数.
  • KeyAsString - 获得给定类型的密钥作为字符串.
  • Schema - 创建另一个对象类型的深层版本,其中属性值被递归替换为给定值类型.
  • Exact - 创建一个不允许额外属性的类型.
  • KeysOfUnion - 建立一个由特定类型的所有钥匙组成的工会,即使是那些专门针对特定工会成员的钥匙.
  • OptionalKeysOf - 从给定类型中提取所有可选密钥.
  • HasOptionalKeys - 创建一个 true编号 :false 类型,取决于该类型是否具有任何可选字段.
  • RequiredKeysOf - 从给定类型中提取所有所需的密钥.
  • HasRequiredKeys - 创建一个 true编号 :false 类型,取决于给定类型是否有任何需要的字段.
  • ReadonlyKeysOf - 从给定类型中提取所有只读密钥.
  • HasReadonlyKeys - 创建一个 true编号 :false 类型取决于给定类型是否有只读字段.
  • WritableKeysOf - 从给定类型中提取所有可写(非只读)密钥.
  • HasWritableKeys - 创建一个 true编号 :false 字段.
  • Spread - 在使用扩展语法合并两个对象或两个数组/图时,模仿TypeScript所推断的类型.
  • IsEqual - 返回布尔值,以表示这两个类型是否相等.
  • TaggedUnion - 建立一个共有歧视财产的联盟.
  • IntRange - 形成一个数字联盟(包括开始,不包括结束).
  • IntClosedRange - 建立数字联盟(包括开始和结束).
  • ArrayIndices - 为常数组或Tuple提供有效的指数.
  • ArrayValues - 为常数组或Tuple提供所有值.
  • ArraySplice - 通过在原数组中指定的索引范围内添加或去除元素来创建新的数组类型.
  • ArrayTail - 提取数组的类型或拖动减去第一个元素.
  • SetFieldType - 创建更改给定密钥类型的类型.
  • Paths - 生成给定对象中所有可能的属性路径的结合.
  • SharedUnionFields - 从对象类型联盟创建共享字段的类型.
  • SharedUnionFieldsDeep - 创建一个类型,由物体类型组成的联盟,共享字段,深入地穿行巢状结构.
  • AllUnionFields - 从对象类型联盟中创建一个包含所有字段的类型.
  • DistributedOmit - Omits密钥 从类型, 分配操作在一个工会.
  • DistributedPick - 从类型中选取钥匙,在工会中分配操作.
  • And - 返回两个给定类型是否都是真实的布尔 .
  • Or - 返回两个给定类型中的任何一种是否真实的布尔值.
  • Xor - 返回布尔值,以确认两个类型中是否有一个是真实的.
  • AllExtend - 返回一个布尔,以显示数组类型中的每一元素是否延伸出另一个类型.
  • NonEmptyTuple - 匹配任何非空的Tuple.
  • NonEmptyString - 匹配任何非空字符串.
  • FindGlobalType - 尝试找到带有指定名称的全局类型 .
  • FindGlobalInstanceType - 试图从其全球定义的构造器中找到一个或多个类型.
  • ConditionalSimplify - 简化某种类型,同时包括和(或)排除某些类型的简化.
  • ConditionalSimplifyDeep - 递减地简化一种类型,同时包括和(或)排除某些类型的简化.
  • ExclusifyUnion - 增加其他成员的钥匙,以确保在对象工会中相互排斥 ?: never。 。 。 .

类型警卫

  • If - 类似假象的类型,根据给定的是否确定 boolean 类型是 true 或者说 false。 。 。 .
  • IsLiteral - 返回一个布尔,以确认给定类型是否为 文字类型。 。 。 .
  • IsStringLiteral - 返回一个布尔,以确认给定类型是否为 string 文字类型。 。 。 .
  • IsNumericLiteral - 返回一个布尔,以确认给定类型是否为 number 或者说 bigint 文字类型。 。 。 .
  • IsBooleanLiteral - 返回一个布尔,以确认给定类型是否为 true 或者说 false 文字类型。 。 。 .
  • IsSymbolLiteral - 返回一个布尔,以确认给定类型是否为 symbol 文字类型。 。 。 .
  • IsAny - 返回给定类型是否为布尔 any。 。 。 .
  • IsNever - 返回给定类型是否为布尔 never。 。 。 .
  • IsUnknown - 返回给定类型是否为布尔 unknown。 。 。 .
  • IsEmptyObject - 返回布尔值,以确认类型是否与空平原对象完全相等,即: {} 数值.
  • IsNull - 返回给定类型是否为布尔 null。 。 。 .
  • IsUndefined - 返回给定类型是否为布尔 undefined。 。 。 .
  • IsTuple - 返回布尔值,以确认给定的数组是否为tuple.
  • IsUnion - 返回一个布尔,以表示给定类型是否是一个结合.
  • IsLowercase - 返回布尔值,以确认给定的字符串是否为小写.
  • IsUppercase - 返回布尔值,以表示给定的字符串文字是否为大写.
  • IsOptional - 返回布尔,以确认给定类型是否包含 undefined。 。 。 .
  • IsNullable - 返回布尔,以确认给定类型是否包含 null。 。 。 .
  • IsOptionalKeyOf - 返回布尔值,以确认给定的密钥是否是类型中的可选密钥.
  • IsRequiredKeyOf - 返回布尔值,以确认给定的密钥是否是类型所需的密钥.
  • IsReadonlyKeyOf - 返回布尔值,以确认给定的密钥是否是类型的只读密钥.
  • IsWritableKeyOf - 返回布尔值,以确认给定的密钥是否属于类型中的可写密钥.

贾森

结构克隆

  • StructuredCloneable - 匹配一个可以使用无穷克隆的值 structuredClone。 。 。 .

自动同步

  • Promisable - 创建一种类型,既代表数值,又代表包裹的数值 PromiseLike。 。 。 .
  • AsyncReturnType - 解开返回函数的返回类型 Promise。 。 。 .
  • Asyncify - 创建给定函数类型的同步版本.

字符串

  • Trim - 从字符串中去掉正后方的空格.
  • Split - 代表使用特定字符集或字符集分割字符串的数组.
  • Words - 代表一组字符串的分解,使用高压来检测单词.
  • Replace - 代表有部分或全部匹配物被替换的字符串.
  • StringSlice - 返回给定范围的字符串片段,就像 String#slice()。 。 。 .
  • StringRepeat - 返回包含给定字符串的指定副本数量的新字符串,就像 String#repeat()。 。 。 .
  • RemovePrefix - 从字符串开头删除指定的前缀.

阵列

  • Arrayable - 创建代表值或数组的类型.
  • Includes - 返回布尔值,以显示给定数组是否包含给定项目.
  • Join - 用给定的字符串作为分隔符加入一系列字符串和/或数字.
  • ArraySlice - 返回给定范围的数组切片,就像 Array#slice()。 。 。 .
  • ArrayElement - 取出数组或tuple的元素类型.
  • LastArrayElement - 提取数组中最后一个元素的类型.
  • FixedLengthArray - 创建代表给定类型和长度的数组的类型。 这个 Array 操纵其长度的原型方法被排除在由此产生的类型之外.
  • MultidimensionalArray - 创建一个代表特定类型和维度的多层面阵列的类型.
  • MultidimensionalReadonlyArray - 创建一个类型,代表给定类型和维度的多维只读数组.
  • ReadonlyTuple - 创建一个类型,代表特定类型和长度的只读倒数.
  • TupleToUnion - 将一团/阵列转换成其组成部分的联盟类型.
  • UnionToTuple - 将联合类型转换为未订购的tuple类型.
  • TupleToObject - 将一推式转换成对象,将每个推式索引映射到相应的类型,作为键值对.
  • TupleOf - 以指定类型的元素创建指定长度的倒数类型.
  • SplitOnRestElement - 将一个阵列分成三个部分,其中第一个部分在剩余元素之前包含所有元素,第二个部分是: rest 元素本身,第三个元素包含剩余元素后的所有元素.
  • ExtractRestElement - 提取 rest 来自数组的元素类型.
  • ExcludeRestElement - 创造出一个Tuple与 rest 删除元素.

数字

  • PositiveInfinity - 匹配隐藏 Infinity 类型.
  • NegativeInfinity - 匹配隐藏 -Infinity 类型.
  • Finite 有限度 number。 。 。 .
  • Integer - 一个 number 这是整数.
  • Float - 一个 number 这不是整数.
  • NegativeFloat - 负数(-∞ < x < 0(中文(简体) ) number 这不是整数.
  • Negative - 一个负数 number编号 :bigint (单位:千美元)-∞ < x < 0(中文(简体) )
  • NonNegative - 一个非阴性 number编号 :bigint (单位:千美元)0 <= x < ∞) (中文(简体) ).
  • NegativeInteger - 负数(-∞ < x < 0(中文(简体) ) number 这是整数.
  • NonNegativeInteger - 非阴性(0 <= x < ∞(中文(简体) ) number 这是整数.
  • IsNegative - 返回布尔,以确认给定数字是否为负数.
  • IsFloat - 返回一个布尔,以表示给定的数字是否是一个浮点,例如 1.5 或者说 -1.5。 。 。 .
  • IsInteger - 返回一个布尔来表示给定数字是否是一个整数,例如 -5, (中文(简体) ), 1.0 或者说 100。 。 。 .
  • GreaterThan - 返回布尔值,以表示一个给定数字是否大于另一个数字.
  • GreaterThanOrEqual - 返回布尔,以表示一个给定数字是否大于或等于另一个数字.
  • LessThan - 返回一个布尔,以表示一个给定数字是否少于另一个数字.
  • LessThanOrEqual - 返回布尔,以表示一个给定数字是否小于或等于另一个数字.
  • Sum - 返回两个数字的总和.
  • Subtract - 返回两个数字之间的差额.

变化大小写

杂项

改进内置

  • ExtendsStrict - 更严格、非分配版本 extends 用于检查一个类型是否可指定另一个类型.
  • ExtractStrict - 更严格的版本 Extract<T, U> 确保每个成员 U 能够成功从中提取一些东西 T。 。 。 .
  • ExcludeStrict - 更严格的版本 Exclude<T, U> 确保每个成员 U 可以成功地排除某些东西 T。 。 。 .

减少类型

如果我们拒绝类型添加,我们将确保在这里记录更好的解决方案.

  • Diff 财务报告和审定财务报表 Spread -拉拉请求作者没有提供任何真实世界的使用案例 公关也停了 如果你认为这种类型有用, 提供一些真实世界的使用案例, 我们可能会重新考虑.
  • Dictionary - 你只保存几个字符(Dictionary<number> 对 Record<string, number>从 Record比较灵活和知名。 另外,你不应该用一个对象作为词典. 我们有 Map 在 JavaScript 现在.
  • ExtractProperties 财务报告和审定财务报表 ExtractMethods - 这些类型违反了单一责任原则。 相反,将你们的类型细化为更颗粒型的分级.
  • Url2Json - 从 URL 字符串中推断搜索参数是一个可爱的想法,但在实践中并不十分有用,因为搜索参数通常是动态的并单独定义的.
  • Nullish - 类型只拯救了几个角色, 不是每个人都知道什么是"无"的意思, 我也试图 走开 null。 。 。 .
  • TitleCase - 这不是解决一个共同的需要, 更适合一个单独的包.
  • ExtendOr 财务报告和审定财务报表 ExtendAnd - 好处不会超过必须学习他们的意思.
  • PackageJsonExtras - 太多可能的配置可以放进去 package.json。如果您想延长 PackageJson 支持您项目中的额外配置,请参见 扩展现有类型 下节.

替代类型名称

如果你用不同的名字知道我们的类型之一,请添加到这里以供发现.

提示

扩展现有类型

  • PackageJson - 有很多工具可以把额外的配置放在 package.json 文档。 你可以延长 PackageJson 支持这些额外的配置.

    示例

    游戏场

    import type {PackageJson as BasePackageJson} from 'type-fest';
import type {Linter} from 'eslint';

type PackageJson = BasePackageJson & {eslintConfig?: Linter.Config};

内建类型

大多数用户不知道的先进类型很多.

  • Awaited<T> - 提取一个数值的类型 Promise 下定决心.

    示例

    游戏场

    interface User {
  id: number;
  name: string;
  age: number;
}

class UserApiService {
  async fetchUser(userId: number): Promise<User> {
      // Fetch the user data from the database.
      // The actual implementation might look like this:
      // const response = await fetch('/api/user/${userId}');
      // const data = response.json();
      // return data;
      return {
          id: 1,
          name: 'John Doe',
          age: 30
      };
  }
}

type FetchedUser = Awaited<ReturnType<UserApiService['fetchUser']>>;

async function handleUserData(apiService: UserApiService, userId: number) {
  try {
      const user: FetchedUser = await apiService.fetchUser(userId);
      // After fetching user data, you can perform various actions such as updating the user interface,
      // caching the data for future use, or making additional API requests as needed.
  } catch (error) {
      // Error handling
  }
}

const userApiService = new UserApiService();
handleUserData(userApiService, 1);

  • Partial<T> - 使所有属性在 T 选项.

    示例

    游戏场

    interface NodeConfig {
        appName: string;
        port: number;
}

class NodeAppBuilder {
        private configuration: NodeConfig = {
                appName: 'NodeApp',
                port: 3000
        };

        private updateConfig<Key extends keyof NodeConfig>(key: Key, value: NodeConfig[Key]) {
                this.configuration[key] = value;
        }

        config(config: Partial<NodeConfig>) {
                type NodeConfigKey = keyof NodeConfig;

                for (const key of Object.keys(config) as NodeConfigKey[]) {
                        const updateValue = config[key];

                        if (updateValue === undefined) {
                                continue;
                        }

                        this.updateConfig(key, updateValue);
                }

                return this;
        }
}

// `Partial<NodeConfig>`` allows us to provide only a part of the
// NodeConfig interface.
new NodeAppBuilder().config({appName: 'ToDoApp'});

  • Required<T> - 使所有属性在 T 所需经费.

    示例

    游戏场

    interface ContactForm {
        email?: string;
        message?: string;
}

function submitContactForm(formData: Required<ContactForm>) {
        // Send the form data to the server.
}

submitContactForm({
        email: '[email protected]',
        message: 'Hi! Could you tell me more about…',
});

// TypeScript error: missing property 'message'
submitContactForm({
        email: '[email protected]',
});

  • Readonly<T> - 使所有属性在 T 仅读.

    示例

    游戏场

    enum LogLevel {
        Off,
        Debug,
        Error,
        Fatal
};

interface LoggerConfig {
        name: string;
        level: LogLevel;
}

class Logger {
        config: Readonly<LoggerConfig>;

        constructor({name, level}: LoggerConfig) {
                this.config = {name, level};
                Object.freeze(this.config);
        }
}

const config: LoggerConfig = {
    name: 'MyApp',
    level: LogLevel.Debug
};

const logger = new Logger(config);

// TypeScript Error: cannot assign to read-only property.
logger.config.level = LogLevel.Error;

// We are able to edit config variable as we please.
config.level = LogLevel.Error;

  • Pick<T, K> - 从 T,选择组合键的属性 K。 。 。 .

    示例

    游戏场

    interface Article {
        title: string;
        thumbnail: string;
        content: string;
}

// Creates new type out of the `Article` interface composed
// from the Articles' two properties: `title` and `thumbnail`.
// `ArticlePreview = {title: string; thumbnail: string}`
type ArticlePreview = Pick<Article, 'title' | 'thumbnail'>;

// Render a list of articles using only title and description.
function renderArticlePreviews(previews: ArticlePreview[]): HTMLElement {
        const articles = document.createElement('div');

        for (const preview of previews) {
                // Append preview to the articles.
        }

        return articles;
}

const articles = renderArticlePreviews([
        {
            title: 'TypeScript tutorial!',
            thumbnail: '/assets/ts.jpg'
        }
]);

  • Record<K, T> - 构造具有一组属性的类型 K 类型 T。 。 。 .

    示例

    游戏场

    // Positions of employees in our company.
type MemberPosition = 'intern' | 'developer' | 'tech-lead';

// Interface describing properties of a single employee.
interface Employee {
        firstName: string;
        lastName: string;
        yearsOfExperience: number;
}

// Create an object that has all possible `MemberPosition` values set as keys.
// Those keys will store a collection of Employees of the same position.
const team: Record<MemberPosition, Employee[]> = {
        intern: [],
        developer: [],
        'tech-lead': [],
};

// Our team has decided to help John with his dream of becoming Software Developer.
team.intern.push({
    firstName: 'John',
    lastName: 'Doe',
    yearsOfExperience: 0
});

// `Record` forces you to initialize all of the property keys.
// TypeScript Error: "tech-lead" property is missing
const teamEmpty: Record<MemberPosition, null> = {
        intern: null,
        developer: null,
};

  • Exclude<T, U> - 不包括从 T 可转让给 U。 。 。 .

    示例

    游戏场

    interface ServerConfig {
    port: null | string | number;
}

type RequestHandler = (request: Request, response: Response) => void;

// Exclude `null` type from `null | string | number`.
// In case the port is equal to `null`, we will use default value.
function getPortValue(port: Exclude<ServerConfig['port'], null>): number {
    if (typeof port === 'string') {
        return parseInt(port, 10);
    }

    return port;
}

function startServer(handler: RequestHandler, config: ServerConfig): void {
    const server = require('http').createServer(handler);

    const port = config.port === null ? 3000 : getPortValue(config.port);
    server.listen(port);
}

  • Extract<T, U> - 从 T 可转让给 U。 。 。 .

    示例

    游戏场

    declare function uniqueId(): number;

const ID = Symbol('ID');

interface Person {
    [ID]: number;
    name: string;
    age: number;
}

// Allows changing the person data as long as the property key is of string type.
function changePersonData<
    Obj extends Person,
    Key extends Extract<keyof Person, string>,
    Value extends Obj[Key]
> (obj: Obj, key: Key, value: Value): void {
    obj[key] = value;
}

// Tiny Andrew was born.
const andrew = {
    [ID]: uniqueId(),
    name: 'Andrew',
    age: 0,
};

// Cool, we're fine with that.
changePersonData(andrew, 'name', 'Pony');

// Government didn't like the fact that you wanted to change your identity.
changePersonData(andrew, ID, uniqueId());

  • NonNullable<T> - 不包括这个 null 财务报告和审定财务报表 undefined 从 T。 。 。 .

    示例 与 strictNullChecks 设置为 true。 。 。 .

    游戏场

    type PortNumber = string | number | null;

/** Part of a class definition that is used to build a server */
class ServerBuilder {
        portNumber!: NonNullable<PortNumber>;

        port(this: ServerBuilder, port: PortNumber): ServerBuilder {
                if (port == null) {
                        this.portNumber = 8000;
                } else {
                        this.portNumber = port;
                }

                return this;
        }
}

const serverBuilder = new ServerBuilder();

serverBuilder
        .port('8000')   // portNumber = '8000'
        .port(null)     // portNumber =  8000
        .port(3000);    // portNumber =  3000

// TypeScript error
serverBuilder.portNumber = null;

  • Parameters<T> - 在tuple中获取函数类型的参数.

    示例

    游戏场

    function shuffle(input: any[]): void {
    // Mutate array randomly changing its' elements indexes.
}

function callNTimes<Fn extends (...arguments_: any[]) => any> (func: Fn, callCount: number) {
    // Type that represents the type of the received function parameters.
    type FunctionParameters = Parameters<Fn>;

    return function (...arguments_: FunctionParameters) {
        for (let i = 0; i < callCount; i++) {
            func(...arguments_);
        }
    }
}

const shuffleTwice = callNTimes(shuffle, 2);

  • ConstructorParameters<T> - 在tuple中获取构造器函数类型的参数.

    示例

    游戏场

    class ArticleModel {
    title: string;
    content?: string;

    constructor(title: string) {
        this.title = title;
    }
}

class InstanceCache<T extends (new (...arguments_: any[]) => any)> {
    private ClassConstructor: T;
    private cache: Map<string, InstanceType<T>> = new Map();

    constructor (ctr: T) {
        this.ClassConstructor = ctr;
    }

    getInstance (...arguments_: ConstructorParameters<T>): InstanceType<T> {
        const hash = this.calculateArgumentsHash(...arguments_);

        const existingInstance = this.cache.get(hash);
        if (existingInstance !== undefined) {
            return existingInstance;
        }

        return new this.ClassConstructor(...arguments_);
    }

    private calculateArgumentsHash(...arguments_: any[]): string {
        // Calculate hash.
        return 'hash';
    }
}

const articleCache = new InstanceCache(ArticleModel);
const amazonArticle = articleCache.getInstance('Amazon forests burning!');

  • ReturnType<T> - 获得函数类型的返回类型.

    示例

    游戏场

    /** Provides every element of the iterable `iter` into the `callback` function and stores the results in an array. */
function mapIter<
        Elem,
        Func extends (elem: Elem) => any,
        Ret extends ReturnType<Func>
>(iter: Iterable<Elem>, callback: Func): Ret[] {
        const mapped: Ret[] = [];

        for (const elem of iter) {
                mapped.push(callback(elem));
        }

        return mapped;
}

const setObject: Set<string> = new Set();
const mapObject: Map<number, string> = new Map();

mapIter(setObject, (value: string) => value.indexOf('Foo')); // number[]

mapIter(mapObject, ([key, value]: [number, string]) => {
        return key % 2 === 0 ? value : 'Odd';
}); // string[]

  • InstanceType<T> - 获取构造函数类型的实例类型.

    示例

    游戏场

    class IdleService {
        doNothing (): void {}
}

class News {
        title: string;
        content: string;

        constructor(title: string, content: string) {
                this.title = title;
                this.content = content;
        }
}

const instanceCounter: Map<Function, number> = new Map();

interface Constructor {
        new(...arguments_: any[]): any;
}

// Keep track how many instances of `Constr` constructor have been created.
function getInstance<
        Constr extends Constructor,
        Arguments extends ConstructorParameters<Constr>
>(constructor: Constr, ...arguments_: Arguments): InstanceType<Constr> {
        let count = instanceCounter.get(constructor) || 0;

        const instance = new constructor(...arguments_);

        instanceCounter.set(constructor, count + 1);

        console.log(`Created ${count + 1} instances of ${Constr.name} class`);

        return instance;
}


const idleService = getInstance(IdleService);
// Will log: `Created 1 instances of IdleService class`
const newsEntry = getInstance(News, 'New ECMAScript proposals!', 'Last month...');
// Will log: `Created 1 instances of News class`

  • Omit<T, K> - 通过从T中取出所有属性然后去除K来构造一个类型.

    示例

    游戏场

    interface Animal {
        imageUrl: string;
        species: string;
        images: string[];
        paragraphs: string[];
}

// Creates new type with all properties of the `Animal` interface
// except 'images' and 'paragraphs' properties. We can use this
// type to render small hover tooltip for a wiki entry list.
type AnimalShortInfo = Omit<Animal, 'images' | 'paragraphs'>;

function renderAnimalHoverInfo (animals: AnimalShortInfo[]): HTMLElement {
        const container = document.createElement('div');
        // Internal implementation.
        return container;
}

  • Uppercase<S extends string> - 将字符串中的每个字符转换成大写.

    示例 
    type T = Uppercase<'hello'>;  // 'HELLO'

type T2 = Uppercase<'foo' | 'bar'>;  // 'FOO' | 'BAR'

type T3<S extends string> = Uppercase<`aB${S}`>;
type T4 = T3<'xYz'>;  // 'ABXYZ'

type T5 = Uppercase<string>;  // string
type T6 = Uppercase<any>;  // any
type T7 = Uppercase<never>;  // never
type T8 = Uppercase<42>;  // Error, type 'number' does not satisfy the constraint 'string'

  • Lowercase<S extends string> - 将字符串中的每个字符转换为小写.

    示例 
    type T = Lowercase<'HELLO'>;  // 'hello'

type T2 = Lowercase<'FOO' | 'BAR'>;  // 'foo' | 'bar'

type T3<S extends string> = Lowercase<`aB${S}`>;
type T4 = T3<'xYz'>;  // 'abxyz'

type T5 = Lowercase<string>;  // string
type T6 = Lowercase<any>;  // any
type T7 = Lowercase<never>;  // never
type T8 = Lowercase<42>;  // Error, type 'number' does not satisfy the constraint 'string'

  • Capitalize<S extends string> - 将字符串中的第一个字符转换为大写.

    示例 
    type T = Capitalize<'hello'>;  // 'Hello'

type T2 = Capitalize<'foo' | 'bar'>;  // 'Foo' | 'Bar'

type T3<S extends string> = Capitalize<`aB${S}`>;
type T4 = T3<'xYz'>;  // 'ABxYz'

type T5 = Capitalize<string>;  // string
type T6 = Capitalize<any>;  // any
type T7 = Capitalize<never>;  // never
type T8 = Capitalize<42>;  // Error, type 'number' does not satisfy the constraint 'string'

  • Uncapitalize<S extends string> - 将字符串中的第一个字符转换为小写.

    示例 
    type T = Uncapitalize<'Hello'>;  // 'hello'

type T2 = Uncapitalize<'Foo' | 'Bar'>;  // 'foo' | 'bar'

type T3<S extends string> = Uncapitalize<`AB${S}`>;
type T4 = T3<'xYz'>;  // 'aBxYz'

type T5 = Uncapitalize<string>;  // string
type T6 = Uncapitalize<any>;  // any
type T7 = Uncapitalize<never>;  // never
type T8 = Uncapitalize<42>;  // Error, type 'number' does not satisfy the constraint 'string'

您可以在 类型脚本文件。 。 。 .

维护者

许可证

SPDX-License-识别器:(MIT或CC0-1.0)

版本与发布记录

@cabloy/type-fest 共发布 2 个版本，首次发布于 2025/12/03；过去 12 个月发布了 2 个版本。

版本发布日期距今
5.3.1latest2025/12/0311 个月前
5.3.02025/12/0311 个月前

关于 @cabloy/type-fest 的常见问题

@cabloy/type-fest 是什么？

基本类型文件集

如何安装 @cabloy/type-fest？

在项目目录运行 npm install @cabloy/type-fest，或使用 pnpm add / yarn add / bun add。

@cabloy/type-fest 支持 TypeScript 吗？

支持。包内自带 TypeScript 类型声明（package.json 声明了 types 入口），安装后即可获得类型提示，无需再安装 @types 包。

@cabloy/type-fest 支持 ESM 还是 CommonJS？

以 ES Module 形式发布，推荐使用 import 引入。在 CommonJS 项目中，Node.js 20.19+ / 22.12+ 可以直接 require() 不含顶层 await 的 ES Module，更早的版本需要改用动态 import()。

@cabloy/type-fest 需要什么版本的 Node.js？

package.json 的 engines 字段要求 Node.js >=20。版本不符时 npm 默认只给出警告，开启 engine-strict 后会拒绝安装。

@cabloy/type-fest 可以商用吗？

@cabloy/type-fest 使用 (MIT OR CC0-1.0) 许可。可在 MIT、CC0-1.0 中任选其一遵守。选择 MIT 时，宽松许可：允许商业使用、修改和再分发，通常只需在分发时保留原版权与许可声明。以上为概括，不构成法律意见，请以许可原文为准。

@cabloy/type-fest 的下载量有多少？

根据 npm 官方下载统计，@cabloy/type-fest 在 2026/10/09 – 2026/11/07 这 30 天内被下载 6,115 次，日均约 204 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

@cabloy/type-fest 还在维护吗？

最新版本 5.3.1 发布于 2025/12/03（11 个月前）；至今共发布 2 个版本，其中过去 12 个月发布了 2 个；首次发布于 2025/12/03。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。