Structure de base de TypeScript

La structure de base d'un programme TypeScript peut être divisée en plusieurs parties, chacune ayant un objectif spécifique.

Voici les composants courants d'un programme TypeScript :

  • Déclarations: y compris les déclarations de type, les déclarations d'interface, etc.
  • Déclarations de variables: y comprislet, constetvarl'utilisation de.
  • Déclarations de fonctions: y compris les fonctions régulières et les fonctions fléchées.
  • Déclarations de classes: utilisées pour définir des classes et leurs membres.
  • Interfaces et alias de types: décrivent la structure des types.
  • Modularisation: viaimportetexportorganiser le code.
  • Assertions de type: conversion de type forcée.
  • Génériques: rendent le code plus réutilisable.
  • Commentaires: augmentent la lisibilité du code.
  • Inférence de type: déduit automatiquement les types.
  • Gardes de type: restreignent la portée du type.
  • Programmation asynchrone: prend en chargeasync/await。
  • Gestion des erreurs: viatry/catchpour capturer les erreurs.

Les parties ci-dessus forment ensemble la structure de base d'un programme TypeScript, offrant aux développeurs une vérification de type puissante, une structure de code et une maintenabilité.


1. Déclarations

Déclarations de type :TypeScript est un langage à typage statique qui utilise des déclarations de type pour définir les types de variables, fonctions, classes, etc. Les déclarations de type aident à rendre le code plus maintenable et plus lisible.

Exemple

let name: string = "Alice";
let age: number = 30;

Déclarations d'interface :Utilisées pour définir la structure d'un objet, y compris ses propriétés et ses méthodes.

Exemple

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

2. Déclarations de variables

En TypeScript, vous pouvez utiliser let, const et var pour déclarer des variables. Il est recommandé d'utiliser let et const ; var n'est plus recommandé.

Exemple

let age: number = 25;
const pi: number = 3.14;

3. Déclarations de fonctions

Déclarations de fonctions : TypeScript permet de déclarer des fonctions avec des annotations de type, y compris les types de paramètres et les types de retour.

Exemple

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

Fonctions fléchées :TypeScript prend également en charge les fonctions fléchées ES6, en utilisant une syntaxe concise pour déclarer des fonctions.

Exemple

const greet = (name: string): string => "Hello, " + name;

4. Déclarations de classes

TypeScript prend en charge la programmation orientée objet, ce qui vous permet de définir des classes ainsi que leurs méthodes et propriétés.

Exemple

class Person {
    name: string;
    age: number;
   
    constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
    }
   
    greet() {
    return `Hello, my name is ${this.name}`;
    }
}

5. Interfaces et alias de type

Interface : utilisée pour décrire la forme d’un objet ; les interfaces peuvent être héritées et étendues.

Exemple

interface Animal {
    name: string;
    sound: string;
    makeSound(): void;
}

Alias de type :Permet de définir des alias pour les types objet, les types union, les types intersection, et plus encore.

Exemple

type ID = string | number;

6. Modules et imports/exports

TypeScript prend en charge la programmation modulaire ; vous pouvez utiliser import et export pour organiser le code.

Export :

Exemple

export class Person {
    constructor(public name: string) {}
}

Import :

Exemple

import { Person } from './person';

7. Assertions de type

Dans certains cas, TypeScript ne peut pas inférer le type exact d'une variable ; les développeurs peuvent utiliser des assertions de type pour spécifier explicitement le type.

Exemple

let value: any = "hello";
let strLength: number = (value as string).length;

8. Génériques

Les génériques vous permettent d'éviter de spécifier des types concrets lors de la définition de fonctions, d'interfaces ou de classes, en utilisant à la place des espaces réservés qui permettent aux utilisateurs de passer des types spécifiques lors de leur utilisation. Les génériques augmentent la réutilisabilité du code et la sécurité des types.

Exemple

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

9. Commentaires

Les commentaires sont utilisés dans les programmes TypeScript pour expliquer le but et la logique du code, ce qui améliore la lisibilité.

Commentaires sur une seule ligne :

Exemple

// Ceci est un commentaire sur une seule ligne

Commentaires multilignes :

Exemple

/* Ceci est un
commentaire multiligne */


10. Inférence de types

TypeScript déduit automatiquement le type d'une variable dans certaines situations. Par exemple, lorsqu'on déclare une variable et qu'on lui affecte une valeur, TypeScript déduit le type de la variable.

Exemple

let num = 10;  // TypeScript déduit que num est de type number

11. Gardes de type

TypeScript fournit des gardes de type (tels que typeof et instanceof) pour réduire la plage de types des variables à l'exécution.

Exemple

function isString(value: any): value is string {
    return typeof value === 'string';
}

12. Programmation asynchrone

TypeScript prend entièrement en charge la programmation asynchrone ; vous pouvez utiliser la syntaxe async/await pour gérer les opérations asynchrones.

Exemple

async function fetchData(): Promise<string> {
    const response = await fetch("https://example.com");
    const data = await response.text();
    return data;
}

13. Gestion des erreurs

TypeScript permet la gestion des erreurs avec des blocs try/catch, et vous pouvez également utiliser des types pour décrire les types d'erreur.

Exemple

try {
    throw new Error("Une erreur s'est produite");
} catch (error) {
    if (error instanceof Error) {
        console.error(error.message);
    }
}
Autres extensions