0Pricing
Frontend Academy · Leçon

Types de données : string, number, boolean, null, undefined

Découvrez les types primitifs de JavaScript, utilisez typeof pour les examiner et apprenez la différence entre null et undefined.

Types de données : string, number, boolean, null, undefined est une leçon Frontend Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 Frontend Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Frontend Academy comprend 4 leçons au total.

Le système de types de JavaScript

JavaScript est typé dynamiquement : les variables n’ont pas de types, ce sont les valeurs qui en ont. Une même variable peut contenir une chaîne, puis un nombre, puis null. Comprendre les sept types primitifs permet d’éviter une grande catégorie de bogues.

Chaîne de caractères

Les chaînes représentent du texte. Utilisez des apostrophes simples, des guillemets doubles ou un accent grave (littéral de gabarit). Elles sont immuables : les méthodes de chaîne renvoient de nouvelles chaînes. Les chaînes possèdent une propriété .length et de nombreuses méthodes intégrées.

const greeting = 'Hello';
const lang = "JavaScript";
const sentence = `I love ${lang}`;  // template literal

console.log(greeting.length);   // 5
console.log('hello'.toUpperCase()); // 'HELLO'
console.log(' trim me '.trim()); // 'trim me'

Nombre

JavaScript possède un seul type numérique. Tous les nombres — entiers et nombres à virgule flottante — sont des nombres à virgule flottante sur 64 bits (IEEE 754). Cela signifie que 0.1 + 0.2 !== 0.3. Valeurs spéciales : Infinity, -Infinity et NaN (pas un nombre).

const age = 30;
const price = 19.99;
console.log(0.1 + 0.2);          // 0.30000000000000004
console.log(typeof NaN);          // 'number'
console.log(isNaN('hello'));      // true
console.log(Number.isNaN('hello')); // false (safer check)

Booléen

Les booléens valent true ou false. Ils sont utilisés dans les conditions et les comparaisons. Chaque valeur de JavaScript possède une valeur de vérité intrinsèque : les valeurs fausses sont false, 0, '', null, undefined et NaN. Toutes les autres sont vraies.

const isActive = true;
const isAdmin = false;

// Falsy values:
if (0) { /* never runs */ }
if ('') { /* never runs */ }
if (null) { /* never runs */ }

Valeur nulle

null est une valeur vide attribuée explicitement. Cela signifie « aucune valeur intentionnellement ». Utilisez null lorsque vous souhaitez vider une variable ou signaler une absence. typeof null === 'object' est un bogue célèbre de JavaScript conservé pour des raisons de compatibilité historique.

let selectedUser = null;  // no user selected yet
selectedUser = { name: 'Alice' };
selectedUser = null;       // cleared

Valeur indéfinie

undefined signifie qu’aucune valeur n’a encore été attribuée. Les variables déclarées mais non initialisées valent undefined. Les arguments manquants d’une fonction valent undefined. Les propriétés manquantes d’un objet renvoient undefined.

let x;                       // undefined
function greet(name) {
  console.log(name);           // undefined if called as greet()
}
const obj = {};
console.log(obj.foo);         // undefined

Valeur nulle ou indéfinie

null = absence intentionnelle. undefined = valeur pas encore attribuée. En règle générale : laissez le moteur définir undefined et utilisez explicitement null dans votre propre code lorsque vous voulez dire « vide ».

Opérateur de type

Utilisez typeof pour examiner le type d’une valeur lors de l’exécution. Il renvoie une chaîne : 'string', 'number', 'boolean', 'undefined', 'object', 'function', 'bigint', 'symbol'. N’oubliez pas que typeof null === 'object' est un bogue connu.

typeof 'hello'     // 'string'
typeof 42          // 'number'
typeof true        // 'boolean'
typeof undefined   // 'undefined'
typeof null        // 'object' ← historical bug
typeof {}          // 'object'
typeof []          // 'object'
typeof function(){} // 'function'

Symbol et BigInt

Symbol : identifiant unique et immuable, utilisé pour les clés de propriétés d’objet qui ne risquent pas d’entrer en collision. BigInt : entiers supérieurs à Number.MAX_SAFE_INTEGER (2^53-1). Créé avec 42n ou BigInt(42). Il n’est pas nécessaire pour la plupart des développements front-end.

Pièges de la conversion implicite des types

JavaScript convertit silencieusement les types lors des comparaisons et des opérations. Utilisez === (égalité stricte) plutôt que == (égalité faible) pour éviter les surprises liées à la conversion implicite.

0 == false        // true (coercion)
0 === false       // false (strict, no coercion)
'' == false       // true
'5' == 5          // true
'5' === 5         // false ✓ use this

Conversion de types

Convertissez explicitement les types avec Number(), String(), Boolean() ou parseInt() / parseFloat(). Une conversion explicite est toujours plus claire que de compter sur la conversion implicite.

Number('42')      // 42
Number('')        // 0
Number('abc')     // NaN
String(42)        // '42'
Boolean(0)        // false
Boolean('hello')  // true
parseInt('10px')  // 10

Vérification rapide

Que renvoie typeof null en JavaScript ?

Récapitulatif : les types de données JavaScript

Sept types primitifs : chaîne, nombre, booléen, valeur nulle, valeur indéfinie, symbole et grand entier. Utilisez typeof pour examiner les types. Utilisez === pour les comparaisons afin d’éviter la conversion implicite. Distinguez null (vide intentionnellement) de undefined (pas encore défini). Toutes les autres valeurs sont des objets.

Questions Fréquemment Posées

La leçon « Types de données : string, number, boolean, null, undefined » est-elle gratuite ?

Oui — le texte complet de « Types de données : string, number, boolean, null, undefined » 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 Frontend Academy, passe à CoddyKit PRO. Le cours Frontend Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Types de données : string, number, boolean, null, undefined » ?

Découvrez les types primitifs de JavaScript, utilisez typeof pour les examiner et apprenez la différence entre null et undefined. Tu pratiques Frontend 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 Frontend Academy ?

Aucune expérience préalable n'est requise. Frontend 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 2 sur 4.

Combien de temps prend la leçon « Types de données : string, number, boolean, null, undefined » ?

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 Frontend Academy ?

Oui. Chaque leçon Frontend 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. Variables : let, const, var et portée
  2. Types de données : string, number, boolean, null, undefined
  3. Fonctions : déclarations, expressions et fonctions fléchées
  4. Flux de contrôle : if, else, switch, for, while
← Retour à Frontend Academy