Ces exercices te permettent d’entraîner ta logique et de pratiquer les étapes du raisonnement STITI :
Stocker → Transformer → Interagir → Tester → Itérer
Chaque série ajoute une nouvelle brique. Prends le temps de bien comprendre ce que fait ton programme à chaque étape.
prompt() pour récupérer des données.console.log() pour afficher des résultats.mon_nombre, age_utilisateur)prompt()prompt() sert à demander une information à l’utilisateur.
Elle renvoie toujours une chaîne de caractères (texte), ou null si l’utilisateur annule.
Exemple :
let nom = prompt("Quel est ton prénom ?");
console.log()console.log() sert à afficher un message ou une variable dans la console.
C’est ta fenêtre de dialogue avec le programme.
Exemple :
console.log("Bonjour " + nom);
Quand tu récupères un nombre avec prompt(), il est stocké comme texte.
Pour faire des calculs, tu dois le convertir :
parseInt(texte) → convertit en nombre entierparseFloat(texte) → convertit en nombre décimalExemple :
let age = parseInt(prompt("Ton âge ?"));
Une variable stocke une valeur en mémoire avec un nom.
let prenom = "Alice"; // Stocke du texte
let age = 25; // Stocke un nombre
+ // Addition (ou concaténation de texte)
- // Soustraction
* // Multiplication
/ // Division
Assembler du texte avec + :
let prenom = "Alice"; // Stocke du texte
console.log("Bonjour " + prenom); // Affiche: Bonjour Alice
Ne pas les utiliser, ces exercices sont réservés aux opérateurs de base.
Objectif : apprendre à manipuler des variables, transformer des données et afficher des résultats.
Exécute du code seulement si une condition est vraie.
if (age >= 18) {
console.log("Majeur");
} else {
console.log("Mineur");
}
=== // Égal à (strict)
!== // Différent de
> // Supérieur à
>= // Supérieur ou égal
< // Inférieur à
<= // Inférieur ou égal
mot === "rouge" // Vérifie égalité exacte (sensible à la casse)
Objectif : ajouter des conditions if pour prendre des décisions.
Répète du code tant qu’une condition est vraie.
let i = 1;
while (i <= 10) {
console.log(i);
i = i + 1; // on transforme i en lui ajoutant 1, pour qu'il rende la condition fausse, dans 10 tours)
}
++i est juste un raccourci pour i = i + 1. Rien de magique.
++i // i = i + 1
--i // i = i - 1
i += 5 // i = i + 5
mot[0] // Premier caractère
mot[mot.length - 1] // Dernier caractère
Objectif : utiliser des boucles pour répéter des actions.
Donne le reste d’une division.
7 % 3 // 1 (7 = 3×2 + 1)
10 % 5 // 0 (divisible exactement)
8 % 2 // 0 (pair)
7 % 2 // 1 (impair)
Combinent plusieurs conditions.
&& // ET (les deux doivent être vraies)
|| // OU (au moins une doit être vraie)
! // NON (inverse vrai/faux)
// Exemples
if (age >= 18 && age <= 65) // Entre 18 et 65
if (mot === "" || mot.length < 3) // Vide OU trop court
if (!(age < 18)) // Équivalent à age >= 18
if (texte === "") {
console.log("Champ vide !");
}
Objectif : maîtriser les opérateurs logiques, le modulo et la validation d’entrées.
Mettre des if à l’intérieur d’autres if pour tester plusieurs cas.
if (age < 0 || age > 150) {
console.log("Invalide");
} else {
if (age < 12) {
console.log("Enfant");
} else if (age < 18) {
console.log("Adolescent");
} else {
console.log("Adulte");
}
}
Raccourci pour éviter trop d’imbrication. C’est juste du sucre syntaxique.
// Ces deux blocs font exactement la même chose :
// Version 1 (imbriquée)
if (note < 10) {
console.log("Échec");
} else {
if (note < 12) {
console.log("Passable");
} else {
console.log("Bien");
}
}
// Version 2 (else if)
if (note < 10) {
console.log("Échec");
} else if (note < 12) {
console.log("Passable");
} else {
console.log("Bien");
}
// && s'évalue avant ||
if (a || b && c) // Équivaut à : a || (b && c)
// Utilise des parenthèses pour être clair
if ((a || b) && c)
Objectif : combiner des tests pour résoudre des situations complexes.
Contrainte : pas de tableaux, snake_case obligatoire.
Demande un âge. Si négatif ou supérieur à 150, affiche “Âge invalide”. Sinon, détermine : enfant (<12), adolescent (12-17), adulte (≥18).
Demande une note entre 0 et 20. Si hors plage, affiche “Note invalide”. Sinon, attribue une mention : échec (<10), passable (10-11), bien (12-13), très bien (14-15), excellent (≥16).
Demande une lettre (un seul caractère). Affiche “Voyelle” si c’est a, e, i, o, u (minuscule ou majuscule), sinon “Consonne”.
Demande deux nombres. Affiche “Deux positifs” si les deux sont >0, “Au moins un négatif” si l’un est <0, “Au moins un zéro” si l’un vaut 0.
Demande un mot. Si longueur >5 ET commence par “a” (minuscule), affiche “Mot long commençant par a”, sinon “Autre cas”.
Demande une heure (0-23). Affiche “Matin” (6-11), “Après-midi” (12-17), “Soirée” (18-22), “Nuit” (23-5). Si hors plage, affiche “Heure invalide”.
Demande une température. Affiche “Gelée” (<0), “Froide” (0-9), “Douce” (10-19), “Chaude” (≥20).
Demande trois nombres. Affiche le plus petit des trois (compare-les deux par deux).
Demande un nom d’utilisateur et un mot de passe. Le bon couple est : utilisateur=”admin”, mot_de_passe=”1234”. Affiche “Connexion réussie” si les deux sont corrects, sinon indique ce qui est faux (“Nom incorrect”, “Mot de passe incorrect”, “Les deux sont faux”).
Demande un nombre. Affiche “Fizz” s’il est divisible par 3, “Buzz” s’il est divisible par 5, “FizzBuzz” s’il est divisible par les deux, sinon affiche le nombre lui-même.
Combiner boucles et tests : la boucle répète, les if décident quoi faire à chaque tour.
let i = 1;
while (i <= 10) {
if (i % 2 === 0) {
console.log(i + " (pair)");
} else {
console.log(i);
}
i++;
}
Continue tant qu’une condition reste vraie.
let mot = "";
while (mot !== "stop") {
mot = prompt("Mot (tape 'stop' pour arrêter) :");
}
Variable qui accumule un résultat pendant la boucle.
let somme = 0;
let i = 1;
while (i <= 10) {
somme += i; // somme = somme + i
i++;
}
console.log(somme); // 55
Objectif : combiner les boucles while avec des conditions internes pour contrôler le flux du programme.
Demande un nombre. Avec un while, affiche les nombres de 1 à ce nombre. Si le nombre courant est pair, ajoute “(pair)” après.
Demande un mot. Avec un while, affiche chaque lettre sur une ligne. Si la lettre est “a”, affiche “⭐” après.
Redemande un mot tant que l’utilisateur n’écrit pas “stop” (boucle infinie contrôlée).
Demande un nombre. Compte de 1 jusqu’à ce nombre avec while. À chaque multiple de 10, affiche “BOOM !”.
Redemande des prénoms jusqu’à ce que l’utilisateur entre une chaîne vide. Pour chaque prénom, affiche “court” si ≤4 lettres, “long” sinon.
Redemande des nombres tant que l’utilisateur ne tape pas 0. Additionne-les au fur et à mesure. Quand il tape 0, affiche la somme totale.
Demande une phrase. Avec un while, parcours la phrase caractère par caractère. Chaque fois que tu rencontres un espace, passe à la ligne (pour séparer les mots). Affiche ainsi chaque mot sur une ligne distincte.
Jeu de devinette : fixe un nombre secret entre 1 et 10 dans ton code (ex: let secret = 7;). Redemande un nombre tant que l’utilisateur ne trouve pas. Indique “Plus grand !” ou “Plus petit !” à chaque essai.
Demande une phrase. Avec un while, parcours-la caractère par caractère et compte combien de fois apparaît la lettre “e” (minuscule). Affiche le total à la fin.
Redemande un mot de passe tant qu’il a moins de 6 caractères. Quand il est valide, affiche “Mot de passe accepté”.
Une boucle à l’intérieur d’une autre. La boucle interne s’exécute complètement à chaque tour de la boucle externe.
let ligne = 1;
while (ligne <= 3) {
let colonne = 1;
while (colonne <= 3) {
console.log("L" + ligne + "C" + colonne);
colonne++;
}
ligne++;
}
// Affiche : L1C1, L1C2, L1C3, L2C1, L2C2, L2C3, L3C1, L3C2, L3C3
let resultat = "";
let i = 1;
while (i <= 5) {
resultat += "*"; // Ajoute une étoile
i++;
}
console.log(resultat); // *****
Parfois il faut plusieurs compteurs.
let voyelles = 0;
let consonnes = 0;
let i = 0;
while (i < texte.length) {
// Traitement...
i++;
}
Objectif : combiner plusieurs boucles et consolider tous les concepts.
Affiche une table de multiplication complète : pour chaque nombre de 1 à 5, affiche sa table de 1 à 10.
***
***
***
*
**
***
****
Demande un nombre. Affiche tous ses diviseurs (de 1 à lui-même). Ensuite, indique s’il est premier.
Jeu de devinette amélioré : nombre secret entre 1 et 100, limite de 7 essais. Compte les tentatives et affiche “Gagné en X essais” ou “Perdu, c’était Y”.
Demande une phrase. Compte et affiche séparément : nombre de voyelles, nombre de consonnes, nombre d’espaces.
Validation en boucle : redemande un âge tant qu’il n’est pas entre 0 et 150. Puis redemande un prénom tant qu’il est vide. Affiche ensuite “Bonjour [prénom], tu as [âge] ans”.
Demande un mot. Avec une boucle, construit et affiche le mot à l’envers (sans utiliser de méthode reverse).
Mini calculatrice : redemande deux nombres et une opération (+, -, *, /) en boucle. Effectue le calcul et affiche le résultat. Continue jusqu’à ce que l’utilisateur tape “stop” comme opération.
Juste du sucre syntaxique pour while. Regroupe initialisation, condition et incrémentation en une ligne.
// Ces deux blocs font EXACTEMENT la même chose :
// Version while
let i = 0;
while (i < 10) {
console.log(i);
i++;
}
// Version for (plus compact)
for (let i = 0; i < 10; i++) {
console.log(i);
}
Syntaxe : for (initialisation; condition; incrémentation)
for : quand tu connais le nombre d’itérations (parcourir 1 à 10, parcourir un tableau)while : quand tu ne sais pas combien de tours (attendre une saisie valide, chercher un élément)Sort immédiatement de la boucle.
for (let i = 1; i <= 20; i++) {
console.log(i);
if (i === 15) break; // Arrête à 15
}
Passe directement au tour suivant.
for (let i = 1; i <= 10; i++) {
if (i % 3 === 0) continue; // Saute les multiples de 3
console.log(i); // 1, 2, 4, 5, 7, 8, 10
}
Objectif : maîtriser la boucle for et le contrôle de flux.
for.break.continue.for avec i < 5.break.continue.for et compte les voyelles.Math.floor(Math.random() * 10) + 1. Donne 3 essais maximum avec for et break quand trouvé.Structure qui stocke plusieurs valeurs dans une seule variable.
let nombres = [10, 20, 30];
let prenoms = ["Alice", "Bob", "Claire"];
let vide = []; // Tableau vide
Index commence à 0.
nombres[0] // 10 (premier)
nombres[1] // 20 (deuxième)
nombres[2] // 30 (troisième)
nombres.length // 3 (nombre d'éléments)
nombres.push(40) // Ajoute 40 à la fin → [10, 20, 30, 40]
nombres[4] = 50 // Ajoute directement à l'index 4
// Avec for (recommandé pour tableaux)
for (let i = 0; i < prenoms.length; i++) {
console.log(prenoms[i]);
}
// Avec while (fonctionne aussi)
let i = 0;
while (i < prenoms.length) {
console.log(prenoms[i]);
i++;
}
Objectif : stocker et manipuler des collections de données avec les tableaux.
0: Alice
1: Bob
2: Claire
3: David
4: Emma
Demande 5 nombres à l’utilisateur, stocke-les dans un tableau, puis affiche-les tous.
Crée un tableau de 10 nombres. Calcule et affiche la somme de tous les éléments.
Demande des mots jusqu’à ce que l’utilisateur tape “fin”. Stocke-les dans un tableau et affiche le tableau complet à la fin.
Crée un tableau de nombres. Affiche uniquement les nombres pairs qu’il contient.
Demande 5 notes, stocke-les dans un tableau. Calcule et affiche la moyenne.
Crée un tableau de nombres. Trouve et affiche le plus grand et le plus petit nombre.
Demande un mot à chercher et un tableau de mots (demande 5 mots). Affiche “Trouvé !” si le mot est dans le tableau, sinon “Pas trouvé”.
Crée deux tableaux de nombres de même taille. Crée un troisième tableau contenant la somme des éléments de même index. Affiche le résultat.
Math.random() génère un nombre décimal entre 0 (inclus) et 1 (exclus).
Pour obtenir un entier entre min et max inclus :
// Étapes :
// 1. Math.random() → 0.0 à 0.999...
// 2. * (max - min + 1) → 0.0 à (max-min+1).999...
// 3. Math.floor() → 0 à (max-min+1)
// 4. + min → min à max
// Formule complète :
let aleatoire = Math.floor(Math.random() * (max - min + 1)) + min;
// Exemples :
Math.floor(Math.random() * 100) + 1 // 1 à 100
Math.floor(Math.random() * 10) + 1 // 1 à 10
Math.floor(Math.random() * 6) + 1 // 1 à 6 (dé)
Créer plusieurs tableaux pour séparer des données.
let positifs = [];
let negatifs = [];
for (let i = 0; i < nombres.length; i++) {
if (nombres[i] > 0) {
positifs.push(nombres[i]);
} else {
negatifs.push(nombres[i]);
}
}
Compare et échange les éléments adjacents jusqu’à ce que le tableau soit trié.
// Principe : les grands nombres "remontent" comme des bulles
for (let i = 0; i < tab.length; i++) {
for (let j = 0; j < tab.length - 1; j++) {
if (tab[j] > tab[j + 1]) {
// Échange
let temp = tab[j];
tab[j] = tab[j + 1];
tab[j + 1] = temp;
}
}
}
Objectif : manipulations complexes de tableaux et premiers algorithmes.
[42, 7, 93, 15, 68, 21, 84, 3, 57, 99]
Demande 7 températures (une par jour). Stocke-les dans un tableau. Affiche la température moyenne et combien de jours étaient au-dessus de la moyenne.
Crée un tableau de prénoms. Demande un prénom à l’utilisateur et compte combien de fois il apparaît dans le tableau.
Demande 5 nombres. Crée un nouveau tableau contenant les mêmes nombres mais dans l’ordre inverse (sans méthode reverse).
Crée deux tableaux de nombres. Fusionne-les dans un troisième tableau contenant tous les éléments des deux premiers.
Demande 10 nombres. Crée deux tableaux : un avec les nombres positifs, un avec les négatifs. Affiche les deux tableaux.
Crée un tableau de mots. Affiche uniquement les mots qui contiennent plus de 5 lettres.
Demande des nombres jusqu’à ce que l’utilisateur tape 0. Stocke-les dans un tableau. Supprime tous les doublons et affiche le tableau final (parcours manuel, pas de Set).
1: 2 fois
2: 3 fois
3: 1 fois
...
texte.substring(debut, fin) // Extrait de debut à fin (exclus)
texte.slice(debut, fin) // Identique à substring
texte.indexOf(recherche) // Position de la première occurrence (-1 si absent)
texte.replace(ancien, nouveau) // Remplace première occurrence
texte.trim() // Supprime espaces début/fin
texte.includes(sous_texte) // true si contient
texte.startsWith(debut) // true si commence par
texte.endsWith(fin) // true si termine par
texte.toLowerCase() // tout en minuscules
texte.toUpperCase() // TOUT EN MAJUSCULES
texte.charAt(index) // Caractère à la position (équivalent à texte[index])
texte.charCodeAt(index) // Code ASCII du caractère
let resultat = "";
for (let i = 0; i < texte.length; i++) {
if (texte[i] !== " ") {
resultat += texte[i];
}
}
// resultat contient texte sans espaces
Objectif : maîtriser la manipulation complexe de textes.
Demande une phrase. Affiche le nombre de mots, de lettres (sans espaces) et d’espaces. Exemple : “Hello world” → 2 mots, 10 lettres, 1 espace
Demande un email. Vérifie qu’il contient un “@” et au moins un “.” après le “@”. Affiche “Valide” ou “Invalide”.
Demande une phrase. Remplace tous les espaces par des tirets “-“ (parcours caractère par caractère, pas de méthode replace).
Demande un mot. Vérifie s’il est un palindrome (identique à l’envers). Affiche “Palindrome” ou “Pas palindrome”. Exemples : “kayak”, “radar”, “level”
Demande une phrase. Affiche chaque mot avec sa première lettre en majuscule (titre de livre). Exemple : “hello world” → “Hello World”
Demande un texte et un mot à chercher. Compte combien de fois le mot apparaît dans le texte (insensible à la casse).
Demande un nom de fichier. Extrait et affiche l’extension (ce qui suit le dernier point). Exemple : “document.pdf” → “pdf”
Demande une phrase. Crée un acronyme avec la première lettre de chaque mot en majuscule. Exemple : “Base de données” → “BDD”
Demande un texte. Supprime toutes les voyelles et affiche le résultat. Exemple : “Bonjour” → “Bnjr”
Demande deux mots. Vérifie s’ils sont des anagrammes (mêmes lettres dans un ordre différent). Affiche “Anagrammes” ou “Pas anagrammes”. Exemples : “chien” et “niche”, “marie” et “aimer”