Votre premier programme

Objectifs

À la fin de cette leçon, vous saurez :

• expliquer pourquoi ce cursus utilise JavaScript partout ;
• distinguer langage, moteur et runtime (et situer Node dans tout ça) ;
• écrire, exécuter et modifier votre premier programme ;
• lire vos premières erreurs sans panique, y compris la fameuse erreur de syntaxe.

🔗 Pour vous rafraîchir la mémoire : du programme au processus

Pourquoi JavaScript ?

Le cursus utilise un seul langage, volontairement :

• dans le terminal, avec Node.js (ce chapitre) ;
• dans le navigateur, pour rendre les pages interactives (chapitres front-end) ;
• côté serveur, pour construire des API (chapitres back-end) ;
• puis comme socle de TypeScript (partie 6).

L'intérêt est pédagogique autant que pratique : chaque notion apprise (variables, fonctions, boucles...) est réinvestie telle quelle dans la leçon suivante, quel que soit l'environnement. C'est aussi le langage du web par excellence : il n'existe pas de navigateur sans moteur JavaScript.

JavaScript, V8, Node : trois niveaux à ne pas confondre

JavaScript  = le langage (sa grammaire : variables, fonctions, boucles...)
V8          = le moteur qui traduit et exécute ce langage en instructions machine
Node.js     = le programme complet qui embarque V8 et y ajoute les accès système

Pourquoi trois noms ? Parce que le même langage tourne dans plusieurs maisons :

• dans Chrome, c'est V8 qui exécute le JavaScript des pages web ;
• dans Firefox, un autre moteur (SpiderMonkey) exécute le même langage ;
• dans votre terminal, c'est Node qui exécute le même langage, avec un bonus décisif pour nous : l'accès aux fichiers, au réseau, aux processus — tout ce dont un serveur a besoin et que le navigateur interdit.

Rappel du chapitre 2 : quand vous tapez node hello.js, le shell lance un nouveau processus node, qui lit le fichier sur disque et exécute son contenu instruction par instruction. Le fichier .js reste inertre sur le disque ; seul Node lui donne vie.

Vérifier l'installation

$ node --version
v22.11.0

(Le numéro exact peut différer ; l'important est d'en avoir un.) Si la commande est introuvable, retournez vérifier l'installation de la VM avant de continuer.

Écrire et exécuter le programme

Créez un dossier de travail puis un fichier hello.js :

mkdir -p ~/cours/js && cd ~/cours/js
nano hello.js

Contenu :

console.log("Hello World");

Une seule ligne. Décomposons-la : console.log est une fonction fournie par Node ; elle reçoit ici la chaîne de caractères "Hello World" et l'écrit sur la sortie standard. Les guillemets délimitent une chaîne (du texte brut) : tout ce qui s'y trouve est affiché tel quel, jamais calculé.

Exécution :

$ node hello.js
Hello World
$

Ce qui vient réellement de se passer, étape par étape :

1. le shell découpe node hello.js et trouve /usr/bin/node via PATH ;
2. un processus node démarre, avec hello.js en argument ;
3. Node lit le fichier depuis le répertoire courant, l'analyse (syntaxe), puis l'exécute ;
4. console.log écrit sur stdout → le texte apparaît dans votre terminal ;
5. fin du script → fin du processus, code de retour 0 (vérifiez avec echo $? !).

Calculer ou afficher : deux mondes différents

Modifions le programme :

console.log("Mon premier");
console.log(1 + 2);
console.log("1 + 2");
console.log(`1 + 2 = ${1 + 2}`);

$ node hello.js
Mon premier
3
1 + 2
1 + 2 = 3

Quatre lignes, quatre comportements :

• "Mon premier" : texte pur, affiché tel quel ;
• 1 + 2 : une expression — Node la calcule (résultat 3), puis affiche ce résultat ;
• "1 + 2" : du texte qui ressemble à un calcul — affiché sans être évalué ;
• `1 + 2 = ${1 + 2}` : une chaîne modèle (backticks) où ${...} contient une expression évaluée puis insérée dans le texte.

Cette distinction « texte affiché / expression calculée » paraît évidente ; elle explique pourtant des heures de confusion chez les débutants. Retenez : entre guillemets doubles ou simples, rien n'est calculé ; entre backticks, seul ce qui est dans ${} l'est.

La console interactive (REPL)

Tapez node sans argument :

$ node
Welcome to Node.js v22.11.0.
Type ".help" for more information.
> 1 + 2
3
> "abc".toUpperCase()
'ABC'
> .exit
$

C'est le REPL (Read-Eval-Print Loop) : vous tapez une expression, Node la lit (Read), l'évalue (Eval), affiche le résultat (Print), et recommence (Loop). Différence subtile avec un fichier : le REPL affiche la valeur de chaque expression même sans console.log. Idéal pour tester une idée en dix secondes ; on sort avec .exit ou Ctrl+D.

Habitude à prendre dès maintenant : REPL pour essayer, fichier pour construire. Avant d'écrire dix lignes douteuses dans un script, testez l'idée en une ligne dans le REPL.

La première erreur : apprenez à la lire dès aujourd'hui

Il va arriver une chose certaine : vous écrirez du code fautif. Entraînons-nous volontairement. Ajoutez cette ligne à hello.js :

console.log("oops);

(guillemet fermant oublié) puis relancez :

$ node hello.js
console.log("oops);
           ^^^^

SyntaxError: missing ) after argument list
    at /home/cours/cours/js/hello.js:5:12

Lisez lentement ce que la machine vous offre :

1. le type d'erreur : SyntaxError — le texte ne respecte pas la grammaire du langage ; rien n'a été exécuté du tout ;
2. la description : missing ) after argument list — une parenthèse ou un guillemet mal fermé ;
3. l'emplacement : fichier, ligne 5 (:5), colonne 12 — et le petit ^^^^ pointe le lieu exact.

Corrigez, relancez : ça marche. Ce rituel (erreur → lecture → localisation → correction → relance) est le geste quotidien du développeur. Le chapitre 6 en fera une méthode complète ; dès aujourd'hui, prenez l'habitude de ne jamais fermer les yeux devant un message d'erreur.

Exercice

1. Créez hello.js et exécutez-le.
2. Ajoutez console.log(20 + 22) et relancez.
3. Ajoutez console.log("20 + 22") et relancez. Expliquez la différence avec la ligne précédente.
4. Affichez une phrase complète avec votre prénom inséré depuis une variable, via backticks.
5. Dans le REPL, calculez 7 * 6, puis faites dire "bonjour".length — que renvoie-t-il ?
6. Exécutez node hello.js depuis /tmp. Que faut-il changer ? Pourquoi ?
7. Provoquez volontairement une SyntaxError (parenthèse manquante), lisez le message, corrigez, revérifiez avec echo $? que tout rentre dans l'ordre.

Résumé

• Un langage partout : terminal (Node), navigateur, serveur, TypeScript ensuite.
• Langage ≠ moteur (V8 traduit/exécute) ≠ runtime (Node ajoute fichiers/réseau/processus).
• console.log(...) écrit sur stdout ; entre guillemets rien ne se calcule, dans ${} oui.
• REPL pour tester vite, fichiers pour construire.
• Une erreur se lit : type + description + ligne. C'est déjà du débogage.

$ node hello.js
Hello World

42
20 + 22

const prenom = "Alice";
console.log(`Bonjour ${prenom}, bienvenue !`);
// Bonjour Alice, bienvenue !

> 7 * 6
42
> "bonjour".length
7

Error: Cannot find module '/tmp/hello.js'

$ echo $?
0