能否定义仅含一个指定类型元素的TypeScript泛型数组类型？

核心结论 #

无法直接用你最初构思的元组语法定义SpecialArray<Unique, Bland>，原因是TypeScript的元组类型不允许连续出现两个Rest元素（...Bland[]），这是语法层面的硬限制，报错"A rest element cannot follow another rest element"正是源于此。

不过我们可以通过其他方式实现编译时校验的需求，以下是几种可行方案：

方案1：直接可赋值的类型校验 #

通过条件类型与数组元素计数结合，实现可直接用于变量声明的SpecialArray类型，确保数组中仅含一个Unique类型元素，其余均为Bland类型：

// 统计数组中指定类型的元素数量
type Count<A extends readonly any[], T, Counter extends any[] = []> = 
  A extends [infer H, ...infer R] 
    ? [H] extends [T] ? Count<R, T, [...Counter, H]> : Count<R, T, Counter>
    : Counter;

// 定义SpecialArray类型
type SpecialArray<Unique, Bland> = 
  readonly (Unique | Bland)[] extends infer A
    ? Count<A, Unique>["length"] extends 1 ? A : never
    : never;

使用示例 #

// 合法：唯一string元素，其余为number
const valid1: SpecialArray<string, number> = [1, "a", 2, 3];
const valid2: SpecialArray<string, number> = ["a", 1, 2];
const valid3: SpecialArray<string, number> = [1, 2, "a"];

// 非法：多个string元素
const invalid1: SpecialArray<string, number> = ["a", "b", 1];
// 非法：包含非number/string类型元素
const invalid2: SpecialArray<string, number> = [1, true, "a"];

注：TypeScript对复杂条件类型的实时校验可能存在延迟，若未即时报错可触发类型检查（如hover查看变量类型）。

方案2：支持最大长度限制的版本SpecialArray<Unique, Bland, MaxLength> #

通过递归生成固定长度的元组组合，限制数组的最大长度，同时确保仅含一个Unique元素：

// 生成0到N-1的索引类型
type Indices<N extends number, T extends any[] = []> = 
  T['length'] extends N ? T[number] : Indices<N, [...T, T['length']]>;

// 生成指定长度、指定位置为Unique的元组
type TupleWithUniqueAt<Unique, Bland, Len extends number, Index extends number, T extends any[] = []> = 
  T['length'] extends Len 
    ? T
    : T['length'] extends Index 
      ? TupleWithUniqueAt<Unique, Bland, Len, Index, [...T, Unique]>
      : TupleWithUniqueAt<Unique, Bland, Len, Index, [...T, Bland]>;

// 生成所有长度从1到MaxLength的合法元组类型
type SpecialArray<Unique, Bland, MaxLength extends number, CurrLen extends number = 1> = 
  CurrLen extends MaxLength 
    ? { [I in Indices<CurrLen>]: TupleWithUniqueAt<Unique, Bland, CurrLen, I> }[Indices<CurrLen>]
    : SpecialArray<Unique, Bland, MaxLength, [...CurrLen[]]['length']> | { [I in Indices<CurrLen>]: TupleWithUniqueAt<Unique, Bland, CurrLen, I> }[Indices<CurrLen>];

使用示例 #

// 允许长度1-3的数组，唯一string元素，其余为number
type LimitedSA = SpecialArray<string, number, 3>;

// 合法
const valid: LimitedSA = [1, "a", 2];
const valid2: LimitedSA = ["a"];

// 非法：长度超过3
const invalid: LimitedSA = [1, 2, 3, "a"];
// 非法：多个string元素
const invalid2: LimitedSA = ["a", "b", 1];

注：MaxLength不宜设置过大（建议不超过20），否则会触发TypeScript递归深度限制，导致编译变慢或报错。

方案3：优化的辅助函数校验 #

如果直接赋值的类型校验不够直观，可通过封装辅助函数获得更清晰的报错信息：

type Count<A extends readonly any[], T, Counter extends any[] = []> = 
  A extends [infer H, ...infer R] 
    ? [H] extends [T] ? Count<R, T, [...Counter, H]> : Count<R, T, Counter>
    : Counter;

type IsSpecial<A extends readonly any[], Unique, Bland> = 
  Count<A, Unique>["length"] extends 1 
    ? A[number] extends Unique | Bland ? A : never 
    : never;

// 封装创建函数，简化使用
const createSpecialArray = <Unique, Bland>() => {
  return <A extends readonly (Unique | Bland)[]>(array: IsSpecial<A, Unique, Bland>) => array;
};

使用示例 #

const specialArray = createSpecialArray<string, number>();

// 合法
const valid = specialArray([1, "a", 2]);
// 非法：直接报错，提示类型不匹配
const invalid = specialArray(["a", "b", 1]);

内容的提问来源于stack exchange，提问作者k-tten