przepływu: Tworzenie typu przepływu przez rozszerzenie inny rodzaj

Question

type someType = { 
    keyOne: string, 
    keyTwo: string, 
}; 

type someOtherType = { 
    keyOne: string, 
    keyTwo: string, 
    keyThree: string, 
}; 

oba typy są przedmioty, które zawierają keyOne i keyTwo, jedyną różnicą jest to ostatni rozciąga tej pierwszej w dodatkowy klucz keyThree.

Zamiast pisać powielony kod, można zbudować typ przepływu someOtherType przez rozszerzenie someType? W moim umyśle przychodzi mi na myśl spoczynkowy obiekt ES6, ale nie jestem pewien, jak osiągnąć coś takiego w Flow.

Dzięki!

Answer 1

To, czego szukasz, to intersection type. Zgodnie z dokumentacją:

Typ przecięcia wymaga podania wartości wszystkich typów danych wejściowych.

składni: przecięcie: < typu 1> & < typu 2> ... & < typu n>

typ skrzyżowania jest rozszerzenie istniejącego typu i dodatkowe wymagania typu do niego.

type someType = { 
    keyOne: string, 
    keyTwo: string 
} 

type someOtherType = someType & { 
    keyThree: string 
} 

const shouldBeOk: someOtherType = { 
    keyOne: 'biz', 
    keyTwo: 'buzz', 
    keyThree: 'baz', 
} 

const shouldError: someOtherType = { 
    keyOne: 123, 
    keyTwo: 'hello', 
    keyThree: 'world', 
} 

// flow error: 
16: const shouldError: someOtherType = { 
          ^object literal. This type is incompatible with 
8: type someOtherType = someType & { 
         ^object type 

Logicznym przeciwieństwem typu przecięcia jest union type. Zgodnie z dokumentacją:

Typ unii wymaga, aby wartość była jednym z typów danych wejściowych.

Składnia: Union: < typ 1> | < typ 2> ... | < typ n>

Jako przykład. możesz użyć typu unii, aby utworzyć przelicznik.

type fooBarBazType = 'foo' | 'bar' | 'baz'; 
const shouldBeOk: fooBarBazType = 'bar'; 

const shouldError: fooBarBazType = 'buzz'; 

4: const shouldError: fooBarBazType = 'buzz'; 
            ^string. This type is incompatible with 
4: const shouldError: fooBarBazType = 'buzz'; 
        ^string enum