我認為您可以透過為row建立一個類型來簡單地實現此目的，該類型將接受string、number或布爾值。

型別 Row = string[] |布林值[] |數字[]

現在，我們可以為foo函數的args參數指派此類型。

function foo(args: Row[]): void { ... ... ... }

使用此類型定義，如果您向foo提供一個參數，其中行中元素的類型不匹配，Typescript 將引發錯誤。

這裡是遊樂場連結代码>.

為了實現這一點，我們需要使用泛型陣列和映射類型來映射陣列的元素。由於我們知道該數組應該是長度為 2 的元組數組，因此我們將推斷元組中第一項的泛型參數，並使第二項具有相同類型。要取得泛型參數的類型，我們需要使用推斷關鍵字。請注意，我們需要確切地知道（或至少是具有相似形狀的類型）用於使其工作的泛型類型，在我們的例子中是Variable：

const foo = (arr: { [K in keyof T]: T[K] extends unknown[] ? T[K][0] extends Variable ? [Variable, Type] : T[K] : T[K]; }) => {}

看起來似乎就是全部，但是讓我們看看以下數組的類型：

const arr = [1, '2', false]; // (string | number | boolean)[] type Arr = typeof arr;

如您所見，該類型與我們在 arr 中的類型不完全相同。編譯器擴展了類型以確保我們可以改變數組元素。為了讓編譯器知道該陣列是唯讀的，我們需要使用const 斷言：

const arr = [1, '2', false] as const; // readonly [1, "2", false] type Arr = typeof arr;

現在看起來不錯，這意味著我們需要將傳遞給foo的數組設定為只讀`，並且由於只讀取組是我們將得到的可變數組的超集如果我們嘗試將只讀取組傳遞給數組，則會出現錯誤：

// false type Case1 = readonly number[] extends number[] ? true : false; // true type Case2 = number[] extends readonly number[] ? true : false;

因此，我們將foo中的所有陣列類型更新為唯讀。請注意，由於我們的數組是二維的，因此內部數組也將是唯讀的，並且數組的約束應該是只讀數組的只讀數組：

const foo = (arr: { [K in keyof T]: T[K] extends readonly unknown[] ? T[K][0] extends Variable ? readonly [Variable, Type] : T[K] : T[K]; }) => {};

測試：

declare const ctx1: Variable; declare const ctx2: Variable; declare const ctx3: Variable; declare const ctx4: Variable; declare const ctx5: Variable; declare const ctx6: Variable<{ name: string; age: number }>; foo([ [ctx1, 3], [ctx2, 'world'], [ctx3, true], [ctx4, 7], ] as const); foo([ [ctx1, 3], [ctx2, 'world'], [ctx3, true], [ctx4, 'invalid'], // error ] as const);

但是，我們仍然存在一些問題。例如，如果元組中的第一個元素是Variable，則表示第二個參數也應該是7，而不是任何數字，如果這是一個問題我們需要取得7的原語，即數字。這可以使用ToPrimitive來自我的type-samurai開源專案的實用程式類型： p>

type ToPrimitive = T extends string ? string : T extends number ? number : T extends null ? null : T extends undefined ? undefined : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : { [K in keyof T]: ToPrimitive; };

更新功能：

const foo = (arr: { [K in keyof T]: T[K] extends readonly unknown[] ? T[K][0] extends Variable ? ToPrimitive extends infer PrimitiveType ? readonly [Variable, PrimitiveType] : T[K] : T[K] : T[K]; }) => {};

另一個問題是，如果在我們目前的foo實作中推斷的類型是number[]，我們將不會允許只讀取組：

foo([ [ctx5, [4, 5, 6]], // The type 'readonly [4, 5, 6]' is 'readonly' and cannot be assigned to the mutable type 'number[]' ] as const)

修復非常簡單，我們將檢查推斷的類型是否是某個數組，然後獲取其元素類型並將 readonly ElemenType[] 作為元組中的第二個參數：

const foo = (arr: { [K in keyof T]: T[K] extends readonly unknown[] ? T[K][0] extends Variable ? ToPrimitive extends infer PrimitiveType ? readonly [ Variable, PrimitiveType extends Array ? readonly ArrayItem[] : PrimitiveType, ] : T[K] : T[K] : T[K]; }) => {};

測試：

foo([ [ctx1, 3], [ctx2, 'world'], [ctx3, true], [ctx4, 7], [ctx5, [4, 5, 6]], [ctx6, {name: "Hi", age: 23}], ] as const); foo([ [ctx1, 3], [ctx2, 'world'], [ctx3, true], [ctx4, true], // error here [ctx5, [4, 5, 6]], [ctx6, 50], // error here ] as const);

令人煩惱的部分是我們需要在任何地方使用const 斷言。在 Typescript5.0中，const 類型參數，這樣我們就可以避免const 斷言：

const foo = (item: T) => item // readonly [1, 2, 3] const result = foo([1,2,3])

不幸的是，我們無法使用它們，因為我們對參數進行了一些操作，而不是直接將T作為類型分配給它：

const foo = (item: {[K in keyof T]: T[K]}) => item // const result: (2 | 1 | 3)[] const result = foo([1, 2, 3])

總之，目前，const 斷言是確保其按預期工作的唯一方法。

連結到遊樂場

#