TypeScript 4.8 officiellement publié

TypeScript 4.8 est officiellement sorti.

Changements depuis les versions bêta et RC

Depuis la version bêta , la version stable prend désormais en charge l'exclusion de fichiers spécifiques de l'importation automatique . L'annonce de la version bêta ne faisait aucune mention de modifications importantes concernant les alias de déstructuration inutilisés dans les signatures de type. De plus, ni la version bêta ni les annonces de version RC ne décrivent les changements de rupture de l'API dans les décorateurs d'arbre de syntaxe TypeScript. Ceux-ci sont détaillés dans l'annonce de la nouvelle version.

changements majeurs

Améliorations de la restriction de type pour les types d'intersection et les types d'union

La version TypeScript 4.8 a d' autres améliorations, principalement dans l'expression des types d'union et des types d'intersection, et le rétrécissement des types. --strictNullChecks

Par exemple, en tant que Top Type dans le système de type TypeScript, le type unknown inclut tous les autres types. En fait, l'effet de unknown et unknown est le même : la signification unique des types nuls et indéfinis, plus l'origine de toutes choses . {} | null | undefined {}

déduire l'extraction dans le type de chaîne de modèle

Dans la version 4.7, TypeScript prend en charge la syntaxe d'extension infer, de sorte que nous pouvons déduire directement la valeur du type attendu en une seule étape, sans avoir à juger à nouveau l'instruction conditionnelle :

type FirstString<T> =
    T extends [infer S, ...unknown[]]
        ? S extends string ? S : never
        : never;

// 基于 infer extends
type FirstString<T> =
    T extends [infer S extends string, ...unknown[]]
        ? S
        : never;

La version 4.8 améliore encore cela. Lorsque infer est contraint d'être un type primitif, il déduit désormais autant que possible les informations de type de infer au niveau du type littéral :

// 此前为 number，现在为 '100'
type SomeNum = "100" extends `${infer U extends number}` ? U : never;

// 此前为 boolean，现在为 'true'
type SomeBool = "true" extends `${infer U extends boolean}` ? U : never;

En même temps, TypeScript vérifiera si la valeur extraite peut être remappée vers la chaîne d'origine. Par exemple, SomeNum vérifiera si elle est égale à . Dans l'exemple suivant, elle ne peut être déduite que du type numérique car elle ne peut pas être remappé en arrière : String(Number("100")) "100"

// String(Number("1.0")) → "1"，≠ "1.0"
type JustNumber = "1.0" extends `${infer T extends number}` ? T : never;

Déduction de type dans les types liés

Le remplissage générique dans TypeScript est également affecté par son appelant, comme dans l'exemple suivant :

declare function chooseRandomly<T>(x: T,): T;

const res1 = chooseRandomly(["linbudu", 599, false]);

À ce stade, le type de res1 et le T générique de la fonction seront déduits comme , mais si nous changeons de méthode : Array<string | number | boolean>

declare function chooseRandomly<T>(x: T,): T;

const [a, b, c] = chooseRandomly(["linbudu", 599, false]);

À ce stade, a, b et c sont déduits en tant que types chaîne, nombre et booléen, ce qui signifie que le type générique de la fonction est rempli avec un tel type de tuple. [string, number, boolean]

Cette façon de remplir les génériques s'appelle Binding Pattern, et dans la version 4.8, la déduction de type basée sur le modèle de liaison est désactivée car son effet sur les génériques n'est pas toujours correct :

declare function f<T>(x?: T): T;

const [x, y, z] = f();

Voir l'annonce de sortie pour plus de détails .

TypeScript 4.8 officiellement publié

Guess you like