Перетворити тип об’єднання на тип перетину


88

Чи є спосіб перетворити тип об’єднання в тип перетину:

type FunctionUnion = () => void | (p: string) => void
type FunctionIntersection = () => void & (p: string) => void

Я хотів би застосувати трансформацію, FunctionUnionщоб отриматиFunctionIntersection

Відповіді:


193

Ви хочете об'єднання до перетину? Це можуть зробити розподільні умовні типи та умовиводи з умовних типів . (Не думайте, що можливо зробити перетин до об’єднання, вибачте) Ось зла магія:

type UnionToIntersection<U> = 
  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never

Це розподіляє союз Uі перепаковує його в новий союз, де всі конститунти знаходяться в противаріантному положенні. Це дозволяє визначити тип як перетин I, як зазначено у довіднику:

Подібним чином, кілька кандидатів на змінну одного типу в противаріантних позиціях викликає висновок про тип перетину.


Подивимось, чи це працює.

По-перше, дозвольте мені ввести в дужки ваш текст, FunctionUnionі FunctionIntersectionоскільки TypeScript, схоже, прив'язує об'єднання / перетин більш щільно, ніж функція return:

type FunctionUnion = (() => void) | ((p: string) => void);
type FunctionIntersection = (() => void) & ((p: string) => void);

Тестування:

type SynthesizedFunctionIntersection = UnionToIntersection<FunctionUnion>
// inspects as 
// type SynthesizedFunctionIntersection = (() => void) & ((p: string) => void)

Виглядає добре!

Будьте обережні, щоб загалом UnionToIntersection<>викрити деякі деталі того, що TypeScript вважає справжнім об’єднанням. Наприклад, booleanочевидно, внутрішньо представлений як true | false, так

type Weird = UnionToIntersection<string | number | boolean>

стає

type Weird = string & number & true & false

який у TS3.6 + дуже охоче зменшується до

type Weird = never

тому що неможливо мати значення, яке є string і number та true і false .

Сподіваюся, що це допомагає. Удачі!


14
10x. Я завжди дізнаюся від вас нові цікаві речі. Я був дуже близький щодо цього питання stackoverflow.com/questions/50369299/…, але справді потрібен спосіб перетворити союз на перехрестя
— Тіціан Чернікова-Драгомір

2
Ця відповідь є чудовою, але мені дійсно важко зрозуміти, як працює ця частина "Що розподіляє об'єднання U і перепаковує його в новий об'єднання, де всі конститунти знаходяться в противаріантному положенні " :( Я не можу повністю зрозуміти цю контраваріантну частину положення ... Я думав, що цей код: type Param<T> = T extends (arg: infer U) => void ? U : never; type InferredParams = Param<((a: string) => void) | ((a: number) => void)>;повинен дати мені, string & numberале він дає мені string | number. Чи можете ви пояснити, чому?
— Маріуш Павельський

10
Це тому, що параметри голого типу раніше, ніж extendsв умовному типі, розподіляються між будь-якими складовими об’єднання. Якщо ви хочете відключити розподілених умовних типів, ви можете використовувати трюк зробити параметр типу «одягненого», наприклад, одного елемента кортежу , як це: type Param<T> = [T] extends [(arg: infer U) => void] ? U : never;. Це має працювати так, як ти хочеш.
— jcalz

3
@RanLottem ключ - це розподільні умовні типи . На мою думку, довідник пояснює це досить добре. Я розширив це в іншому місці, де вам потрібна додаткова інформація. Удачі!
— jcalz

1
@NicholasCuthbert будь обережний; unknownє "правильним" результатом. Для всіх Aі B, UTI<A | B>має бути рівним UTI<A> & UTI<B>, так? Нехай Bбуде neverі записка A | neverє A. Тепер у вас є UTI<A> = UTI<A> & UTI<never>для всіх A. Єдиний розумний спосіб задовольнити це UTI<never>= unknown, оскільки X & unknownдорівнює X. Якби UTI<never>були never, тоді UTI<A> = UTI<A> & never, але оскільки X & never= never, ти кажеш UTI<A> = neverдля всіх A... не чудово. Можуть бути випадки використання для UTI<never>бути never, але мені це не очевидно, тому будьте обережні.
— jcalz

6

Існує також дуже пов'язана проблема, коли ви хочете перетину декількох типів, але не обов'язково перетворювати об'єднання в перехрестя. Просто неможливо потрапити на перехрестя, не вдаючись до тимчасових профспілок!

Проблема полягає в тому, що типи, для яких ми хотіли б отримати перетин, можуть мати всередині об’єднання , які також будуть перетворені на перехрестя. Охоронці на допомогу:

// union to intersection converter by @jcalz
// Intersect<{ a: 1 } | { b: 2 }> = { a: 1 } & { b: 2 }
type Intersect<T> = (T extends any ? ((x: T) => 0) : never) extends ((x: infer R) => 0) ? R : never

// get keys of tuple
// TupleKeys<[string, string, string]> = 0 | 1 | 2
type TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>

// apply { foo: ... } to every type in tuple
// Foo<[1, 2]> = { 0: { foo: 1 }, 1: { foo: 2 } }
type Foo<T extends any[]> = {
    [K in TupleKeys<T>]: {foo: T[K]}
}

// get union of field types of an object (another answer by @jcalz again, I guess)
// Values<{ a: string, b: number }> = string | number
type Values<T> = T[keyof T]

// TS won't believe the result will always have a field "foo"
// so we have to check for it with a conditional first
type Unfoo<T> = T extends { foo: any } ? T["foo"] : never

// combine three helpers to get an intersection of all the item types
type IntersectItems<T extends any[]> = Unfoo<Intersect<Values<Foo<T>>>>

type Test = [
    { a: 1 } | { b: 2 },
    { c: 3 },
]

// this is what we wanted
type X = IntersectItems<Test> // { a: 1, c: 3 } | { b: 2, c: 3 }

// this is not what we wanted
type Y = Intersect<Test[number]> // { a: 1, b: 2, c: 3 }

Виконання в наведеному прикладі відбувається так

IntersectItems<[{ a: 1 } | { b: 2 }, { c: 3 }]> =
Unfoo<Intersect<Values<Foo<[{ a: 1 } | { b: 2 }, { c: 3 }]>>>> =
Unfoo<Intersect<Values<{0: { foo: { a: 1 } | { b: 2 } }, 1: { foo: { c: 3 } }}>>> =
Unfoo<Intersect<{ foo: { a: 1 } | { b: 2 } } | { foo: { c: 3 } }>> =
Unfoo<(({ foo: { a: 1 } | { b: 2 } } | { foo: { c: 3 } }) extends any ? ((x: T) => 0) : never) extends ((x: infer R) => 0) ? R : never> =
Unfoo<(({ foo: { a: 1 } | { b: 2 } } extends any ? ((x: T) => 0) : never) | ({ foo: { c: 3 } } extends any ? ((x: T) => 0) : never)) extends ((x: infer R) => 0) ? R : never> =
Unfoo<(((x: { foo: { a: 1 } | { b: 2 } }) => 0) | ((x: { foo: { c: 3 } }) => 0)) extends ((x: infer R) => 0) ? R : never> =
Unfoo<{ foo: { a: 1 } | { b: 2 } } & { foo: { c: 3 } }> =
({ foo: { a: 1 } | { b: 2 } } & { foo: { c: 3 } })["foo"] =
({ a: 1 } | { b: 2 }) & { c: 3 } =
{ a: 1 } & { c: 3 } | { b: 2 } & { c: 3 }

Сподіваємось, це також показує деякі інші корисні методи.

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.