Introduction à la syntaxe TypeScript

Introduction to TypeScript Syntax

• TypeScript étend JavaScript en ajoutant la typage statique. Ceci permet une meilleure organisation du code, une détection précoce des erreurs et une meilleure maintenabilité, surtout dans les projets plus importants.

Variable Declaration

• Les variables en TypeScript sont déclarées en utilisant les mots clés let, const, ou var, de manière similaire à JavaScript. Cependant, var est généralement déconseillé pour sa portée de fonction.
• let et const ont une portée de bloc.
• Les annotations de type sont essentielles pour TypeScript. Elles précisent le type de données attendu d'une variable.
  • Exemple: let age: number = 30; déclare une variable de type number.

Data Types

• TypeScript prend en charge divers types de données:
  • string (ex: let name: string = "Alice";)
  • number (ex: let age: number = 30;)
  • boolean (ex: let isStudent: boolean = true;)
  • any (ex: let value: any = "Hello";) - moins utile et à éviter si possible
  • null et undefined (ex: let result: null | undefined = null;) - la gestion explicite de ces valeurs est souvent bénéfique (types d'union).
  • array: let numbers: number[] = [1, 2, 3]; ou let strings: Array<string> = ["a", "b"]; – définit un tableau.
  • tuple: let coordinate: [number, number] = [10, 20]; – définit un tableau de longueur fixe de types différents.
  • enum: Permet de définir des ensembles de constantes nommées. Un moyen utile de représenter des codes d'état ou d'autres valeurs fixes.
    • Exemple: enum Color { Red, Green, Blue }
  • object: Structures de données complexes. Des types peuvent être définis pour celles-ci.
  • void: Indique qu'une fonction ne retourne rien. Pour les fonctions qui ne sont pas censées renvoyer de valeurs.
  • never: Un type qui n'apparaît jamais. Par exemple, les fonctions qui lancent toujours des erreurs.

Interfaces

• Les interfaces définissent la structure des objets.
• Elles précisent les propriétés et leurs types.
• Elles sont utiles pour imposer des formes de données cohérentes.

interface Person {
    name: string;
    age: number;
}

Classes

• Les classes en TypeScript permettent de définir des structures d'objets personnalisées.
• Les propriétés et les méthodes sont définies dans la classe.

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    sound(): string { return "Son générique"; }
}

Fonctions

• Les fonctions en TypeScript peuvent avoir des types pour les paramètres et les valeurs de retour.

function greet(name: string): string {
    return "Bonjour, " + name + "!";
}

Union Types

• Les types d'union permettent à une variable de contenir plusieurs types.

let id: number | string = 123;

- Permet d'assigner des valeurs d'un type ou d'un autre à une variable dans une portée spécifique. Utile pour combiner des valeurs.

Intersection Types

• Les types d'intersection combinent les propriétés de plusieurs types.

interface Shape {
    color: string;
}

interface Size {
    width: number;
    height: number;
}

type ColorfulSize = Shape & Size;

let square: ColorfulSize = {
  color: "Red",
  width: 10,
  height: 10
};

• Combine les propriétés et fonctions se chevauchant de différents types. Utile pour implémenter des types plus robustes à partir de plusieurs composants ou traits.

Generics

• Les génériques permettent de créer des composants réutilisables qui peuvent fonctionner avec différents types.

function identity<T>(arg: T): T {
    return arg;
}

• Utile pour écrire des composants réutilisables qui peuvent fonctionner sur divers types; implique souvent des placeholders pour les types de données, ce qui permet une application plus large dans votre code.

Type Aliases

• Les alias de type fournissent un nom alternatif pour des types existants.

type ID = number | string;

• Permet de créer des noms de type plus descriptifs. Aide à rendre les structures de types longues et complexes plus lisibles.

Commentaires

• Les commentaires sur une seule ligne commencent par //.
• Les commentaires sur plusieurs lignes sont entre /* */.

Modules

• Les modules organisent le code en unités réutilisables.
• TypeScript prend en charge les modules similaires aux modules ES6, permettant le partage de code entre des projets et d'autres applications.

Modificateurs d'accès

• public, private, et protected contrôlent l'accessibilité des membres de classe.

Opérateur de coalescence nullish (??)

• L'opérateur de coalescence nullish (??) retourne l'opérande de droite si l'opérande de gauche est null ou undefined.

let result = value ?? defaultValue;

Opérateur de chaînage optionnel (?.)

• L'opérateur de chaînage optionnel (?.) accède aux propriétés d'objets imbriqués en toute sécurité sans générer d'erreur si une propriété est null ou undefined.

let val = obj?.prop1?.prop2;

Unions Discriminées

• Utilisées pour définir des propriétés communes qui permettent de différencier les types au sein d'une union. Souvent couplées avec des types conditionnels pour gérer des types différents au sein de la même structure.

Ce quiz explore la syntaxe de TypeScript, un langage qui étend JavaScript avec le typage statique. Il couvre la déclaration de variables, les types de données et les annotations de type essentielles pour la programmation efficace. Testez vos connaissances sur ces concepts clés pour améliorer vos compétences en développement.