Types TypeScript : string, number, boolean et les autres

Les types TypeScript décrivent le genre de valeur qu'une variable peut contenir. Vous écrivez un type après deux-points, let name: string, et le compilateur refuse tout code qui y place le mauvais genre de valeur. Les types de base sont les sept primitives de JavaScript, plus les types objet pour les tableaux et les objets.

let title: string = "TypeScript";
let version: number = 7;
let isStrict: boolean = true;
let big: bigint = 9007199254740993n;
let id: symbol = Symbol("id");
let nothing: null = null;
let notSet: undefined = undefined;

let scores: number[] = [90, 72, 85];
let user: { name: string; age: number } = { name: "Ada", age: 36 };

console.log(title, version, isStrict, big, id);
console.log(nothing, notSet);
console.log(scores, user);

Les annotations sont vérifiées à la compilation, puis retirées. Le programme qui s'exécute est du JavaScript ordinaire.

Les types primitifs

Les noms de types sont en minuscules. À l'exécution, typeof renvoie les mêmes mots pour la plupart d'entre eux : typeof x === "number" est la façon de vérifier le type primitif d'une valeur pendant l'exécution du programme.

Les annotations de type

Une annotation, c'est : Type après une variable, un paramètre ou la liste de paramètres d'une fonction. C'est sur les paramètres que les annotations comptent le plus, car TypeScript ne peut pas deviner ce qu'un appelant va passer.

function describe(name: string, age: number, admin: boolean): string {
    return `${name} (${age})${admin ? " [admin]" : ""}`;
}

let label: string = describe("Ada", 36, true);
console.log(label); // Ada (36) [admin]

// Without an annotation, TypeScript infers the type from the value:
let count = 10; // count: number
count = count + 1;
console.log(count); // 11

Quand une variable est initialisée sur la même ligne, l'annotation est en général superflue : let count = 10 a déjà le type number. Les règles pour omettre les types sont sur la page inférence de type.

Un mauvais type est une erreur de compilation

Assignez une valeur du mauvais type, et le compilateur s'arrête avant que quoi que ce soit ne s'exécute :

// This does not compile: a string is not a number.
let port: number = 8080;
port = "3000";
console.log(port);

Le compilateur affiche :

index.ts(3,1): error TS2322: Type 'string' is not assignable to type 'number'.

La correction consiste à convertir la valeur, port = Number("3000"), ou à changer l'annotation si la variable doit vraiment contenir du texte.

number : il n'y a pas de type entier

JavaScript stocke chaque nombre sous forme de valeur à virgule flottante sur 64 bits, TypeScript n'a donc qu'un seul type number. Les entiers sont exacts jusqu'à Number.MAX_SAFE_INTEGER (2 ** 53 - 1). Au-delà, utilisez bigint.

let price: number = 19.99;
let quantity: number = 3; // also number: no int type

console.log(Number.isInteger(quantity)); // true
console.log(Number.isInteger(price));    // false
console.log(Math.trunc(7 / 2));          // 3 (integer division)
console.log(0.1 + 0.2);                  // 0.30000000000000004

console.log(Number.MAX_SAFE_INTEGER);     // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 2); // 9007199254740992 (wrong)

let exact: bigint = 9007199254740991n + 2n;
console.log(exact); // 9007199254740993n

// @ts-expect-error: bigint and number cannot be mixed
const mixed = () => exact + 1;
console.log(exact + BigInt(1), Number(exact)); // 9007199254740994n 9007199254740992

bigint et number ne se mélangent pas : exact + 1 est une erreur de compilation (TS2365 : Operator '+' cannot be applied to types 'bigint' and '1'., où '1' est le type littéral du 1) et, s'il s'exécutait un jour, une TypeError à l'exécution aussi. Convertissez explicitement un des deux côtés avec BigInt(1) ou Number(exact), en sachant que Number arrondit les valeurs hors de la plage sûre.

Si vous voulez un type qui n'accepte que des nombres entiers, TypeScript ne sait pas l'exprimer pour des valeurs quelconques. Validez avec Number.isInteger à l'endroit où la valeur entre dans votre programme.

boolean

boolean a exactement deux valeurs, true et false. Les valeurs simplement truthy (1, "yes") ne sont pas des booléens : convertissez-les avec Boolean(x) ou x !== 0.

let loggedIn: boolean = false;
const items: string[] = ["a", "b"];

const hasItems: boolean = items.length > 0;
const hasName: boolean = Boolean("Ada");

console.log(loggedIn, hasItems, hasName); // false true true

null et undefined

Avec strict activé (la valeur par défaut depuis TypeScript 6.0), null et undefined sont des types distincts et ne font partie ni de string, ni de number, ni d'aucun autre type. Une variable qui peut être vide l'indique avec une union :

let nickname: string | undefined;
console.log(nickname); // undefined

nickname = "Ace";
console.log(nickname.toUpperCase()); // ACE

let middleName: string | null = null;
console.log(middleName ?? "(none)"); // (none)

Lire une propriété d'une valeur qui peut être undefined est une erreur de compilation tant que vous ne l'avez pas vérifiée. La page null et undefined présente les vérifications, ?. et ??.

Tableaux et objets en un coup d'œil

Tout ce qui n'est pas une primitive est un type objet. Les trois formes que vous rencontrez en premier :

let tags: string[] = ["ts", "js"];               // array of strings
let point: { x: number; y: number } = { x: 1, y: 2 }; // object with two number properties
let greet: (name: string) => string = (n) => `hi ${n}`; // function type

Chacune a sa propre page : tableaux, tuples (tableaux de longueur fixe), types objet et types de fonctions.

string, number, boolean ou String, Number, Boolean

Les noms avec majuscule sont les types des objets enveloppes de JavaScript (new String("x")), pas des valeurs ordinaires. Annotez avec les noms en minuscules.

// This does not compile: String (the wrapper) is not string (the primitive).
const wrapped: String = "text";
const plain: string = wrapped;
console.log(plain);

index.ts(3,7): error TS2322: Type 'String' is not assignable to type 'string'.
  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.

Remplacez String par string à la première ligne et le bloc s'exécute. Il en va de même pour Number, Boolean, Symbol et BigInt. (Object est un cas à part : il accepte presque n'importe quelle valeur, primitives comprises ; voir les types objet.)

Autres types intégrés

Quelques autres types apparaissent tôt. Chacun a sa propre page.