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 compris
let,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: via
importetexportorganiser 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 charge
async/await。 - Gestion des erreurs: via
try/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 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
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
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
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
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
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
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
6. Modules et imports/exports
TypeScript prend en charge la programmation modulaire ; vous pouvez utiliser import et export pour organiser le code.
Export :
Exemple
constructor(public name: string) {}
}
Import :
Exemple
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 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
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
Commentaires multilignes :
Exemple
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
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
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
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
throw new Error("Une erreur s'est produite");
} catch (error) {
if (error instanceof Error) {
console.error(error.message);
}
}