Блог

Я не в состоянии полностью понять использование ключевого слова extends в случае типов объединения. Вот фрагмент кода, объясняющий возникшую у меня путаницу.

 class SomeClass {
    someClassProp: string;
};

class SomeExtendedClass extends SomeClass {
    someExtendedClassProp: string;
};

function someClassFunction<T extends SomeClass>(args: T): T {
    return args;
};

let someClass: SomeClass, someExtendedClass: SomeExtendedClass;

someClassFunction(someClass);
someClassFunction(someExtendedClass); // Works just fine(case 1)

type someType = 'a' | 'b';
type someExtendedType = someType | 'c';

function someTypeFunction<T extends someType>(args: T): T {
    return args;
};

let someType: someType, someExtendedType: someExtendedType;

someTypeFunction(someType);
someTypeFunction(someExtendedType); // Gives me an error(case 2)
  

Итак, мне было интересно, почему принимаются такие дизайнерские решения и каковы их последствия.

изменение function someTypeFunction<T extends someType>(args: T): T {return args;}; на function someTypeFunction<T extends someExtendedType>(args: T): T {return args;};
работает, но я не могу понять, как эта штука на самом деле работает.

РЕДАКТИРОВАТЬ 1

 type someType = 'a' | 'b';
type someOtherType = 'c';
type someUnionType = someType | someOtherType;

type someTypeCore<T extends someUnionType> = { type: T };

type someTypeObj<T extends someType> = { a: string } amp; someTypeCore<T>;
type someOtherTypeObj<T extends someOtherType> = { b: string, c: string } amp; someTypeCore<T>;

function typeAssertion<T extends someUnionType>(args: someTypeCore<T>): args is someTypeObj<T> {
    return (args as someTypeObj<T>).a !== undefined; // Gives an error
};

function someTypeFunction<T extends someUnionType>(args: someTypeCore<T>): T {
    if (typeAssertion(args)) {
        // Do something for someTypeObj 
    } else {
        // Do Something for someOtherTypeObj 
    };
    return args.type;
};
  

Как нам решить эту проблему.

extends В функции сохраняется T значение подтипа указанного типа. То, что означает подтип, может быть немного неожиданным для объединений.

Вы должны подумать о том, что на самом деле означает отношение подтипа. Когда мы говорим, что это SomeExtendedClass подкласс SomeClass , подразумевается, что любой экземпляр SomeExtendedClass также является экземпляром SomeClass

Итак, набор всех SomeClass экземпляров содержит набор всех SomeExtendedClass экземпляров.

Но если мы применим этот взгляд на подтипы к объединениям, мы увидим, что объединение с меньшим количеством членов ( "a" | "b" ) на самом деле является подтипом объединения с большим количеством членов ( "a" | "b" | "c" ), поскольку все экземпляры "a" | "b" являются экземплярами "a" | "b" | "c" .

Мы интуитивно думаем, что подтип — это тот, в котором «больше материала», но когда мы думаем о объединениях, эта интуиция подводит нас, нам нужно подумать об отношениях подтипов в терминах множеств.