TypeScript

TypeScript 5.2 Bêta

Soumis par fredericmazue le

Microsoft a annoncé la disponbilité de TypeScript 5.2 Bêta, que vous pouvez obtenir via NuGet ou via npm avec la commande suivante : npm install -D typescript@beta

Voici une liste des nouveautés apportées par TypeScript 5.2 :

  • Déclarations using et gestion explicite des ressources
  • Métadonnées des décorateurs
  • Eléments de Tuple nommés ou anonymes
  • Des méthodes plus faciles à utiliser pour les unions de tableaux
  • Complétion de membre d'objet lorsqu'il manque une virgule
  • Refactoring des variable inline

Quelques changements de rupture sont également à remarquer. ceux-ci sont décrits dans le billet de Microsoft qui présente TypeScript 5.2.

TypeScript 5.1 RC

Soumis par fredericmazue le

Microsoft a annoncé la disponiblité de TypeScript 5.1 Release Candidate. Microsoft précise que d'ici à la version stable de TypeScript 5.1, il n'y aura plus de changement, sauf d'éventuelles corrections de bogues critiques.

Depuis la version bêta, Microsoft a corrigé les hooks init dans les décorateurs, car le comportement proposé a été ajusté. Microsoft a également apporté des modifications au compottement d'emit pour isolatedModules afin d'assurer que les scripts ne soient pas réécrits dans les modules. Cela signifie également que l'utilisation de l'API transpileModule garantira également que les fichiers de script ne sont pas interprétés comme des modules, car cela suppose l'utilisation de isolatedModules.

Les nouveautés majeures de TypeScript 5.1 sont les retours implicites pour les fonctions retournant undefined et les accesseurs sans types liés, tels que détaillés ici. 

TypeScript 5.1 bêta

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 5.1 en version beta. Cette mouture se fait principalement remarquer par les retours implicites pour les fonctions retournant undefined, et par les accesseurs sans types liés.

Retours implicites pour les fonctions retournant undefined

En JavaScript si une fonction se termine sans instruction return, elle renvoie la valeur undefined .

function foo() {
    // no return
}
// x = undefined

let x = foo();

Cependant, dans les versions précédentes de TypeScript, les seules fonctions qui ne pouvaient absolument pas avoir d'instructions de retour étaient les fonctions de type retour void ou any. Cela signifiait que même si vous disiez explicitement "cette fonction retourne undefined", vous étiez obligé d'avoir au moins une instruction de retour.

//  fine - we inferred that 'f1' returns 'void'
function f1() {
    // no returns
}

//  fine - 'void' doesn't need a return statement
function f2(): void {
    // no returns
}

//  fine - 'any' doesn't need a return statement
function f3(): any {
    // no returns
}

//  error!
// A function whose declared type is neither 'void' nor 'any' must return a value.
function f4(): undefined {
    // no returns
}

Ce qui pouvait être pénible si certaines API s'attendaient à ce qu'une fonction retourne undefined. Car cela impose d'écrire au moins un retour explicite de undefined ou une instruction et d'une annotation explicite.

declare function takesFunction(f: () => undefined): undefined;

//  error!
// Argument of type '() => void' is not assignable to parameter of type '() => undefined'.
takesFunction(() => {
    // no returns
});

//  error!
// A function whose declared type is neither 'void' nor 'any' must return a value.
takesFunction((): undefined => {
    // no returns
});

//  error!
// Argument of type '() => void' is not assignable to parameter of type '() => undefined'.
takesFunction(() => {
    return;
});

//  works
takesFunction(() => {
    return undefined;
});

//  works
takesFunction((): undefined => {
    return;
});

Pour remédier à cela, tout d'abord TypeScript 5.1 autorise désormais fonction retournant undefiened  à ne pas avoir d'instruction return.

//  Works in TypeScript 5.1!
function f4(): undefined {
    // no returns
}

//  Works in TypeScript 5.1!
takesFunction((): undefined => {
    // no returns
});

Ensuite si une fonction n'a pas d'expression de retour et est transmise à quelque chose qui attend une fonction qui retourne undefined, TypeScript déduit undefined pour le type de retour de cette fonction.

//  Works in TypeScript 5.1!
takesFunction(function f() {
    //                 ^ return type is undefined
 
   // no returns
});

//  Works in TypeScript 5.1!
takesFunction(function f() {
    //                 ^ return type is undefined

    return;
});

Accesseurs sans types liés

TypeScript 4.3 permettait de dire qu'une paire d'accesseurs getet setpouvait spécifier deux types différents.

interface Serializer {
    set value(v: string | number | boolean);
    get value(): string;
}

declare let box: Serializer;

// Allows writing a 'boolean'
box.value = true;

// Comes out as a 'string'
console.log(box.value.toUpperCase());

Ceci avec l'exigence que le type de get soit un sous-type du type de set. Cela signifiait qu'écrire

box.value = box.value;

serait toujours valide.

Cependant, il existe de nombreuses API existantes qui ont des types totalement indépendants entre leurs getters et leurs setters.

TypeScript 5.1 autorise désormais des types complètement indépendants pour les accesseurs, à condition qu'ils aient des annotations de type explicites. Et tandis que cette version de TypeScript ne change pas encore les types pour ces interfaces intégrées, CSSStyleRule peut maintenant être définie de la manière suivante :

interface CSSStyleRule {
    // ...

    /** Always reads as a `CSSStyleDeclaration` */
    get style(): CSSStyleDeclaration;

    /** Can only write a `string` here. */
    set style(newValue: string);

    // ...
}

Cela permet également d'autres modèles comme exiger que les accesseurs set n'acceptent que des données "valides", tout en spécifiant que les accesseurs get peuvent retourner undefined si un état sous-jacent n'a pas encore été initialisé.

class SafeBox {
    #value: string | undefined;

    // Only accepts strings!
    set value(newValue: string) {
    }

    // Must check for 'undefined'!
    get value(): string | undefined {
        return this.#value;
    }
}

TypeScript 5.0 est sorti

Soumis par fredericmazue le

Microsoft a annoncé la sortie de TypeScript 5.0. Selon Microsoft cette nouvelle version du langage le rend plus petit, plus simple et plus rapide. Les deux nouveautés qui nous semblent être les plus importantes sont les décorateurs d'ECMAScript et les paramètres de type const.

Les décorateurs

Les décorateurs sont des fonctions appelées sur des classes, des éléments de classe ou d'autres formes de syntaxe JavaScript. Les décorateurs ont trois capacités principales :

  1. Ils peuvent remplacer la valeur qui est décorée par une valeur correspondante qui a la même sémantique. 
  2. Ils peuvent donner accès à la valeur qui est décorée via des fonctions d'accès qu'ils peuvent ensuite choisir de partager.
  3. Ils peuvent initialiser la valeur qui est décorée, en exécutant du code supplémentaire après que la valeur a été entièrement définie. Dans les cas où la valeur est un membre de la classe, l'initialisation se produit une fois par instance.

Essentiellement, les décorateurs peuvent être utilisés pour métaprogrammer et ajouter des fonctionnalités à une valeur, sans modifier fondamentalement son comportement externe.

Microsoft donne cet exemple :

class Person {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    greet() {
        console.log(`Hello, my name is ${this.name}.`);
    }
}

const p = new Person("Ray");
p.greet();

Supposons qu'à des fins de débogage, on modifie la classe comme ceci :

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }

    greet() {
        console.log("LOG: Entering method.");
        console.log(`Hello, my name is ${this.name}.`);
        console.log("LOG: Exiting method.")
    }
}

C'est quelque chose qu'un développeur fait fréquemment, et qu'il fait et refait avec d'autres méthodes au cours de son travail. Un décorateur va simplifier les choses. On commence par écrire une fonction de remplacement de caractère générique qui sera amenée à remplacer les méthodes dont on veut suivre l'exécution :

function loggedMethod(originalMethod: any, _context: any) {

    function replacementMethod(this: any, ...args: any[]) {
        console.log("LOG: Entering method.")
        const result = originalMethod.call(this, ...args);
        console.log("LOG: Exiting method.")
        return result;
    }

    return replacementMethod;
}

Maintenant loggedMethod peut par exemple décorer la méthode greet de notre classe :

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }

    @loggedMethod
    greet() {
        console.log(`Hello, my name is ${this.name}.`);
    }
}

const p = new Person("Ray");
p.greet();

// Output:
//   LOG: Entering method.
//   Hello, my name is Ray.
//   LOG: Exiting method.

Ainsi la décoration @loggedMethod a remplacé la méthode greet par la fonction loggedMethod

L'implémentation des décorateurs a évolué depuis TypeScript 5.0 bêta. Ainsi les décorateurs peuvent maintenant avant ou après export et export default.

Les paramètres de type const

Lors de la déduction du type d'un objet, TypeScript choisit généralement un type censé être général. Par exemple, dans l'exemple ci-dessous, le type inféré de names est string[]:

type HasNames = { readonly names: string[] };
function getNamesExactly<T extends HasNames>(arg: T): T["names"] {
    return arg.names;
}

// Inferred type: string[]
const names = getNamesExactly({ names: ["Alice", "Bob", "Eve"]});

Cependant, selon ce que la fonction getNamesExactly fait exactement et comment elle est destinée à être utilisée, il peut souvent arriver qu'un type plus spécifique soit souhaité.

Jusqu'à présent, les auteurs d'API devaient généralement recommander d'ajouter as const à certains endroits pour obtenir l'inférence souhaitée :

// The type we wanted:
//    readonly ["Alice", "Bob", "Eve"]
// The type we got:
//    string[]
const names1 = getNamesExactly({ names: ["Alice", "Bob", "Eve"]});

// Correctly gets what we wanted:
//    readonly ["Alice", "Bob", "Eve"]
const names2 = getNamesExactly({ names: ["Alice", "Bob", "Eve"]} as const);

Ce qui est fastidieux et peut entraîner des oublis. Dans TypeScript 5.0, vous pouvez désormais ajouter un modificateur const à une déclaration de paramètre de type pour que l'inférence const-like soit la valeur par défaut :

type HasNames = { names: readonly string[] };
function getNamesExactly<const T extends HasNames>(arg: T): T["names"]
//                       ^^^^^
    return arg.names;
}

// Inferred type: readonly ["Alice", "Bob", "Eve"]
// Note: Didn't need to write 'as const' here
const names = getNamesExactly({ names: ["Alice", "Bob", "Eve"] });

TypeScript 5.0 RC

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 5.0 en Release Candidate. Cette nouvelle mouture majeure du langage le rend, selon Microsoft, plus petit, plus simple et plus rapide. Parmi les nombreuses nouveautés, nous remarquons des décorateurs d'ECMAScript et les paramètres de type const.

Les décorateurs

Les décorateurs sont des fonctions appelées sur des classes, des éléments de classe ou d'autres formes de syntaxe JavaScript. Les décorateurs ont trois capacités principales :

  1. Ils peuvent remplacer la valeur qui est décorée par une valeur correspondante qui a la même sémantique. 
  2. Ils peuvent donner accès à la valeur qui est décorée via des fonctions d'accès qu'ils peuvent ensuite choisir de partager.
  3. Ils peuvent initialiser la valeur qui est décorée, en exécutant du code supplémentaire après que la valeur a été entièrement définie. Dans les cas où la valeur est un membre de la classe, l'initialisation se produit une fois par instance.

Essentiellement, les décorateurs peuvent être utilisés pour métaprogrammer et ajouter des fonctionnalités à une valeur, sans modifier fondamentalement son comportement externe.

Microsoft donne cet exemple :

class Person {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    greet() {
        console.log(`Hello, my name is ${this.name}.`);
    }
}

const p = new Person("Ray");
p.greet();

Supposons qu'à des fins de débogage, on modifie la classe comme ceci :

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }

    greet() {
        console.log("LOG: Entering method.");
        console.log(`Hello, my name is ${this.name}.`);
        console.log("LOG: Exiting method.")
    }
}

C'est quelque chose qu'un développeur fait fréquemment, et qu'il fait et refait avec d'autres méthodes au cours de son travail. Un décorateur va simplifier les choses. On commence par écrire une fonction de remplacement de caractère générique qui sera amenée à remplacer les méthodes dont on veut suivre l'exécution :

function loggedMethod(originalMethod: any, _context: any) {

    function replacementMethod(this: any, ...args: any[]) {
        console.log("LOG: Entering method.")
        const result = originalMethod.call(this, ...args);
        console.log("LOG: Exiting method.")
        return result;
    }

    return replacementMethod;
}

Maintenant loggedMethod peut par exemple décorer la méthode greet de notre classe :

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }

    @loggedMethod
    greet() {
        console.log(`Hello, my name is ${this.name}.`);
    }
}

const p = new Person("Ray");
p.greet();

// Output:
//   LOG: Entering method.
//   Hello, my name is Ray.
//   LOG: Exiting method.

Ainsi la décoration @loggedMethod a remplacé la méthode greet par la fonction loggedMethod

L'implémentation des décorateurs a évolué depuis TypeScript 5.0 bêta. Ainsi les décorateurs peuvent maintenant avant ou après export et export default.

Les paramètres de type const

Lors de la déduction du type d'un objet, TypeScript choisit généralement un type censé être général. Par exemple, dans l'exemple ci-dessous, le type inféré de names est string[]:

type HasNames = { readonly names: string[] };
function getNamesExactly<T extends HasNames>(arg: T): T["names"] {
    return arg.names;
}

// Inferred type: string[]
const names = getNamesExactly({ names: ["Alice", "Bob", "Eve"]});

Cependant, selon ce que la fonction getNamesExactly fait exactement et comment elle est destinée à être utilisée, il peut souvent arriver qu'un type plus spécifique soit souhaité.

Jusqu'à présent, les auteurs d'API devaient généralement recommander d'ajouter as const à certains endroits pour obtenir l'inférence souhaitée :

// The type we wanted:
//    readonly ["Alice", "Bob", "Eve"]
// The type we got:
//    string[]
const names1 = getNamesExactly({ names: ["Alice", "Bob", "Eve"]});

// Correctly gets what we wanted:
//    readonly ["Alice", "Bob", "Eve"]
const names2 = getNamesExactly({ names: ["Alice", "Bob", "Eve"]} as const);

Ce qui est fastidieux et peut entraîner des oublis. Dans TypeScript 5.0, vous pouvez désormais ajouter un modificateur const à une déclaration de paramètre de type pour que l'inférence const-like soit la valeur par défaut :

type HasNames = { names: readonly string[] };
function getNamesExactly<const T extends HasNames>(arg: T): T["names"]
//                       ^^^^^
    return arg.names;
}

// Inferred type: readonly ["Alice", "Bob", "Eve"]
// Note: Didn't need to write 'as const' here
const names = getNamesExactly({ names: ["Alice", "Bob", "Eve"] });

Vous pouvez obtenir TypeScript 5.0 RC sur NuGet avec nmp, comme ceci :

npm install typescript@rc

TypeScript 5.0 bêta prend en charge les décorateurs d'ECMAScript

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 5.0 bêta. Une mouture qui selon Microsoft apporte de nombreuses améliorations pour rendre le langage plus simple et qui réduisent son empreinte mémoire tout en améliorant ses performances. La nouveauté la plus notable de TypeScript 5.0 bêta est la prise en charge des décorateurs d'ECMAScript.

Les décorateurs sont des fonctions appelées sur des classes, des éléments de classe ou d'autres formes de syntaxe JavaScript. Les décorateurs ont trois capacités principales :

  1. Ils peuvent remplacer la valeur qui est décorée par une valeur correspondante qui a la même sémantique. 
  2. Ils peuvent donner accès à la valeur qui est décorée via des fonctions d'accès qu'ils peuvent ensuite choisir de partager.
  3. Ils peuvent initialiser la valeur qui est décorée, en exécutant du code supplémentaire après que la valeur a été entièrement définie. Dans les cas où la valeur est un membre de la classe, l'initialisation se produit une fois par instance.

Essentiellement, les décorateurs peuvent être utilisés pour métaprogrammer et ajouter des fonctionnalités à une valeur, sans modifier fondamentalement son comportement externe.

Microsoft donne cet exemple :

class Person {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    greet() {
        console.log(`Hello, my name is ${this.name}.`);
    }
}

const p = new Person("Ray");
p.greet();

Supposons qu'à des fins de débogage, on modifie la classe comme ceci :

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }

    greet() {
        console.log("LOG: Entering method.");
        console.log(`Hello, my name is ${this.name}.`);
        console.log("LOG: Exiting method.")
    }
}

C'est quelque chose qu'un développeur fait fréquemment, et qu'il fait et refait avec d'autres méthodes au cours de son travail. Un décorateur va simplifier les choses. On commence par écrire une fonction de remplacement de caractère générique qui sera amenée à remplacer les méthodes dont on veut suivre l'exécution :

function loggedMethod(originalMethod: any, _context: any) {

    function replacementMethod(this: any, ...args: any[]) {
        console.log("LOG: Entering method.")
        const result = originalMethod.call(this, ...args);
        console.log("LOG: Exiting method.")
        return result;
    }

    return replacementMethod;
}

Maintenant loggedMethod peut par exemple décorer la méthode greet de notre classe :

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }

    @loggedMethod
    greet() {
        console.log(`Hello, my name is ${this.name}.`);
    }
}

const p = new Person("Ray");
p.greet();

// Output:
//   LOG: Entering method.
//   Hello, my name is Ray.
//   LOG: Exiting method.

Ainsi la décoration @loggedMethod a remplacé la méthode greet par la fonction loggedMethod

Toutes les nouveautés de TypeScript 5.0 bêta sont décrites dans l'annonce de Microsoft.

TypeScript 4.9

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 4.9. Un mouture riche où l'on remarque particulièrement l'arrivée du nouvel opérateur satisfies, l'amélioration de l'opérateur in, et les auto-accesseurs.

Operateur satisfies

Microsoft explique que les développeurs TypeScript sont souvent confrontés à un dilemme : s'assurer qu'une expression correspond à un type, tout en souhaitant également conserver le type le plus spécifique de cette expression à des fins d'inférence.

Microsoft donne cet exemple :

// Each property can be a string or an RGB tuple.
const palette = {
    red: [255, 0, 0],
    green: "#00ff00",
    bleu: [0, 0, 255]
//  ^^^^ sacré bleu - we've made a typo!
};

// We want to be able to use array methods on 'red'...
const redComponent = palette.red.at(0);

// or string methods on 'green'...
const greenNormalized = palette.green.toUpperCase();

il est écrit bleu dans le code, alors que c'est probablement blue qui aurait du être écrit. Il serait possible de gérer cette faute de frappe bleu en utilisant une annotation de type sur palette, mais en perdant alors les informations sur chaque propriété.

type Colors = "red" | "green" | "blue";

type RGB = [red: number, green: number, blue: number];

const palette: Record<Colors, string | RGB> = {
    red: [255, 0, 0],
    green: "#00ff00",
    bleu: [0, 0, 255]
//  ~~~~ The typo is now correctly detected
};

// But we now have an undesirable error here - 'palette.red' "could" be a string.
const redComponent = palette.red.at(0);

Le nouvel opérateur satisfies permet de valider que le type d'une expression correspond à un certain type, sans changer le type résultant de cette expression. A titre d'exemple, on pourrait utiliser satisfies pour valider que toutes les propriétés de palette sont compatibles avec string | number[] :

type Colors = "red" | "green" | "blue";

type RGB = [red: number, green: number, blue: number];

const palette = {
    red: [255, 0, 0],
    green: "#00ff00",
    bleu: [0, 0, 255]
//  ~~~~ The typo is now caught!
} satisfies Record<Colors, string | RGB>;

// Both of these methods are still accessible!
const redComponent = palette.red.at(0);
const greenNormalized = palette.green.toUpperCase();

Operateur in

Microsoft explique qu'en tant que développeurs, nous devons souvent gérer des valeurs qui ne sont pas entièrement connues au moment de l'exécution. En fait, nous ne savons souvent pas si des propriétés existent, si nous obtenons une réponse d'un serveur ou si nous lisons un fichier de configuration. L'opérateur de JavaScript in peut vérifier si une propriété existe sur un objet.

Auparavant, TypeScript nous permettait de restreindre tous les types qui ne répertorient pas explicitement une propriété.

interface RGB {
    red: number;
    green: number;
    blue: number;
}

interface HSV {
    hue: number;
    saturation: number;
    value: number;
}

function setColor(color: RGB | HSV) {
    if ("hue" in color) {
        // 'color' now has the type HSV
    }
    // ...
}

Ici, le type RGB n'a pas listé hue et a été restreint, nous laissant avec le type HSV. Mais qu'en est-il des exemples où aucun type ne mentionne une propriété donnée ? Dans ces cas-là, le langage ne nous a pas beaucoup aidés. Prenons l'exemple suivant en JavaScript :

function tryGetPackageName(context) {
    const packageJSON = context.packageJSON;
    // Check to see if we have an object.
    if (packageJSON && typeof packageJSON === "object") {
        // Check to see if it has a string name property.
        if ("name" in packageJSON && typeof packageJSON.name === "string") {
            return packageJSON.name;
        }
    }

    return undefined;
}

Réécrire cela en TypeScript canonique serait simplement une question de définition et d'utilisation d'un type pour context. Cependant, choisir un type sûr comme unknown pour la propriété packageJSON causerait des problèmes dans les anciennes versions de TypeScript.

En effet, alors que le type de packageJSON est passé de unknown à object, l'opérateur in est strictement limité aux types qui définissaient réellement la propriété vérifiée. En conséquence, le type de packageJSON est resté object.

TypeScript 4.9 rend l'opérateur in un peu plus puissant lors de la réduction des types qui ne répertorient pas du tout la propriété. Au lieu de les laisser tels quels, le langage croisera leurs types avec Record<"property-key-being-checked", unknown>.

Ainsi, dans l'exemple, packageJSON aura son type réduit de unknown à object puis object & Record<"name", unknown>. permet d'accéder directement à packageJSON.name et de le réduire indépendamment

interface Context {
    packageJSON: unknown;
}

function tryGetPackageName(context: Context): string | undefined {
    const packageJSON = context.packageJSON;
    // Check to see if we have an object.
    if (packageJSON && typeof packageJSON === "object") {
        // Check to see if it has a string name property.
        if ("name" in packageJSON && typeof packageJSON.name === "string") {
            // Just works!
            return packageJSON.name;
        }
    }

    return undefined;
}

Auto-accesseurs 

Les auto-accesseurs sont une fonctionnalité à venir dans ECMAScript appelée auto-accessors. Les auto-accesseurs sont déclarés comme les propriétés sur les classes, sauf qu'ils sont déclarés avec le mot clé accessor. Par exemple :

class Person {
    accessor name: string;

    constructor(name: string) {
        this.name = name;
    }
} 

Sur le capot, ce mot clé, qui est un sucre syntaxique, provoque la génération de deux accesseurs classiques pour une propriété privée.

class Person {
    #__name: string;

    get name() {
        return this.#__name;
    }
    set name(value: string) {
        this.#__name = name;
    }

    constructor(name: string) {
        this.name = name;
    }
}

TypeScript 4.9 RC apporte les auto-accessors

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de TypeScript 4.9 en version Release Candidate. Lors de la sortie de TypeScript 4.9 Bêta, nous vous avions parlé de l'arrivée du nouvel opérateur satisfies qui répond à une problématique courante en programmation TypeSctipt : s'assurer qu'une expression correspond à un type, tout en souhaitant également conserver le type le plus spécifique de cette expression à des fins d'inférence.

Pour cela, le nouvel opérateur satisfies permet de valider que le type d'une expression correspond à un certain type, sans changer le type résultant de cette expression.

TypeScript 4.9 RC se fait remarquer par la prise en charge en charge d'une fonctionnalité à venir dans ECMAScript appelée auto-accessors. Les auto-accesseurs sont déclarés comme les propriétés sur les classes, sauf qu'ils sont déclarés avec le mot clé accessor. Par exemple :

class Person {
    accessor name: string;

    constructor(name: string) {
        this.name = name;
    }
} 

Sur le capot, ce mot clé, qui est un sucre syntaxique, provoque la génération de deux accesseurs classiques pour une propriété privée.

class Person {
    #__name: string;

    get name() {
        return this.#__name;
    }
    set name(value: string) {
        this.#__name = name;
    }

    constructor(name: string) {
        this.name = name;
    }
}

Microsoft fête les 10 ans de TypeScript

Soumis par fredericmazue le

TypeScript est un langage de programmation libre et open source développé par Microsoft qui a pour but d'améliorer et de sécuriser la production de code JavaScript. Le code TypeScript est transcompilé en JavaScript, et peut ainsi être interprété par n'importe quel navigateur web ou moteur JavaScript. TypeScript a été cocréé par Anders Hejlsberg, principal concepteur de C# à Redmond, et aussi de Turbo Pascal et Delphi lorsqu'il travaillait chez Borland. Anders Hejlsberg a rejoint Microsoft en 1996.

TypeScript a été rendu public le 1er octobre 2012 , après deux ans de développement interne chez Microsoft.

Pour l'occasion Microsoft revient sur la genèse de TypeScript dans un billet. Microsoft souligne, c'est de bonne guerre, que dans les enquêtes et les classements de langages comme l'enquête annuelle de StackOverflow, le rapport Octoverse de GitHub et le classement des langages de Redmonk, TypeScript s'est toujours classé dans le top 10 (sinon 5) des langages les plus utilisés et les plus appréciés. Mais Microsoft passe sous silence le fait que TypeScript n'est qu'à la position 40 de l'index TIOBE.

TypeScript 4.9 bêta apporte le nouvel opérateur satisfies

Soumis par fredericmazue le

Microsoft a annoncé a disponibilité de de TypeScript 4.9 bêta, une mouture dont la nouveauté la plus remarquable est l'arrivée d'un nouvel opérateur : satisfies, ainsi que l'amélioration de l'opérateur in.

Operateur satisfies

Microsoft explique que les développeurs TypeScript sont souvent confrontés à un dilemme : s'assurer qu'une expression correspond à un type, tout en souhaitant également conserver le type le plus spécifique de cette expression à des fins d'inférence.

Microsoft donne cet exemple :

// Each property can be a string or an RGB tuple.
const palette = {
    red: [255, 0, 0],
    green: "#00ff00",
    bleu: [0, 0, 255]
//  ^^^^ sacré bleu - we've made a typo!
};

// We want to be able to use array methods on 'red'...
const redComponent = palette.red.at(0);

// or string methods on 'green'...
const greenNormalized = palette.green.toUpperCase();

il est écrit bleu dans le code, alors que c'est probablement blue qui aurait du être écrit. Il serait possible de gérer cette faute de frappe bleu en utilisant une annotation de type sur palette, mais en perdant alors les informations sur chaque propriété.

type Colors = "red" | "green" | "blue";

type RGB = [red: number, green: number, blue: number];

const palette: Record<Colors, string | RGB> = {
    red: [255, 0, 0],
    green: "#00ff00",
    bleu: [0, 0, 255]
//  ~~~~ The typo is now correctly detected
};

// But we now have an undesirable error here - 'palette.red' "could" be a string.
const redComponent = palette.red.at(0);

Le nouvel opérateur satisfies permet de valider que le type d'une expression correspond à un certain type, sans changer le type résultant de cette expression. A titre d'exemple, on pourrait utiliser satisfies pour valider que toutes les propriétés de palette sont compatibles avec string | number[] :

type Colors = "red" | "green" | "blue";

type RGB = [red: number, green: number, blue: number];

const palette = {
    red: [255, 0, 0],
    green: "#00ff00",
    bleu: [0, 0, 255]
//  ~~~~ The typo is now caught!
} satisfies Record<Colors, string | RGB>;

// Both of these methods are still accessible!
const redComponent = palette.red.at(0);
const greenNormalized = palette.green.toUpperCase();

Operateur in

Microsoft explique qu'en tant que développeurs, nous devons souvent gérer des valeurs qui ne sont pas entièrement connues au moment de l'exécution. En fait, nous ne savons souvent pas si des propriétés existent, si nous obtenons une réponse d'un serveur ou si nous lisons un fichier de configuration. L'opérateur de JavaScript in peut vérifier si une propriété existe sur un objet.

Auparavant, TypeScript nous permettait de restreindre tous les types qui ne répertorient pas explicitement une propriété.

interface RGB {
    red: number;
    green: number;
    blue: number;
}

interface HSV {
    hue: number;
    saturation: number;
    value: number;
}

function setColor(color: RGB | HSV) {
    if ("hue" in color) {
        // 'color' now has the type HSV
    }
    // ...
}

Ici, le type RGB n'a pas listé hue et a été restreint, nous laissant avec le type HSV. Mais qu'en est-il des exemples où aucun type ne mentionne une propriété donnée ? Dans ces cas-là, le langage ne nous a pas beaucoup aidés. Prenons l'exemple suivant en JavaScript :

function tryGetPackageName(context) {
    const packageJSON = context.packageJSON;
    // Check to see if we have an object.
    if (packageJSON && typeof packageJSON === "object") {
        // Check to see if it has a string name property.
        if ("name" in packageJSON && typeof packageJSON.name === "string") {
            return packageJSON.name;
        }
    }

    return undefined;
}

Réécrire cela en TypeScript canonique serait simplement une question de définition et d'utilisation d'un type pour context. Cependant, choisir un type sûr comme unknown pour la propriété packageJSON causerait des problèmes dans les anciennes versions de TypeScript.

En effet, alors que le type de packageJSON est passé de unknown à object, l'opérateur in est strictement limité aux types qui définissaient réellement la propriété vérifiée. En conséquence, le type de packageJSON est resté object.

TypeScript 4.9 rend l'opérateur in un peu plus puissant lors de la réduction des types qui ne répertorient pas du tout la propriété. Au lieu de les laisser tels quels, le langage croisera leurs types avec Record<"property-key-being-checked", unknown>.

Ainsi, dans l'exemple, packageJSON aura son type réduit de unknown à object puis object & Record<"name", unknown>. permet d'accéder directement à packageJSON.name et de le réduire indépendamment

interface Context {
    packageJSON: unknown;
}

function tryGetPackageName(context: Context): string | undefined {
    const packageJSON = context.packageJSON;
    // Check to see if we have an object.
    if (packageJSON && typeof packageJSON === "object") {
        // Check to see if it has a string name property.
        if ("name" in packageJSON && typeof packageJSON.name === "string") {
            // Just works!
            return packageJSON.name;
        }
    }

    return undefined;
}