La RC de TypeScript 2.7 est disponible
Et s'accompagne de la vérification d'attribution définie pour les propriétés de classe

Le , par Stéphane le calme, Chroniqueur Actualités
Vérification d'attribution définie pour les propriétés de classe

TypeScript 2.7 introduit un nouvel indicateur appelé --strictPropertyInitialization. Cet indicateur effectue des vérifications pour s'assurer que chaque propriété d'instance d'une classe est initialisée dans
le corps du constructeur ou par un initialiseur de propriété. Par exemple

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
class C { 
    foo: number; 
    bar = "hello"; 
    baz: boolean; 
//  ~~~ 
//  Erreur ! La propriété 'baz' n’a pas d’initialiseur et n'est pas définitivement affecté dans le constructeur. 
    constructor() { 
        this.foo = 42; 
    } 
}

Dans le code précédent, si nous voulons vraiment que baz soit potentiellement indéfini, nous devrions l'avoir déclaré avec le type boolean | undefined.

Il existe certains scénarios dans lesquels les propriétés peuvent être initialisées indirectement (peut-être par une méthode d'assistance ou une bibliothèque d'injection de dépendances), auquel cas
vous pouvez utiliser les nouveaux modificateurs d'assertion d'affectation définie pour vos propriétés.

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class C { 
    foo!: number; 
    // ^ 
    // Remarquez ce '!' modificateur. 
    // Il s’agit là de "l'assertion d'assignation définie" 
  
    constructor() { 
        this.initialize(); 
    } 
  
    initialize() { 
        this.foo = 0; 
    } 
}

Il faut garder à l'esprit que --strictPropertyInitialization sera activé avec d'autres drapeaux de mode --strict, ce qui peut avoir un impact sur votre projet. Vous pouvez définir le paramètre strictPropertyInitialization sur false dans votre compilerOptions de votre fichier tsconfig.json ou sur --strictPropertyInitialization false sur la ligne de commande pour désactiver cette vérification.


Tuples à longueur fixe

Dans TypeScript 2.6 et les versions antérieures, [number, string, string] était considéré comme un sous-type de [number, string]. Cela a été motivé par la nature structurelle de TypeScript; les premier et deuxième éléments d'un [number, string, string] sont respectivement des sous-types des premier et deuxième éléments de [number, string]. Cependant, Microsoft explique qu’après avoir examiné l'utilisation réelle des tuples, son équipe a remarqué que la plupart des situations dans lesquelles cela était permis étaient généralement indésirables.

Aussi, grâce à un pull-request de Tycho Grouwstra, les types de tuples encodent maintenant leur arité dans le type de leur propriété de longueur respective, et les tuples de différentes arités ne sont plus assignables les uns aux autres. Ceci est accompli en tirant parti des types littéraux numériques, qui permettent maintenant aux tuples d'être distincts des tuples de différentes arités.

Conceptuellement, vous pouvez considérer le type [number, string] comme équivalent à la déclaration suivante de NumStrTuple :

Code TypeScript : Sélectionner tout
1
2
3
4
5
interface NumStrTuple extends Array<number | string> { 
    0: number; 
    1: string; 
    length: 2; // en utilisant le type littéral numérique '2' 
}

Étant donné que ce changement provoque une rupture, Microsoft précise que si vous devez recourir au comportement d'origine dans lequel les tuples ne font qu'appliquer une taille minimale, vous pouvez utiliser une déclaration similaire qui ne définit pas explicitement une propriété length, revenant à number.

Code TypeScript : Sélectionner tout
1
2
3
4
interface MinimumNumStrTuple extends Array<number | string> { 
    0: number; 
    1: string; 
}

Microsoft a fait la liste de quelques changements qui peuvent provoquer une rupture mineure, notamment :
  • les tuples ont maintenant des propriétés de longueur numérique fixe ;
  • instanceof et inont désormais un comportement légèrement différent ;
  • les inférences provenant de signatures génériques utilisent désormais des types de contraintes de base de type paramètres au lieu de any ;
  • l'API setSelectionRange accepte désormais uniquement "forward" | "backward" | "none" ;
  • allowSyntheticDefaultImports ne synthétise plus les importations par défaut à partir des fichiers d'implémentation TypeScript (c'est-à-dire .ts et .tsx).


Mise à jour du 01/02/2018 : Microsoft annonce la disponibilité de la version stable de TypeScript 2.7

En plus de ce qui a déjà été apporté par la RC de TypeScript 2.7, Microsoft annonce la disponibilité de plusieurs améliorations et nouveautés. Nous pouvons citer entre autres :

Contrôles de propriété de classe plus stricts
TypeScript 2.7 introduit un nouvel indicateur de rigueur nommé --strictPropertyInitialization!

Cet indicateur s'assure que chaque propriété d'instance d'une classe est définie dans le corps du constructeur ou par un initialiseur de propriété. Dans un sens, il apporte certaines des vérifications d'assignation définies des variables aux propriétés de l'instance dans les classes. Par exemple :

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
class C { 
    foo: number; 
    bar = "hello"; 
    baz: boolean; 
//  ~~~ 
//  Erreur! La propriété 'baz' n'a pas d'initialiseur et n'est pas directement affectée au constructeur. 
    constructor() { 
        this.foo = 42; 
    } 
}
Dans ce qui précède, baz n'a pas été défini et TypeScript signale une erreur. Si nous voulons vraiment que baz soit potentiellement indéfini, nous devrions l'avoir déclaré avec le type boolean | indéfini.

Il existe certains scénarios dans lesquels les propriétés peuvent être initialisées indirectement (peut-être par une méthode d'assistance ou une bibliothèque d'injection de dépendances). Dans ces cas, vous pouvez convaincre le système de types en utilisant les assertions d'assignation définies pour vos propriétés.

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
class C { 
    foo!: number; 
    // ^ 
    // Notez ce point d'exclamation! 
    // C'est le modificateur "d’assertion d'assignation définie". 
    constructor() { 
        this.initialize(); 
    } 
  
    initialize() { 
        this.foo = 0; 
    } 
}
Assertions d'assignation définies

Les assertions d'assignation définies sont une nouvelle syntaxe que vous pouvez utiliser pour convaincre TypeScript qu'une propriété sera définitivement assignée. Mais en plus de travailler sur les propriétés de classe, TypeScript 2.7 vous permet également d'utiliser cette fonctionnalité sur les déclarations de variables !

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
let x!: number[]; 
initialize(); 
x.push(4); 
  
function initialize() { 
    x = [0, 1, 2, 3]; 
}

Source : blog MSDN


Source : blog Microsoft

Et vous ?

Quels sont les changements qui vous intéressent le plus ?


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :
Contacter le responsable de la rubrique Accueil