Как я могу ввести функцию, которая принимает тип объединения, только если она содержит определенный подтип?

Я изо всех сил пытаюсь понять контекст здесь. Но почему не function processArray(arr: string[] | number[] | boolean[]): void или function processArray<T extends string[] | number[] | boolean[]>(arr: T): void?

Я думаю, вы можете захотеть что-то вроде этого:

function processArray<T extends string | number | boolean>(arr: T[]): void {
    const [first] = arr;

    if (typeof first === "string") {
        console.info(arr); // some complex logic here
    } else {
        // do nothing for arrays that are not of string[] type
    }
}

Это позволяет вам передавать массивы, подобные значениям вашего примера, а также смешанные типы, поэтому вам может понадобиться гарантия в вашем приложении, что массивы имеют только один тип. В противном случае перепишите свой чек на (за счет некоторых дополнительных вычислений):

if (arr.every(value => typeof value === "string")) {

общие ограничения TypeScript служат только в качестве так называемой верхней границы типа. Если у вас есть T extends string[], то требуется, чтобы T был подтипом string[] или присваивался ему. То, что вы хотите, больше похоже на нижнюю границу, поскольку вы хотите, чтобы string[] вместо этого можно было присвоить T. То есть вы хотите, чтобы это был тип, который может принимать массив строк, а не тот, который может предоставить массив строк. На microsoft/TypeScript#14520 есть запрос функции, но пока это не является частью языка.

На самом деле похоже, что вы хотите немного другое ограничение. Вы хотите, чтобы T был каким-то типом массива, поэтому T extends readonly unknown[], и вы хотите, чтобы тип элемента этого массива, возможно, был каким-то string. Поэтому вместо того, чтобы говорить, что тип элемента ограничен string сверху или снизу, вы скорее хотите сказать, что между типом и string есть некоторое совпадение. Итак, если элемент массива равен string, или string | boolean, или "a" | "b" | "c", или "a" | number, все в порядке. Вы хотите отклонить его только в том случае, если вообще нет перекрытия, например, если тип элемента массива был number | boolean.

Поэтому нам нужен способ выразить это в ограничении. К счастью, мы можем сделать это следующим образом:

function processArray<T extends readonly unknown[] &
    (string & T[number] extends never ? never : unknown)
>(arr: T): void {
    console.info(arr);
}

Это самореферентное ограничение (также называемое F-ограниченным ), которое оказывается принятым (иногда TS отклоняет их как круговые). В нем говорится, что T должно быть присвоено readonly unknown[], и (используя [пересечение])( https://www.typescriptlang.org/docs/handbook/2/objects.html#intersection-types ), нам нужно его можно присвоить условному типу string & T[number] extends never ? never : unknown. Тип string & T[number] является пересечением или перекрытием между string и типом элемента T (если T является массивом и вы индексируете его с помощью ключа типа number, то вы получаете тип элемента, поэтому T[number]). Если этот тип перекрытия пуст, это невозможный тип никогда , а условный тип оценивается как ничего не принимающий never тип. Если этот тип перекрытия не пуст, условный тип оценивается как неизвестный тип принятия всего.

Другими словами, если тип элемента T может включать в себя тип string, ограничение оценивается как T extends readonly unknown[], и он примет массив... но если это не так, то ограничение оценивается как T extends never, и все это не удастся.

Давайте проверим это:

const sArr = ["a", "b", "c"];
const nArr = [1, 2, 3];
const bArr = [true, false];

const arr1 = Math.random() < 0.5 ? sArr : nArr
processArray(arr1); // okay

const arr2 = Math.random() < 0.5 ? sArr : bArr
processArray(arr2); // okay

const arr3 = Math.random() < 0.5 ? nArr : bArr;
processArray(arr3); // error

processArray(["a", "b"] as const); // okay
processArray(["a", 1] as const); // okay
processArray([1, 2] as const); // error

Выглядит неплохо. Только массивы, которые не принимают string любого типа, отклоняются.

Площадка ссылка на код