如何在显式定义对象类型的前提下推断函数参数类型

这个问题确实戳中了TypeScript类型系统里一个常见的痛点——既要确保对象严格符合预设的结构规范，又不想丢失函数属性的具体参数类型细节。其实咱们可以通过两种方式解决：泛型约束或者satisfies关键字（TS 4.9+支持），让类型系统同时完成校验和细节保留。

先分析下你的问题根源 #

你之前的Resource类型是一个“固定”的结构：

type Query = ((...params: any[]) => Promise<any>);
type Resource = { query: Query; }

当你用const resource: Resource = { ... }定义对象时，TypeScript会把resource.query的类型拓宽成Query，而不是它原本的(id: string) => Promise<string>。这就导致Params<typeof resource['query']>只能推断出any[]，因为Query的参数是any[]。

而inferredResource没有类型约束，所以TS能保留它的原始类型，但你没法确保它一定符合Resource的结构规范。

解决方案1：用泛型定义Resource类型 #

把Resource改成泛型，让它接受一个具体的Query子类作为参数，这样既约束了结构，又能保留函数的具体类型：

type Query = ((...params: any[]) => Promise<any>);
// 泛型版本的Resource，默认值保留原来的Query类型
type Resource<Q extends Query = Query> = { query: Q; }

// 方式1：显式指定泛型参数
const resource: Resource<(id: string) => Promise<string>> = { 
  query: (id: string) => Promise.resolve(id) 
};

// 方式2：让TS自动推导泛型参数（更简洁）
const resource = { query: (id: string) => Promise.resolve(id) } as Resource<typeof resource.query>;

// 现在参数类型推断正常了！
type ResourceParams = Params<typeof resource['query']>; // 类型为[string]

解决方案2：用satisfies关键字（推荐，TS 4.9+） #

satisfies是TypeScript 4.9新增的关键字，它的作用是检查对象是否符合指定类型，但不会改变对象的原始类型——完美契合你的需求：

type Query = ((...params: any[]) => Promise<any>);
type Resource = { query: Query; }
type Params<T> = T extends ((...params: infer R) => Promise<any>) ? R : any[];

// 用satisfies确保对象符合Resource结构，同时保留原始类型
const resource = { query: (id: string) => Promise.resolve(id) } satisfies Resource;

// 现在既能保证结构安全，又能正确推断参数类型
type ResourceParams = Params<typeof resource['query']>; // 类型为[string]

// 如果结构不符合，TS会报错（比如少了query属性，或者query不是函数）
const badResource = { name: "test" } satisfies Resource; // 报错：类型"{ name: string; }"不满足类型"Resource"

扩展：复杂结构的场景 #

如果你的Resource有更多属性，比如多个方法，这个方案同样适用。比如：

type Query = ((...params: any[]) => Promise<any>);
type Mutation = ((...params: any[]) => Promise<any>);
type Resource<Q extends Query = Query, M extends Mutation = Mutation> = { 
  query: Q;
  mutate: M;
};

const userResource = {
  query: (userId: string) => Promise.resolve({ id: userId, name: "Alice" }),
  mutate: (userId: string, newName: string) => Promise.resolve({ success: true })
} satisfies Resource;

// 分别推断两个方法的参数类型
type QueryParams = Params<typeof userResource.query>; // [string]
type MutateParams = Params<typeof userResource.mutate>; // [string, string]

这样一来，你既可以确保对象完全符合Resource的结构规范，又能精准获取每个函数属性的参数类型，完美兼顾了类型安全和推断能力。

内容的提问来源于stack exchange，提问作者Andy Jessop