TypeScript : Le Couteau Suisse de JavaScript, Corrigeant les Fautes et Renforçant la Sécurité

Rebonjours, chers lecteurs

Dans l’article précédent, nous avons parlé de la manière d’installer TypeScript dans des frameworks tels qu’Angular et React. Aujourd’hui, nous allons aborder les particularités et les caractéristiques que TypeScript met à notre disposition.

Les types simples et spéciaux :

En plus des variables primitives que la plupart des languages de programmation nous propose telle string, number/float et bool. Typescript nous donne la posibilité déclarer explicitement le type d'une variable.

let message: string = "Bonjour";

Non seulement ca, il nous proprose des types spéciaux qui ne référent de types primitives spécifique comme any , unknow, void et never. Le type any désactive complètement le système de typage de TypeScript. Une variable de type any peut contenir n'importe quelle valeur et être manipulée sans restrictions.

let valeur: any = "Bonjour"; 
valeur = 42; // Pas d'erreur Pas vérification :(

Le type unknown est similaire à any, à la différence qu'il bloque les opérations dangereuses tant que son type n'a pas été vérifié. Il est particulièrement utile lorsqu'on ne connaît pas à l'avance les types retournés par une API.

 let x: unknown = "Hello, world!"; // impose une vérification de type avant d effectuer certaines opérations sur la variable. :)

console.log(x.length); 

// Vérification du type avant l'opération
if (typeof x === 'string') {
  console.log(x.length); 
}

Ensuite,nous avons le type void est utilisé pour indiquer qu'une fonction ne retourne aucune valeur. Il est particulièrement utile pour les fonctions qui exécutent une action sans résultat à renvoyer, comme console.log() ou les gestionnaires d'événements (event handlers).

function logMessage(message: string): void {
  console.log(message);
}
let resultat: void = logMessage("Hello"); // La fonction ne retourne rien

Enfin, Le type never représente une valeur qui n'existe jamais. Il est utilisé dans les cas où une fonction ne peut jamais retourner de résultat.

let x: never = true; // Erreur, le type bool n'est pas assignable

Bref aperçu :

Les interfaces aiment les contrats, les types préfèrent les faits !

Contrairement à JavaScript, TypeScript nous offre la possibilité d’utiliser des interfaces, ce qui permet une meilleure réutilisation du code. De plus, les interfaces sont extensibles : elles peuvent être étendues ou implémentées par des classes. Elles sont également capables de fusionner si vous avez plusieurs déclarations de la même interface — une particularité intéressante propre à TypeScript. Et ce n’est pas tout ! Parlons aussi des types, qui offrent encore plus de flexibilité que les interfaces ! N’est-ce pas formidable, chers lecteurs et lectrices ? Avec les types, on peut définir non seulement des objets, mais aussi des types primitifs, des unions, des intersections, des tuples, des fonctions, et bien plus encore.

Maintenant, nous allons voir d'interfaces de type divers exemples concrets :

1. Union Types (Types d'union)

Les types d'union permettent de d'assigner plusieurs types de valeurs à une variable.

function statutCode(code: string | number) {
    console.log(`My status code is ${code}.`)
}
statutCode(404);
statutCode("404")

Utilité des types d'union :

• Flexibilité : Une fonction ou une variable peut accepter plusieurs types de valeurs, ce qui est particulièrement utile lorsqu'on travaille avec des API ou des entrées qui peuvent être de différents types.
• Clarté : En utilisant les types d'union, vous indiquez clairement qu'une variable peut être l'un des types spécifiés, ce qui améliore la lisibilité du code.
• Sécurité : TypeScript peut encore effectuer des vérifications de type, vous protégeant ainsi des erreurs potentielles.

2. Type d'intersection

L'intersection types (ou intersection de types) offre la possibilité de fusionner plusieurs types en un seul. Cela implique qu'une variable ou un objet peut être une combinaison de plusieurs types, ce qui signifie qu'elle doit répondre à toutes les exigences des types fusionnés.

//Classe Élève
type Élève = {
    nom: string;
    age: number;
};
//Classe SalledeClasse
type SalledeClasse = {
    nomClasse: number;
    typeClasse: string;
    
};
type  = Élève & SalledeClasse;

const nouvelleÉlève: ÉlèveDetails = {
    name: "John Doe",
    age: 12,
    nomClasse: 1234,
    typeClasse: "Algèbre I"
};

Utilité des types d'intersections :

• Composabilité : L'intersection des types vous offre la possibilité de fusionner plusieurs types pour concevoir des types plus sophistiqués. C'est parfait quand un objet ou une variable doit avoir plusieurs caractéristiques de divers types
• Conformité aux contrats : Un variable ou un objet doit satisfaire à toutes les contraintes des types combinés, assurant ainsi une plus stricte observance des exigences de données ou d'interfaces.
• Modélisation de structures complexes : Quand vous manipulez des éléments nécessitant des caractéristiques de divers types ou interfaces, les intersections offrent une façon claire et rigoureuse d'imposer cette exigence.

Bien évidemment, chers lecteurs, TypeScript nous offre en plus des types personnalisés et de nombreuses fonctionnalités qui faciliteront votre expérience en programmation. Donc, je vous invite à consulter la documentation de TypeScript pour en savoir plus.

Références :

• W3Schools TypeScript Tutorial https://www.w3schools.com/typescript/index.php (Page consultée le 28 février 2025).
• TatvaSoft JavaScript vs TypeScript : Key Comparison https://www.tatvasoft.com/blog/javascript-vs-typescript/ (Page consultée le 28 février 2025)
• Kinsta Qu’est-ce que TypeScript ? Un guide complet https://kinsta.com/fr/base-de-connaissances/guide-complet-typescript/ (Page consultée le 28 février 2025)
• Typescript TypeScript Documentation (https://www.typescriptlang.org/docs/ (Page consultée le 28 février 2025)
• The Software House How to speed up a TypeScript project (https://www.typescriptlang.org/docs/ (Page consultée le 28 février 2025)