Informatique · JavaScript et front

Les bases de JavaScript

Un bouton qui réagit, un formulaire qui vérifie ton adresse : derrière, il y a du JavaScript, le langage que tous les navigateurs exécutent.

Déjà à l'aise ? Aller au quiz

Le principe

Une page web, c'est trois langages qui travaillent ensemble : HTML pour la structure, CSS pour l'apparence, JavaScript pour le comportement.

HTML la structure <button> CSS l'apparence color: red JavaScript le comportement score += 1 trois langages, une seule page

C'est JavaScript qui réagit aux clics et fait les calculs : c'est lui qu'on apprend ici.

Après cette fiche, tu sais

  • déclarer des variables avec let et const, et suivre la mémoire ligne après ligne ;
  • reconnaître les types de valeurs, et prévoir ce que font + et == quand les types diffèrent ;
  • écrire des conditions et des boucles, et dérouler une boucle à la main ;
  • écrire une fonction, l'appeler, et dire où une variable est visible ;
  • ranger des données dans des tableaux et des objets.
Petite question avant de commencer : en JavaScript, que vaut "5" + 2 ? Le nombre 7, le texte "52", ou une erreur ?

Je dirais 7, non ? Ça fait 5 + 2.

Garde ta réponse en tête : on la vérifie dans la notion 3, avec les conversions.

Un nom pour une valeur

Notion 1 · Les variables

Donner un nom à une valeur

Un programme JavaScript est une suite d'instructions, exécutées de haut en bas. On les écrit dans des balises <script>, on les tape dans la console du navigateur (touche F12), ou on les lance avec Node.js.

page.html <script> console.log("Bonjour !"); </script> console Bonjour ! le navigateur lit le script de haut en bas

Une variable

Pour retenir une valeur, on la range dans une variable : un nom qui désigne une valeur en mémoire.1

let score = 0 score = 10 réassignable const prenom = "Léa" réassigner : interdit constante

let si la valeur va changer, const si elle ne doit plus être réassignée. C'est le bon choix par défaut.

Le nom

Lettres, chiffres, _ et $, sans espace et sans chiffre au début. JavaScript distingue les majuscules des minuscules : note et Note sont deux variables différentes.

note 5 Note 6 ≠ deux variables : la casse compte

L'habitude : des noms parlants en camelCase, comme noteFinale.

Un vieux mot-clé

Tu croiseras aussi var, l'ancienne façon de déclarer, d'avant 2015. Le standard du langage s'appelle ECMAScript : let et const sont arrivés avec sa version de 2015.1

Dans du code neuf, on utilise donc let et const. On verra dans la notion 6 ce que var change.

Une instruction, en morceaux

Fais défiler : une instruction s'éclate en morceaux, puis une case apparaît en mémoire.

const prenom = "Léa" ; mot-clédéclare nomchoisi par toi affectation« ranger » valeurune chaîne find'instruction MÉMOIRE prenom "Léa"
Étape 1 sur 3

Une instruction complète : on crée une constante prenom qui contient le texte "Léa".

Étape 2 sur 3 · les morceaux

Le mot-clé déclare, le nom est choisi par toi, le signe = range la valeur, le ; termine l'instruction.

Étape 3 sur 3 · l'exécution

Une case nommée prenom apparaît en mémoire, avec "Léa" dedans. En JavaScript, = veut dire « ranger », jamais « est égal ».

La mémoire, ligne par ligne

Fais défiler : sept lignes s'exécutent l'une après l'autre. Surveille les cases de la mémoire et la console. Tu peux aussi toucher un numéro de ligne.

Scène 1 · Variables

Ce que contient la mémoire

CODE 1234567 let score = 0; const prenom = "Léa"; score = score + 10; score += 5; let bonus; console.log(score, bonus); prenom = "Zoé"; › console vide MÉMOIRE vide : rien n'est encore exécuté score let 0 prenom const "Léa" bonus let undefined

ligne 0 sur 7score …

Tu as vu la ligne 3 ? score = score + 10 serait faux en maths. En JavaScript, la machine calcule d'abord la droite, puis range le résultat à gauche.
Exercice · à toi

Que contient la mémoire ?

Trois petits programmes. Déroule-les dans ta tête, ligne par ligne, puis choisis.

Des valeurs de toutes sortes

Notion 2 · Les types

Toutes les valeurs ne se ressemblent pas

Chaque valeur a un type. La norme en définit huit : sept types primitifs et les objets.1

number 42 string "Léa" boolean true undefined undefined null null bigint 10n symbol Symbol() objet [4, 5] sept types primitifs et les objets

Le type, on le lit

On n'écrit jamais le type d'une variable : JavaScript le déduit de la valeur. Une même variable let peut recevoir un nombre, puis un texte.

typeof 42 vaut "number", typeof "42" vaut "string".

42 typeof "number" "42" typeof "string" typeof renvoie toujours un texte

Deux réponses surprennent

  • typeof null vaut "object" : un héritage de la toute première version du langage. Une correction a été proposée pour la norme, puis rejetée. null est pourtant une valeur primitive.2
  • typeof [4, 5] vaut aussi "object" : un tableau est un objet. Pour le reconnaître, on écrit Array.isArray(t).2
TypeExemplesSert à
number42, 4.5, -0.5tous les nombres
string"Léa", 'VD', `5 CHF`du texte (une chaîne)
booleantrue, falsevrai ou faux
undefinedundefinedpas encore de valeur
nullnullaucune valeur, exprès
bigint, symbol10ngrands entiers, identifiants
objet[4, 5], { note: 5 }tableaux, objets, fonctions
Un point, pas une virguleDans le code, la partie décimale se sépare par un point : 4.5. La virgule sépare des éléments, comme dans [4.5, 5]. Dans le texte de cette fiche, on écrit 4,5, comme en maths.
Exercice · à toi

Range chaque valeur selon typeof

Touche une valeur, puis la case de ce que renvoie typeof. Méfie-toi de deux d'entre elles.

Quand le plus colle

Notion 3 · Opérations et comparaisons

Calculer, coller, comparer

Les nombres se calculent avec +, -, *, /, ** (puissance) et % (reste) : 7 % 2 vaut 1, ce qui permet de savoir si un nombre est pair.

Mais + a deux métiers : il additionne les nombres et il colle les textes.3

1 + 2 3 nombre additionne 3 + "3" "33" texte colle on calcule de gauche à droite

Dès qu'il y a une chaîne

Dès qu'un des deux côtés de + est une chaîne, l'autre devient une chaîne. Avec -, * ou /, la chaîne est convertie en nombre. La dernière ligne est un gabarit : entre accents graves, ${…} insère une valeur dans le texte.

"5" + 2        // "52"
"5" - 2        // 3
1 + 2 + "3"    // "33"
`${"Léa"} a ${5.5}`   // "Léa a 5.5"
Réponse à ma question du début : "5" + 2 vaut "52", un texte. Ces conversions faites en douce s'appellent la coercition.

Et "5" * 2 ? Ça ferait 10 ?

Oui : "5" devient 5, puis 5 × 2 vaut 10. Pour éviter les surprises, on convertit soi-même, comme juste après.

Convertir soi-même

Number("42") donne 42, et String(42) donne "42". Une conversion impossible donne NaN (Not a Number) : Number("4,5") vaut NaN, car la virgule n'est pas un séparateur décimal en JavaScript.

"42" Number() 42 "4,5" Number() NaN la conversion échoue : NaN

Attention au calcul

0,1 + 0,2 ne fait pas 0,3. Les nombres sont rangés en binaire sur 64 bits (norme IEEE 754), et 0,1 n'a pas d'écriture binaire exacte.5

0.1 + 0.2 0.30000000000000004 0.1 + 0.2 === 0.3 false 0,1 n'a pas d'écriture binaire exacte

Pour comparer deux nombres à virgule, on tolère un petit écart : Math.abs(a - b) < 1e-9.

Deux égalités

== (égalité faible) convertit d'abord les valeurs vers un même type. === (égalité stricte) compare sans rien convertir : des types différents donnent toujours false.

== 1 "1" converti en 1 = true === 1 "1" ≠ types différents false

MDN le dit sans détour : l'égalité stricte est presque toujours celle qu'il faut utiliser.4 Les comparaisons <, >, <=, >= renvoient un booléen. Les contraires de === et de == sont !== et !=.

La machine à comparer

Fais défiler : cinq paires de valeurs passent par == puis par ===. Regarde quand une valeur est convertie, et quand la machine refuse de le faire.

Scène 2 · Comparaisons

1 et "1"

ÉGALITÉ FAIBLE 1 number "1" string == 1 après conversion règle spéciale ?

Vrai, faux, et tout le reste

Dans un if, une valeur devient un booléen. Huit valeurs deviennent false, on les dit falsy :

  • false, 0, -0, 0n ;
  • "" (la chaîne vide), null, undefined et NaN.6

Toutes les autres sont truthy, y compris "0", " " et le tableau vide []. Les opérateurs && (et), || (ou) et ! (non) combinent les conditions.

Retiens NaN : c'est la seule valeur qui n'est pas égale à elle-même. Pour savoir si un calcul a raté, on écrit Number.isNaN(x).
Jeu · prédis la sortie

Que vaut chaque expression ?

Huit expressions, toutes vérifiées dans un vrai moteur JavaScript. Réfléchis avant de toucher.

Deux chemins possibles

Notion 4 · Les conditions

Faire un choix

if exécute un bloc seulement si sa condition est vraie. else if teste une autre condition, et else attrape tous les autres cas.

note = 4.5 note >= 4 ? oui Suffisant Insuffisant non ici, 4.5 >= 4 est vrai : Suffisant s'exécute
notes.jsJavaScript
const note = 4.5;

if (note >= 4) {
  console.log("Suffisant");
} else {
  console.log("Insuffisant");
}

// ternaire : condition ? oui : non
const verdict = note >= 4
  ? "réussi"
  : "à retravailler";
Suffisant

De haut en bas

Les conditions sont testées de haut en bas, et seule la première vraie s'exécute. La ternaire condition ? oui : non est une version courte, vue dans le code ci-dessus.

Piège

Un seul = dans un if ne compare rien : if (note = 6) range 6 dans note (qui doit être un let), et 6 est truthy. Le bloc s'exécute donc toujours.

note = 6 range 6 dans note 6 est truthy 6 n'est pas 0 bloc toujours exécuté pour comparer, il faut ===

Pour comparer, on écrit === (ou >=, <…).

Exercice · à toi

Remets la fonction dans l'ordre

Avec 6, la fonction doit répondre « très bien » ; avec 4,5, « suffisant » ; avec 3,5, « insuffisant ». Touche une ligne, puis celle avec laquelle l'échanger. Attention à l'ordre des conditions.

Un tour de plus

Notion 5 · Les boucles

Répéter sans recopier

Une boucle répète un bloc tant qu'une condition est vraie. La boucle for regroupe trois choses entre ses parenthèses.

for (let i = 0; i < notes.length; i++) { initialisation une fois, au début condition avant chaque tour pas après chaque tour le corps se répète tant que la condition est vraie

Trois parties : l'initialisation (let i = 0), la condition (i < notes.length) et le pas (i++).

Une boucle tourne

Fais défiler : la boucle calcule la moyenne de quatre notes. Suis i, la condition et la somme à chaque tour, comme si tu exécutais le code à la main.

Scène 3 · Boucle for

La moyenne de quatre notes

123456 const notes = [4.5, 5, 3.5, 6]; let somme = 0; for (let i = 0; i < notes.length; i++) { somme = somme + notes[i]; } const moyenne = somme / notes.length; notes i · i < notes.length ? · somme ·

tour 0 sur 4i ·somme ·

Quatre tours, cinq tests

Le corps tourne quatre fois. Le test, lui, est fait cinq fois : le dernier, 4 < 4, est faux, et c'est lui qui arrête la boucle.

Deux autres boucles

while répète tant que sa condition est vraie, sans compteur intégré. for…of parcourt directement les valeurs d'un tableau, sans indice.

n <= 10 ? corps du while n += 2 vrai retour au test suite faux sans n += 2, le test resterait vrai : boucle infinie
boucles.jsJavaScript
let n = 0;
while (n <= 10) {   // 0, 2, 4… 10
  console.log(n);
  n += 2;  // sinon : boucle infinie
}

let total = 0;
for (const note of [4.5, 5, 3.5, 6]) {
  total += note;    // 19 à la fin
}
Exercice · à toi

Combien de tours ?

Pour chaque boucle, compte combien de fois le corps s'exécute. Un indice : écris les valeurs successives du compteur.

Un bloc qui se réutilise

Notion 6 · Les fonctions

Écrire une fois, utiliser partout

Une fonction est un bloc de code nommé. Elle reçoit des paramètres, fait son travail et renvoie un résultat avec return.

[4.5, 5, 3.5, 6] moyenne (notes) 4.75 moyenne([4.5, 5, 3.5, 6]) renvoie 4.75

Déclarer, appeler

On la déclare une fois, puis on l'appelle autant qu'on veut, avec des arguments différents à chaque fois.

fonctions.jsJavaScript
function moyenne(notes) {
  let somme = 0;
  for (const n of notes) somme += n;
  return somme / notes.length;
}

moyenne([4.5, 5, 3.5, 6]);   // 4.75
moyenne([6, 5]);             // 5.5

// fonction fléchée : plus courte
const arrondiDemi = note =>
  Math.round(note * 2) / 2;
arrondiDemi(4.75);           // 5

Sans return

Une fonction qui calcule sans return renvoie undefined. Et return arrête la fonction : les lignes placées après ne s'exécutent jamais.

5 return n * 2; 10 5 n * 2; undefined sans return, le résultat est perdu

Où vit une variable ?

Une variable n'est pas visible partout : sa portée dépend de l'endroit où elle est déclarée. let et const vivent dans le bloc entre accolades où elles sont nées ; var vit dans toute la fonction.1 Fais défiler.

PORTÉE GLOBALE const taux = 0.5; function demo() { if (true) { let x = 1; console.log(taux); 0.5 } x = 1 console.log(x); ReferenceError: x is not defined }
Étape 1 sur 4 · un bloc

let x = 1 est déclarée dans le bloc du if : x n'existe qu'entre ses accolades.

Étape 2 sur 4 · hors du bloc

Après l'accolade fermante, console.log(x) ne trouve rien : ReferenceError, x n'est pas défini.

Étape 3 sur 4 · avec var

Avec var, x ignore le bloc et vit dans toute la fonction : la même ligne affiche 1. C'est une source de bugs, d'où let.

Étape 4 sur 4 · chercher dehors

Une variable est cherchée dans le bloc, puis dans les blocs qui l'entourent, jusqu'à la portée globale : taux est trouvé. Jamais dans l'autre sens.

Jeu · trouve le bug

Trois programmes, trois erreurs

Chaque programme tourne, mais donne un résultat faux. Trouve pourquoi.

Ranger, puis retrouver

Notion 7 · Tableaux et objets

Ranger plusieurs valeurs ensemble

Un tableau est une liste ordonnée. Ses cases sont numérotées à partir de 0.

4.5 [0] 5 [1] 3.5 [2] notes.length = 3 undefined [3] notes[3] n'existe pas : on lit undefined

Les bornes

Dans const notes = [4.5, 5, 3.5], notes[0] vaut 4.5 et notes.length vaut 3. La dernière case est notes[notes.length - 1].

Lire une case qui n'existe pas donne undefined, sans erreur.

tableaux.jsJavaScript
const notes = [4.5, 5, 3.5, 6];
notes.push(5.5);       // 5 notes
notes.includes(6);     // true
notes.map(n => n * 2);
// [9, 10, 7, 12, 11] : nouveau tableau
notes.filter(n => n < 4);   // [3.5]

const eleve = {
  prenom: "Léa",
  canton: "VD",
  notes: [5, 4.5]
};
eleve.prenom;          // "Léa"
eleve["canton"];       // "VD"
eleve.age = 16;        // ajoutée

Un objet

Un objet regroupe des valeurs nommées, ses propriétés : une clé, deux points, une valeur. On lit une propriété avec un point (eleve.prenom) ou avec des crochets (eleve["canton"]).

eleve prenom: "Léa", canton: "VD", notes: [5, 4.5] eleve.prenom "Léa" eleve["canton"] "VD"

Un tableau d'objets

Un tableau d'objets décrit toute une classe : c'est exactement la forme des données JSON qu'envoient les serveurs.

Une référence

Pourquoi ? Une variable ne contient pas le tableau lui-même, mais une référence vers lui. const interdit de réassigner la variable, pas de modifier le tableau.1

const notes = [4, 5];
notes.push(6);   // permis : c'est le même tableau
notes = [];         // TypeError

Copie ou référence ?

Fais défiler : cinq étapes montrent ce qui est copié et ce qui est partagé.

VARIABLES OBJETS EN MÉMOIRE a 5 b 5 t u v
Étape 1 sur 5 · une copie

let a = 5; let b = a; : b reçoit une copie de la valeur de a.

Étape 2 sur 5 · indépendants

b = 9; ne touche que b : a vaut toujours 5.

Étape 3 sur 5 · une référence

const t = [1, 2]; const u = t; : un seul tableau existe, t et u pointent tous les deux vers lui.

Étape 4 sur 5 · partagé

u.push(3); modifie ce tableau commun : t le voit aussi, et t === u vaut true.

Étape 5 sur 5 · une vraie copie

const v = [...t]; crée un nouveau tableau avec les mêmes éléments : t === v vaut false, et modifier v ne change plus t.

Exercice · à toi

Tableaux et objets

Quatre questions sur les indices, push, filter et les propriétés.

Maintenant, à toi

Attention

Les pièges classiques

Six erreurs reviennent sans cesse. Fais défiler les cartes : chacune dit ce qui se passe et pourquoi.

= au lieu de ===

Un seul signe = range une valeur. Dans un if, il rend la condition presque toujours vraie.

Additionner du texte

Ce qu'on lit dans un champ de formulaire est une chaîne : "4" + 1 vaut "41". Convertis d'abord avec Number(…).

La virgule décimale

4,5 n'est pas un nombre en JavaScript, et Number("4,5") vaut NaN. Dans le code : 4.5.

Une case de trop

Les indices vont de 0 à length - 1. Avec i <= t.length, on lit t[t.length], qui vaut undefined : une somme devient NaN.

Tester NaN avec ===

x === NaN vaut toujours false, même si x vaut NaN. On écrit Number.isNaN(x).

Croire que const fige tout

const interdit de réassigner la variable, pas de modifier le tableau ou l'objet qu'elle désigne.

Entraîne-toi

Exercices corrigés

Cherche d'abord, sur papier ou dans la console, puis ouvre le corrigé. Chaque solution a été exécutée.

1Écris une fonction estPair(n) qui renvoie true si n est pair.Voir le corrigé
function estPair(n) {
  return n % 2 === 0;
}
estPair(7);    // false
estPair(-4);   // true

Un nombre est pair si le reste de sa division par 2 vaut 0. La comparaison n % 2 === 0 donne déjà un booléen : inutile d'écrire un if.

2Écris une fonction max(t) qui renvoie la plus grande valeur d'un tableau non vide, avec une boucle.Voir le corrigé
function max(t) {
  let plusGrand = t[0];
  for (const x of t) {
    if (x > plusGrand) plusGrand = x;
  }
  return plusGrand;
}
max([4, 5.5, 3, 6, 2]);   // 6

On part de la première valeur, puis on la remplace chaque fois qu'on rencontre plus grand. Partir de 0 serait faux pour un tableau de nombres négatifs. (JavaScript le fait aussi tout seul : Math.max(...t).)

3Combien de notes sont insuffisantes (sous 4) dans [4.5, 3.5, 5, 2.5, 4] ? Écris le code de deux façons.Voir le corrigé
const notes = [4.5, 3.5, 5, 2.5, 4];

let compte = 0;
for (const n of notes) {
  if (n < 4) compte++;
}
// compte vaut 2

notes.filter(n => n < 4).length;   // 2

2 (3,5 et 2,5). Le 4 n'est pas compté : 4 < 4 est faux. La seconde version garde les notes insuffisantes dans un nouveau tableau, puis lit sa longueur.

4Ton école arrondit les moyennes au demi-point. Écris arrondiDemi(note) : 4,74 doit donner 4,5 et 4,75 doit donner 5.Voir le corrigé
function arrondiDemi(note) {
  return Math.round(note * 2) / 2;
}
arrondiDemi(4.74);   // 4.5
arrondiDemi(4.75);   // 5

Les demi-points deviennent des entiers quand on multiplie par 2 (4,75 × 2 = 9,5). Math.round arrondit à l'entier le plus proche (9,5 donne 10), puis on divise par 2 pour revenir à l'échelle des notes.

À retenir

La fiche en huit lignes

Huit cartes pour réviser avant le quiz.

Variables

const par défaut, let si la valeur change ; = range une valeur, il ne compare pas.

Types

number, string, boolean, undefined, null, bigint, symbol, et les objets ; typeof null vaut "object".

Conversions

+ colle dès qu'il y a une chaîne ; -, *, / convertissent en nombre ; un échec donne NaN.

Égalité

=== compare sans convertir : c'est lui qu'on utilise. NaN n'est égal à rien : on écrit Number.isNaN.

Conditions

if, else if, else : testées de haut en bas, la première vraie gagne.

Boucles

for (initialisation ; condition ; pas), while, for…of : for et while s'arrêtent quand la condition devient fausse, for…of quand le tableau est fini.

Fonctions

Paramètres en entrée, return en sortie ; let et const ont une portée de bloc.

Tableaux, objets

Indices de 0 à length - 1 ; pour un tableau ou un objet, une variable garde une référence, pas une copie.

Le moment de vérité

Dernière étape : le quiz. Si tu hésites, déroule le code dans ta tête, comme dans les scènes.
Quiz final

Teste-toi

Sources

  1. MDN Web Docs, Types et grammaire (standard ECMAScript ; let, const et var ; portée de bloc ; remontée et zone morte temporelle ; sensibilité à la casse ; propriétés d'un objet constant modifiables) et Types et structures de données JavaScript (sept types primitifs et les objets), consulté le 8 octobre 2026. Types et grammaire, Types et structures de données (developer.mozilla.org)
  2. MDN Web Docs, L'opérateur typeof (tableau des résultats ; typeof null vaut "object", héritage de la première implémentation, correction proposée puis rejetée ; typeof NaN vaut "number" ; Array.isArray pour reconnaître un tableau), consulté le 8 octobre 2026. developer.mozilla.org
  3. MDN Web Docs, Addition (+) (si l'un des opérandes est une chaîne, l'autre est converti en chaîne et les deux sont concaténés ; sinon, addition numérique), consulté le 8 octobre 2026. developer.mozilla.org
  4. MDN Web Docs, Comparaisons d'égalité et de similitude (égalité stricte sans conversion, égalité faible avec conversion, null == undefined, NaN différent de lui-même ; « l'égalité stricte est presque toujours l'opération de comparaison qu'il convient d'utiliser »), consulté le 8 octobre 2026. developer.mozilla.org
  5. MDN Web Docs, Number : propriété statique EPSILON (0.1 + 0.2 vaut 0.30000000000000004 ; comparaison avec une tolérance) et Number (format binaire IEEE 754 en double précision, sur 64 bits), consulté le 8 octobre 2026. EPSILON, Number (developer.mozilla.org)
  6. MDN Web Docs, Falsy (Valeurs de type fausses) (valeurs considérées comme fausses : false, 0, -0, 0n, "", null, undefined, NaN, et l'objet historique document.all), consulté le 8 octobre 2026. developer.mozilla.org

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Tous les extraits de code ont été exécutés avec Node.js 25.

Glisser pour continuer vers DOM, événements et fetch
Gymnase 1