Types de base de TypeScript
Les types de base permettent aux développeurs de décrire plus précisément la structure et l'intention des données.
Les types de données inclus dans TypeScript sont les suivants :
| Type | Description | Exemple |
|---|---|---|
string | Représente des données textuelles | let name: string = "Alice"; |
number | Représente des nombres, y compris les entiers et les nombres à virgule flottante | let age: number = 30; |
boolean | Représente une valeur booléennetrueoufalse | let isDone: boolean = true; |
array | Représente un tableau d'éléments du même type | let list: number[] = [1, 2, 3]; |
tuple | Représente un tableau dont les types et la longueur sont connus | let person: [string, number] = ["Alice", 30]; |
enum | Définit un ensemble de constantes nommées | enum Color { Red, Green, Blue }; |
any | Type quelconque, sans vérification de type | let value: any = 42; |
void | Aucune valeur de retour (souvent utilisée pour les fonctions) | function log(): void {} |
null | Représente une valeur vide | let empty: null = null; |
undefined | Représente undefined | let undef: undefined = undefined; |
never | Représente l'absence de valeur de retour | function error(): never { throw new Error("error"); } |
object | Représente des types non primitifs | let obj: object = { name: "Alice" }; |
union | Type union, signifiant qu'il peut être l'un de plusieurs types | `let id: string |
unknown | Type incertain, nécessite une vérification de type avant utilisation | let value: unknown = "Hello"; |
Remarque :TypeScript et JavaScript n'ont pas de type entier.
1. string
Représente des données textuelles ; ne peut stocker que des chaînes de caractères, généralement utilisé pour décrire des informations textuelles.
let message: string = "Hello, TypeScript!";
Chaînes de caractères modèles :TypeScript prend en charge leschaînes de caractères modèles, qui utilisent des accents graves`(rappelez-vous, pas des guillemets simples ') pour les définir, permettant d'insérer des variables ou des expressions dans des chaînes de caractères. Elles sont idéales pour le texte multiligne et la concaténation de variables.
let name: string = "Alice";
let greeting: string = `Hello, ${name}! Welcome to TypeScript.`;
console.log(greeting); // 输出:Hello, Alice! Welcome to TypeScript.
2. number
TypeScript utilise le type number pour représenter tous les nombres, y compris les entiers et les nombres à virgule flottante.
let age: number = 25; let temperature: number = 36.5;
3. boolean
Représente les valeurs logiques true ou false, utilisées pour les jugements conditionnels.
let isCompleted: boolean = false;
4. array
Il peut représenter un groupe d'éléments du même type. Il peut être exprimé de deux manières : type[] ou Array<type>.
let numbers: number[] = [1, 2, 3]; let names: Array<string> = ["Alice", "Bob"];
5. tuple
Représente un tableau avec un nombre connu et des types d'éléments. Chaque élément peut être d'un type différent, ce qui convient pour représenter des données avec une structure fixe.
let person: [string, number] = ["Alice", 25];
6. enum
Utilisé pour définir un ensemble de constantes nommées. Par défaut, les valeurs enum commencent à 0 et augmentent.
enum Color {
Red,
Green,
Blue,
}
let favoriteColor: Color = Color.Green;
7. any
Il peut représenter n'importe quel type. Il convient aux cas où le type de données est incertain, mais doit être utilisé avec prudence, car any contourne la vérification de type.
let randomValue: any = 42; randomValue = "hello";
Le type any est un type de données utilisé par TypeScript pour les variables dont le type n'est pas clair pendant la programmation. Il est couramment utilisé dans les trois situations suivantes.
1. Lorsque la valeur d'une variable change dynamiquement, par exemple une saisie de l'utilisateur, le type any permet à ces variables d'ignorer la vérification de type pendant la phase de compilation. L'exemple de code est le suivant :
let x: any = 1; // 数字类型 x = 'I am who I am'; // 字符串类型 x = false; // 布尔类型
Lors de la réécriture de code existant, any permet d'inclure ou de supprimer sélectivement la vérification de type pendant la compilation. L'exemple de code est le suivant :
let x: any = 4; x.ifItExists(); // 正确,ifItExists方法在运行时可能存在,但这里并不会检查 x.toFixed(); // 正确
Lors de la définition d'un tableau qui stocke des données de types divers, l'exemple de code est le suivant :
let arrayList: any[] = [1, false, 'fine']; arrayList[1] = 100;
8. void
Utilisé pour les fonctions sans valeur de retour. Lors de la déclaration d'une variable, le type void signifie qu'elle ne peut être affectée qu'à null ou undefined.
function logMessage(message: string): void {
console.log(message);
}
9. null et undefined
null et undefined représentent respectivement « valeur vide » et « indéfini ». Par défaut, ils sont des sous-types de tous les types, mais une vérification stricte peut être activée en définissant strictNullChecks.
let empty: null = null; let notAssigned: undefined = undefined;
null
En JavaScript, null signifie « rien ».
null est un type spécial avec une seule valeur. Il représente une référence à un objet vide.
L'utilisation de typeof pour détecter null renvoie « object ».
undefined
En JavaScript, undefined est une variable à laquelle aucune valeur n'a été affectée.
Appeler typeof sur une variable sans valeur renvoie undefined.
null et undefined sont des sous-types de tous les autres types (y compris void), et peuvent être assignés à d'autres types, tels que number. Dans ce cas, le type après l'affectation devient null ou undefined. Toutefois, lorsque la fonctionnalité de vérification stricte de null (--strictNullChecks) est activée dans TypeScript, null et undefined ne peuvent être assignés qu'à void ou à leurs propres types correspondants. Exemple de code :
// 启用 --strictNullChecks let x: number; x = 1; // 编译正确 x = undefined; // 编译错误 x = null; // 编译错误
Dans l'exemple ci-dessus, la variable x ne peut être que de type number. Si un type peut être null ou undefined, vous pouvez utiliser | pour prendre en charge plusieurs types. Exemple de code :
// 启用 --strictNullChecks let x: number | null | undefined; x = 1; // 编译正确 x = undefined; // 编译正确 x = null; // 编译正确
Pour plus d'informations, voir :JavaScript typeof, null et undefined
10. never
Représente l'absence de valeur de retour ; généralement utilisé pour les fonctions qui lèvent des erreurs ou entrent dans des boucles infinies, ce qui signifie que la fonction ne se termine jamais normalement.
function throwError(message: string): never {
throw new Error(message);
}
never est un sous-type de tous les autres types (y compris null et undefined), représentant des valeurs qui ne se produisent jamais. Cela signifie qu'une variable déclarée comme le type never ne peut se voir assigner qu'une valeur de type never. Dans les fonctions, cela se manifeste généralement par le fait de lever une exception ou de ne pas atteindre un point de terminaison (par exemple, une boucle infinie). Exemple de code :
let x: never;
let y: number;
// 编译错误,数字类型不能转为 never 类型
x = 123;
// 运行正确,never 类型可以赋值给 never类型
x = (()=>{ throw new Error('exception')})();
// 运行正确,never 类型可以赋值给 数字类型
y = (()=>{ throw new Error('exception')})();
// 返回值为 never 的函数可以是抛出异常的情况
function error(message: string): never {
throw new Error(message);
}
// 返回值为 never 的函数可以是无法被执行到的终止点的情况
function loop(): never {
while (true) {}
}
11. object
Représente des valeurs non primitives, adaptées aux structures d'objets complexes.
let person: object = { name: "Alice", age: 30 };
12. Types union
Indique qu'une variable peut être de l'un de plusieurs types. Implémenté à l'aide du symbole |.
let id: string | number; id = "123"; id = 456;
13. unknown (type incertain)
Similaire à any, mais plus strict. Il doit être vérifié au niveau du type avant de pouvoir être affecté à des variables d'autres types.
let value: unknown = "Hello";
if (typeof value === "string") {
let message: string = value;
}14. Assertions de type
Les assertions de type permettent aux développeurs d'indiquer explicitement au compilateur le type d'une variable, souvent utilisées lorsque le type ne peut pas être inféré. La syntaxe as ou la syntaxe avec chevrons peut être utilisée.
let someValue: any = "this is a string"; let strLength: number = (someValue as string).length;
15. Types littéraux
Les types littéraux permettent à une variable de n'avoir que des valeurs spécifiques, et sont utilisés conjointement avec les types union pour définir des états spécifiques d'une variable.
let direction: "up" | "down" | "left" | "right"; direction = "up";
Grâce à ces types, TypeScript offre une sécurité de type et des capacités de vérification du code plus fortes, permettant aux développeurs d'exprimer les données et l'intention plus clairement et précisément, réduisant ainsi les erreurs d'exécution.
Exemple
L'exemple suivant illustre la définition et l'utilisation des principaux types de base en TypeScript, en simulant un objet utilisateur et les fonctions d'opération associées.
Exemple
enum Role {
Admin,
Utilisateur,
Guest,
}
// Utiliser une interface pour définir la structure de l'utilisateur
interface User {
id: number; // type number, utilisé pour identifier l'utilisateur de manière unique
username: string; // type string, représentant le nom d'utilisateur
isActive: boolean; // type boolean, indiquant si l'utilisateur est actif
role: Role; // type enum, utilisé pour représenter le rôle de l'utilisateur
hobbies: string[]; // type array, stockant les hobbies de l'utilisateur
contactInfo: [string, number]; // type tuple, un tuple contenant un numéro de téléphone, au format : [indicatif régional, numéro de téléphone]
}
// Créer un objet utilisateur conforme à la structure de l'interface User
const user: User = {
id: 1,
username: "Alice",
isActive: true,
role: Role.User,
hobbies: ["Reading", "Gaming"],
contactInfo: ["+1", 123456789],
};
// Définir une fonction qui renvoie une chaîne de caractères pour obtenir les informations de l'utilisateur
function getUserInfo(user: User): string {
return `Utilisateur ${user.username} est ${user.isActive ? "actif" : "inactif"} avec le rôle ${Role[user.role]}`;
}
// Utiliser le type void pour définir une fonction qui affiche spécifiquement les informations de l'utilisateur
function printUserInfo(user: User): void {
console.log(getUserInfo(user));
}
// Définir un paramètre de fonction de type union, acceptant un ID utilisateur (number) ou un nom d'utilisateur (string)
function findUser(query: number | string): User | undefined {
// Utiliser typeof pour déterminer le type de query
if (typeof query === "number") {
// S'il s'agit d'un nombre, trouver l'utilisateur par ID
return query === user.id ? user : undefined;
} else if (typeof query === "string") {
// S'il s'agit d'une chaîne, trouver l'utilisateur par username
return query === user.username ? user : undefined;
}
return current;
}
// Définir une fonction de type never pour gérer les situations anormales dans le programme
function throwError(message: string): never {
throw new Error(message);
}
// Utiliser le type any pour gérer les données de type inconnu
let unknownData: any = "This is a string";
unknownData = 42; // Réaffecter à un nombre, le type est any
// Utiliser le type unknown pour gérer les données incertaines, ce qui est plus sûr
let someData: unknown = "Possible data";
if (typeof someData === "string") {
console.log(`Longueur des données: ${(someData as string).length}`);
}
// Appeler chaque fonction et tester
printUserInfo(user); // Afficher les informations de l'utilisateur
console.log(findUser(1)); // Trouver l'utilisateur par ID
console.log(findUser("Alice")); // Trouver l'utilisateur par nom d'utilisateur
// Variables utilisant les types null et undefined
let emptyValue: null = null;
let uninitializedValue: undefined = undefined;
Explication :
- Type Enum (
Role): Utilisé pour définir des constantes nommées pour les rôles utilisateurAdmin、UseretGuest。 - Interface (
User): définitUserla structure d'un objet, y comprisid、username、isActivepropriétés telles que..., démontrantstring、number、boolean、arrayettuplel'utilisation des types. - Fonction
getUserInfo: renvoie une description de l'utilisateur, en utilisant l'interpolation de chaînes avecenum。 - fonction
printUserInfo: le type estvoid, car il ne fait qu'afficher des informations et ne renvoie aucune valeur. - Type union (
number | string): utilisée pourfindUserle paramètre de la fonction, qui peut accepter des nombres ou des chaînes de caractères. nevertype:throwErrorLa fonction lève une erreur et ne retourne pas normalement, donc elle utilisenevertype.anytype: démontre comment déclarer une variable pouvant accepter n'importe quel type.unknowntype: similaire àany, mais plus sûr ; dans l'exemple, une vérification de type est effectuée avant l'assertion de type.nulletundefined: démontre l'utilisation de valeurs null.