Après la version Beta de TypeScript 5.4, voici la présentation de la version candidate de TypeScript 5.4 (TypeScript 5.4 RC). Cette version se concentre sur les corrections de bogues. D'ici la sortie de la version stable de TypeScript 5.4, Microsoft ne prévoit pas d'autres changements, que des corrections de bogues critiques.Voici une liste rapide des nouveautés de TypeScript 5.4 :
- Préservation du rétrécissement dans les fermetures après les dernières affectations
- Le type utilitaire NoInfer
- Object.groupBy et Map.groupBy
- Support des appels require() dans --moduleResolution bundler et --module preserve
- Attributs et assertions d'importation vérifiés
- Correction rapide pour l'ajout de paramètres manquants
- Dépréciations à venir de la version 5.5
Ces nouveautés n'ont subit aucun changement dans cette version stable. Depuis la bêta, cette version met à jour les nouveaux changements notables de comportement, y compris les restrictions autour de la compatibilité des enums, les restrictions sur le nommage des membres des enums, et les améliorations dans le comportement des types mappés.
Changements à venir suite aux dépréciations de TypeScript 5.0
TypeScript 5.0 a rendu obsolètes les options et comportements suivants :
- charset
- target: ES3
- importsNotUsedAsValues
- noImplicitUseStrict
- noStrictGenericChecks
- keyofStringsOnly
- suppressExcessPropertyErrors
- suppressImplicitAnyIndexErrors
- out
- preserveValueImports
- prepend pour les projets références
- newLine inmplicitemet spécifique à l'OS
Pour continuer à les utiliser, les développeurs utilisant TypeScript 5.0 et d'autres versions plus récentes ont dû spécifier une nouvelle option appelée ignoreDeprecations avec la valeur "5.0".
Cependant, TypScript 5.4 sera la dernière version dans laquelle elles continueront à fonctionner normalement. D'ici TypeScript 5.5 (probablement juin 2024), elles deviendront des erreurs difficiles à corriger, et le code qui les utilise devra être migré.
Changements notables du comportement
Cette section présente un ensemble de changements notables qu'il convient de reconnaître et de comprendre dans le cadre d'une mise à jour. Elle met parfois en évidence des dépréciations, des suppressions et de nouvelles restrictions. Elle peut également contenir des corrections de bogues qui sont des améliorations fonctionnelles, mais qui peuvent également affecter une version existante en introduisant de nouvelles erreurs.
Changements dans lib.d.ts
Les types générés pour le DOM peuvent avoir un impact sur la vérification de type de votre base de code.
Contraintes de type conditionnelles plus précises
Le code suivant n'autorise plus la deuxième déclaration de variable dans la fonction foo.
| Code : | Sélectionner tout |
1 2 3 4 5 6 | type IsArray<T> = T extends any[] ? true : false;
function foo<U extends object>(x: IsArray<U>) {
let first: true = x; // Error
let second: false = x; // Error, but previously wasn't
} |
Mais ce comportement était inexact car il était trop enthousiaste. Même si la contrainte de T n'est pas assignable à Foo, cela ne signifie pas qu'elle ne sera pas instanciée avec quelque chose qui l'est. Le comportement le plus correct est donc de produire un type union pour la contrainte du type conditionnel dans les cas où il n'est pas possible de prouver que T n'étend jamais ou toujours Foo.
TypeScript 5.4 adopte ce comportement plus précis. Ce que cela signifie en pratique, c'est que vous pouvez commencer à trouver que certaines instances de type conditionnel ne sont plus compatibles avec leurs branches.
Réduction plus agressive des intersections entre les variables de type et les types primitifs
TypeScript réduit maintenant les intersections entre les variables de type et les primitives de manière plus agressive, en fonction de la façon dont la contrainte de la variable de type se superpose à ces primitives.
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | declare function intersect<T, U>(x: T, y: U): T & U;
function foo<T extends "abc" | "def">(x: T, str: string, num: number) {
// Was 'T & string', now is just 'T'
let a = intersect(x, str);
// Was 'T & number', now is just 'never'
let b = intersect(x, num)
// Was '(T & "abc") | (T & "def")', now is just 'T'
let c = Math.random() < 0.5 ?
intersect(x, "abc") :
intersect(x, "def");
} |
Amélioration de la vérification des chaînes de caractères avec interpolations
TypeScript vérifie maintenant plus précisément si les chaînes de caractères sont assignables aux emplacements d'un modèle de chaîne de caractères.
| Code : | Sélectionner tout |
1 2 3 4 5 6 | function a<T extends {id: string}>() {
let x: `-${keyof T & string}`;
// Used to error, now doesn't.
x = "-id";
} |
Erreurs lorsque les importations de type seulement entrent en conflit avec les valeurs locales
Auparavant, TypeScript autorisait le code suivant sous isolatedModules si l'importation vers Something ne faisait référence qu'à un type.
| Code : | Sélectionner tout |
1 2 3 | import { Something } from "./some/path";
let Something = 123; |
| Code : | Sélectionner tout |
Import 'Something' conflicts with local value, so must be declared with a type-only import when 'isolatedModules' is enabled.
| Code : | Sélectionner tout |
1 2 3 4 5 | import type { Something } from "./some/path";
// or
import { type Something } from "./some/path"; |
Nouvelles restrictions d'assignabilité des enums
Lorsque deux enums ont les mêmes noms déclarés et les mêmes noms de membres d'enum, ils étaient auparavant toujours considérés comme compatibles ; cependant, lorsque les valeurs étaient connues, TypeScript autorisait silencieusement qu'ils aient des valeurs différentes.
TypeScript 5.4 renforce cette restriction en exigeant que les valeurs soient identiques lorsqu'elles sont connues.
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | namespace First {
export enum SomeEnum {
A = 0,
B = 1,
}
}
namespace Second {
export enum SomeEnum {
A = 0,
B = 2,
}
}
function foo(x: First.SomeEnum, y: Second.SomeEnum) {
// Both used to be compatible - no longer the case,
// TypeScript errors with something like:
//
// Each declaration of 'SomeEnum.B' differs in its value, where '1' was expected but '2' was given.
x = y;
y = x;
} |
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | namespace First {
export declare enum SomeEnum {
A,
B,
}
}
namespace Second {
export declare enum SomeEnum {
A,
B = "some known string",
}
}
function foo(x: First.SomeEnum, y: Second.SomeEnum) {
// Both used to be compatible - no longer the case,
// TypeScript errors with something like:
//
// One value of 'SomeEnum.B' is the string '"some known string"', and the other is assumed to be an unknown numeric value.
x = y;
y = x;
} |
Restrictions sur les noms des membres des enums
TypeScript ne permet plus aux membres d'une énumération d'utiliser les noms Infinity, -Infinity ou NaN.
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 | // Errors on all of these:
//
// An enum member cannot have a numeric name.
enum E {
Infinity = 0,
"-Infinity" = 1,
NaN = 2,
} |
Meilleure préservation des types mappés sur les tuples avec n'importe quels éléments restants
Auparavant, l'application d'un type mappé avec any dans un tuple créait un type d'élément any. Ceci n'est pas souhaitable et est maintenant corrigé.
| Code : | Sélectionner tout |
1 2 3 4 5 | Promise.all(["", ...([] as any)])
.then((result) => {
const head = result[0]; // 5.3: any, 5.4: string
const tail = result.slice(1); // 5.3 any, 5.4: any[]
}); |
Quelles sont les prochaines étapes ?
À ce stade, nous prévoyons très peu de changements pour TypeScript 5.4, hormis des corrections de bogues critiques pour le compilateur et des corrections de bogues mineurs pour le service de langage. Dans les prochaines semaines, nous publierons la première version stable de TypeScript 5.4. Gardez un œil sur notre plan d'itération pour connaître les dates de sortie et plus si vous avez besoin de planifier en fonction de cela.
Sinon, nous nous concentrons principalement sur le développement de TypeScript 5.5, et nous venons de rendre public le plan d'itération de TypeScript 5.5. De même, ce plan d'itération décrit les domaines d'intérêt et les éléments de travail prévus, ainsi que les dates de publication cibles que vous pouvez utiliser pour vos propres plans. De plus, nous facilitons l'utilisation des nightly builds de TypeScript sur npm, et il existe une extension pour utiliser ces nightly releases dans Visual Studio Code.
Sinon, nous nous concentrons principalement sur le développement de TypeScript 5.5, et nous venons de rendre public le plan d'itération de TypeScript 5.5. De même, ce plan d'itération décrit les domaines d'intérêt et les éléments de travail prévus, ainsi que les dates de publication cibles que vous pouvez utiliser pour vos propres plans. De plus, nous facilitons l'utilisation des nightly builds de TypeScript sur npm, et il existe une extension pour utiliser ces nightly releases dans Visual Studio Code.
Et vous ?
Quel est votre avis sur cette version ?Voir aussi :
Microsoft annonce la disponibilité de TypeScript 5.4 Beta, avec l'introduction du type utilitaire NoInfer, mais aussi les changements à venir suite aux dépréciations de TypeScript 5.0 TypeScript a 10 ans ! Joyeux anniversaire. À cette occasion, Microsoft fait le point. L'entreprise revient sur les doutes des premiers jours ainsi que sur l'évolution du langage Cinq vérités inconfortables à propos de TypeScript selon Stefan Baumgartner, auteur de livres sur le langage de programmation