0Pricing
TypeScript Academy · Leçon

Types primitifs : string, number, boolean

Annotez les variables avec les trois types primitifs fondamentaux de TypeScript.

Types primitifs : string, number, boolean est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Bienvenue

Les trois principaux types primitifs de TypeScript sont chaîne, nombre et booléen. Dans cette leçon, vous apprendrez à annoter des variables avec ces types.

Annoter des variables

Ajoutez une annotation de type après le nom de la variable, en la séparant par deux-points. TypeScript imposera ce type pendant toute la durée de vie de la variable.
let username: string = 'Alice';
let score: number = 100;
let isLoggedIn: boolean = true;

Inférence de types

TypeScript peut déduire les types à partir de la valeur initiale. Vous n’avez pas toujours besoin d’une annotation explicite : le compilateur le détermine lui-même.
let city = 'Istanbul';   // inferred as string
let price = 9.99;        // inferred as number
let enabled = false;     // inferred as boolean

Erreurs de type lors de la compilation

Une fois qu’une variable possède un type, lui affecter un type différent constitue une erreur de compilation. TypeScript la détecte avant l’exécution du code.
let count: number = 10;
count = 'ten'; // Error: Type 'string' is not assignable to type 'number'

Le type chaîne

Le type chaîne représente toutes les valeurs textuelles. TypeScript vérifie que les opérations sur les chaînes, comme .toUpperCase(), sont valides.
let greeting: string = 'Hello';
console.log(greeting.toUpperCase()); // 'HELLO'
console.log(greeting.length);        // 5

Le type nombre

TypeScript possède un seul type nombre pour les entiers comme pour les nombres à virgule flottante, à l’image de JavaScript. Il n’existe pas de type distinct pour les entiers ou les nombres à virgule flottante.
let age: number = 25;
let pi: number = 3.14159;
let hex: number = 0xFF;

Le type booléen

Le type booléen représente vrai ou faux. TypeScript empêche les erreurs de conversion implicite des valeurs de vérité en imposant que les variables booléennes contiennent uniquement vrai ou faux.
let isDone: boolean = false;
let hasAccess: boolean = true;
// isDone = 1; // Error — not a boolean

Les littéraux de modèle fonctionnent avec les chaînes

TypeScript attribue un type aux expressions de littéral de modèle. Intégrer une valeur qui n'est pas une chaîne dans un littéral de modèle est autorisé, car JavaScript la convertit en chaîne.
let name: string = 'World';
let n: number = 42;
let msg = `Hello ${name}, you scored ${n}`;

Types primitifs et objets enveloppeurs

Utilisez toujours les types chaîne, nombre et booléen en minuscules, et non leurs équivalents String, Number et Boolean. Les versions avec une majuscule sont des types d'objets enveloppeurs et doivent rarement être utilisées.
// Correct
let a: string = 'hello';

// Avoid
let b: String = new String('hello'); // wrapper object

Annotations de type des paramètres de fonction

Annoter les paramètres de fonction avec des types primitifs permet de détecter les erreurs dues à des arguments incorrects au moment de la compilation.
function add(a: number, b: number): number {
  return a + b;
}
add(2, 3);      // OK
// add(2, '3'); // Error

Quand omettre les annotations

Si vous initialisez une variable avec une valeur, TypeScript déduit son type. Ajouter une annotation explicite est facultatif, mais peut améliorer la lisibilité des signatures de fonction.
// Both are fine:
const x = 5;          // inferred number
const y: number = 5;  // explicit number

Vérification rapide

Quel est le type primitif TypeScript correct pour la valeur 3.14 ?

Récapitulatif

Utilisez chaîne, nombre et booléen pour les types primitifs de TypeScript. TypeScript déduit les types à partir des valeurs initiales, mais les annotations explicites sont utiles dans les signatures de fonction. Utilisez toujours les noms de type en minuscules.

Questions Fréquemment Posées

La leçon « Types primitifs : string, number, boolean » est-elle gratuite ?

Oui — le texte complet de « Types primitifs : string, number, boolean » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Types primitifs : string, number, boolean » ?

Annotez les variables avec les trois types primitifs fondamentaux de TypeScript. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Types primitifs : string, number, boolean » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Types primitifs : string, number, boolean
  2. Le type any et pourquoi l’éviter
  3. unknown contre any : le choix le plus sûr
  4. null, undefined et vérifications strictes de nullité
← Retour à TypeScript Academy