如何确保元组元素标签被保留？

背景

我正在尝试使用带标签的元组元素将现有的重载函数替换为剩余参数。

原始代码

这是原始重载函数的简化版本：

function doSomething(arg1: string, arg2: number):void;
function doSomething(arg1: string, arg2: number, arg3: unknown[]):void;
function doSomething(arg1: string, arg2: number, arg3: boolean):void;
function doSomething(arg1: string, arg2: number, arg3: unknown[], arg4: boolean):void {
    // ...implementation
}

因此第三个和第四个参数是可选的，但提供时顺序可以是：

arg3: unknown[]
arg3: unknown[], arg4: boolean
arg3: boolean

尝试的解决方案

我决定首先创建带标签的元组元素，然后根据提供的类型变量类型将其类型设置为提供的类型或never。然后过滤该元组，删除任何元素never并返回结果。

type CalcAdditionArgs<ThirdArgType extends unknown[], FourthArgType extends boolean> = [
    myArg3: ThirdArgType extends [] ? never : ThirdArgType,
    myArg4 : [FourthArgType] extends [boolean] ? FourthArgType extends true ? true : never : never
]

type GetAdditionalArgs<ThirdArgType extends unknown[], FourthArgType extends boolean> = 
    FilterType<CalcAdditionArgs<ThirdArgType, FourthArgType>,  never>

FilterType是此处找到的元组过滤实用程序的修改版本https://stackoverflow.com/a/64034671/1798234 https://stackoverflow.com/a/64034671/1798234

type FilterType<T extends unknown[], U = undefined> = 
    (T extends [] ? 
        [] :
        (T extends [infer H, ...infer R] ?
            ([H] extends [U] ?
                FilterType<R, U> :
                [H, ...FilterType<R, U>]) : 
            T
        )
    );

为了清楚起见，这是使用它们的函数

function execute<
    ThirdArgType extends unknown[] = [],
    FourthArgType extends boolean = false
>(
    arg1: string,
    arg2: number,
    ...args:GetAdditionalArgs<ThirdArgType, FourthArgType>
    
): void {
    // do something here
}

Problem

这是两种实用程序类型的输出：

type a = CalcAdditionArgs<[], false>; //  [myArg3: never, myArg4: never]
type b = CalcAdditionArgs<[], true>; // [myArg3: [string, number], myArg4: never]
type c = CalcAdditionArgs<[string, number], false>; // [myArg3: [string, number], myArg4: never]
type d = CalcAdditionArgs<[string, number, Function], true>; // [myArg3: [string, number, Function], myArg4: true]

type e = GetAdditionalArgs<[], false>; // []
type f = GetAdditionalArgs<[], true>; // [true]
type g = GetAdditionalArgs<[string, number], false>; // [string: number]
type h = GetAdditionalArgs<[string, number, Function], true>; // [[string, number, Function], true]

如你看到的，GetAdditionalArgs（更确切地说FilterType) 正在剥离元组元素标签。

Question

我无法理解如何（如果实际上可能）在实用程序类型中创建然后操作元组类型。即创建一个空元组，然后向其中添加所需的类型。因此，我的解决方案方法是预先创建填充的元组，然后删除元素。

1. 有谁知道为什么元组元素标签被剥离FilterType有没有办法使用现有的解决方案来解决这个问题？

Or

2. 有没有更好/更简单的解决方案来实现我正在寻找的结果？

Solution

感谢@captain-yossarian 的回复以及@ford04 的回复（https://stackoverflow.com/a/64194372/1798234 https://stackoverflow.com/a/64194372/1798234）我能够使用剩余参数重新思考我的解决方案方法：

type Append<E extends [unknown], A extends unknown[]> = [...A, ...E]

type GetMyArrayArg<T extends unknown[]> = [myArrayArg: T extends [] ? never : T]
type GetMyBooleanArg<T extends boolean> = [myBooleanArg : [T] extends [boolean] ? T extends true ? true : never : never]


type AddParameter<T extends [unknown], U extends unknown[] = []> =
    T extends [] ? 
        U :
        T extends [infer H] ?
            [H] extends [never] ? 
                U : 
                Append<T, U> :
            U

type GetAdditionalArgs<ThirdArgType extends unknown[], FourthArgType extends boolean> = 
    AddParameter<
        GetMyBooleanArg<FourthArgType>, 
        AddParameter<
            GetMyArrayArg<ThirdArgType>>
        >


type a = GetAdditionalArgs<[], false>; // []
type b = GetAdditionalArgs<[], true>; // [myBooleanArg: true]
type c = GetAdditionalArgs<[string, number], false>; // [myArrayArg: [string, number]]
type d = GetAdditionalArgs<[string, number, Function], true>; // [myArrayArg: [string, number, Function], myBooleanArg: true]

如果您好奇为什么从输出中删除元组标签，可能很难回答。

首先，在这里你可以找到docs https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-0.html#labeled-tuple-elements .

根据文档：

它们纯粹用于文档和工具

这只是我的猜测。

我认为标签被删除是因为FilterType实用类型。FilterType创建全新的元组，并且 TS 似乎在迭代期间不保留元组标签。

考虑这个例子：

type Labeled = [name: string];

type Infer<L extends Labeled> = L extends [infer First] ? [First] : never

type Result = Infer<Labeled> // [string], no label

数字索引也不保留标签。[L[0]]- 退货[string].

似乎它与其余参数一起使用：

type Labeled = [name: string];

type Infer<L extends Labeled> = L extends [infer _] ? [...L] : never

type Result = Infer<Labeled> // [name: string], with label

CalcAdditionArgs不创建新元组。

我在文档中没有找到如何保留标签。

我假设，既然您在中创建了新元组FilterType，元素的顺序可能不会保留。因此，保留标签可能不安全。但这只是我的猜测。

Here https://github.com/microsoft/TypeScript/pull/38234你可以找到公关

但是，您可以将标签添加到FilterType:

type FilterType<T extends unknown[], U = undefined> =
    (T extends [] ?
        [] :
        (T extends [infer H, ...infer R] ?
            ([H] extends [U] ?
                FilterType<R, U> :
                [Batman: H, ...Superman: FilterType<R, U>]) : // <----- LABELS
            T
        )
    );

正如您可能已经注意到的，我添加了Batman标签和Superman标签，它们存在于输出中：

type FilterType<T extends unknown[], U = undefined> =
    (T extends [] ?
        [] :
        (T extends [infer H, ...infer R] ?
            ([H] extends [U] ?
                FilterType<R, U> :
                [Batman: H, ...Superman: FilterType<R, U>]) :
            T
        )
    );


type CalcAdditionArgs<ThirdArgType extends unknown[], FourthArgType extends boolean> = [
    myArg3: ThirdArgType extends [] ? never : ThirdArgType,
    myArg4: [FourthArgType] extends [boolean] ? FourthArgType extends true ? true : never : never
]

type GetAdditionalArgs<ThirdArgType extends unknown[], FourthArgType extends boolean> =
    FilterType<CalcAdditionArgs<ThirdArgType, FourthArgType>, never>


type e = GetAdditionalArgs<[], false>; // []
type f = GetAdditionalArgs<[], true>; // [Batman: true]
type g = GetAdditionalArgs<[string, number], false>; // [Batman: [string, number]]
type h = GetAdditionalArgs<[string, number, Function], true>; // [Batman: [string, number, Function], Batman: true]

如果这不符合您的期望，您可以手动创建允许的元组的并集。这将是最安全的方式