La Structure d'un Programme — Cours débutant

Section 01

1 C'est quoi un programme ?

Un programme est comme une recette de cuisine : il reçoit des ingrédients (les données), suit des étapes (le code), et produit un plat (le résultat).

📌 Idée clé

Tout programme, quelle que soit sa complexité, suit toujours le même schéma de base : recevoir → traiter → communiquer.

1

Le programme reçoit des informations
L'utilisateur tape quelque chose, un fichier est lu, une valeur est fournie…

2

Le programme traite ces informations
Il effectue des calculs, des comparaisons, des transformations.

3

Le programme communique ses résultats
Il affiche un résultat, enregistre un fichier, ou signale une erreur.

🧠 Astuce mémoire

Pense à un distributeur automatique : tu insères une pièce (entrée), la machine traite ta commande (traitement), et te donne le produit ou affiche une erreur (sortie ou erreur).

Section 02

2 Les trois flux

Un programme communique avec le monde extérieur via trois canaux, appelés flux standards. Chaque flux a un rôle précis et une couleur différente dans ce cours :

⌨️

Entrée

stdin

données

⚙️

Programme

traitement

▶

🖥️

Sortie

stdout

▶

⚠️

Erreur

stderr

stdin — ce que reçoit le programme

stdout — le résultat normal

stderr — les messages d'erreur

⚠️ Attention

Sortie normale et erreur sont deux canaux séparés. Ils peuvent être redirigés indépendamment dans un terminal. Ce n'est pas la même chose !

Section 03

3 L'entrée — stdin

L'entrée standard (stdin) est le moyen qu'a un programme pour recevoir des informations. En mode console, c'est ce que l'utilisateur tape au clavier. On peut aussi fournir des données depuis un fichier.

Comment lire une entrée dans chaque langage

        
        
        
      

1// Node.js — lecture d'une entrée via readline
2const readline = require('readline');
3
4const rl = readline.createInterface({
5  input: process.stdin,   // ← flux d'entrée
6  output: process.stdout
7});
8
9rl.question('Quel est ton prénom ? ', (prenom) => {
10  // prenom contient ce que l'utilisateur a tapé
11  console.log(`Bonjour, ${prenom} !`);
12  rl.close();
13});
      

1// PHP — lecture depuis stdin
2<?php
3
4// Afficher une question
5echo 'Quel est ton prénom ? ';
6
7// Lire la réponse depuis l'entrée standard
8$prenom = trim(fgets(STDIN));   // ← flux d'entrée
9
10echo "Bonjour, $prenom !\n";
      

1// C# — lecture depuis stdin
2using System;
3
4Console.Write("Quel est ton prénom ? ");
5
6// Console.ReadLine() lit depuis stdin
7string prenom = Console.ReadLine();  // ← flux d'entrée
8
9Console.WriteLine($"Bonjour, {prenom} !");
      

🧠 À retenir

La lecture se fait toujours depuis un flux : process.stdin, STDIN, ou Console.ReadLine(). Ce sont trois façons différentes de dire "lis ce que l'utilisateur a tapé".

Section 04

4 La sortie — stdout

La sortie standard (stdout) est utilisée pour afficher les résultats normaux d'un programme. C'est ce que l'utilisateur voit s'afficher dans le terminal lorsque tout se passe bien.

Écrire sur la sortie standard

        
        
        
      

1// JavaScript — écrire sur stdout
2
3// Méthode habituelle
4console.log('Résultat : 42');
5
6// Écriture directe sur stdout (sans saut de ligne automatique)
7process.stdout.write('Chargement...');
8
9// Exemple complet
10const score = 98;
11console.log(`Ton score : ${score}/100`); // → stdout
      

1// PHP — écrire sur stdout
2<?php
3
4// echo écrit directement sur stdout
5echo "Résultat : 42\n";
6
7// Autre façon
8fwrite(STDOUT, "Chargement...\n");
9
10// Exemple complet
11$score = 98;
12echo "Ton score : $score/100\n"; // → stdout
      

1// C# — écrire sur stdout
2using System;
3
4// WriteLine ajoute un saut de ligne
5Console.WriteLine("Résultat : 42");
6
7// Write n'ajoute pas de saut de ligne
8Console.Write("Chargement...");
9
10// Exemple complet
11int score = 98;
12Console.WriteLine($"Ton score : {score}/100"); // → stdout
      

💡 Différence Write vs WriteLine

Write (ou process.stdout.write) écrit sans aller à la ligne. WriteLine (ou console.log, echo) écrit et passe automatiquement à la ligne suivante.

Section 05

5 L'erreur — stderr

La sortie d'erreur (stderr) est un flux séparé de stdout, dédié aux messages d'erreur et d'avertissement. Même si les deux s'affichent dans le terminal par défaut, ils peuvent être redirigés indépendamment.

⚠️ Pourquoi séparer les erreurs ?

Si tu envoies le résultat d'un programme vers un fichier (monprog > résultats.txt), les erreurs s'affichent quand même dans le terminal grâce à stderr. Le fichier reste propre et ne contient que les vrais résultats.

Écrire sur la sortie d'erreur

        
        
        
      

1// JavaScript — écrire sur stderr
2
3// console.error → stderr (s'affiche en rouge dans de nombreux terminaux)
4console.error('Erreur : fichier introuvable !');
5
6// Écriture directe
7process.stderr.write('Problème critique\n');
8
9// Exemple complet : sortie normale + erreur séparées
10const age = -5;
11if (age < 0) {
12  console.error(`Erreur : l'âge ne peut pas être négatif (reçu: ${age})`);
13} else {
14  console.log(`Âge valide : ${age} ans`);
15}
      

1// PHP — écrire sur stderr
2<?php
3
4// Écriture directe sur STDERR
5fwrite(STDERR, "Erreur : fichier introuvable !\n");
6
7// Exemple complet
8$age = -5;
9if ($age < 0) {
10  fwrite(STDERR, "Erreur : l'âge ne peut pas être négatif (reçu: $age)\n");
11} else {
12  echo "Âge valide : $age ans\n";
13}
      

1// C# — écrire sur stderr
2using System;
3
4// Console.Error → stderr
5Console.Error.WriteLine("Erreur : fichier introuvable !");
6
7// Exemple complet
8int age = -5;
9if (age < 0) {
10  Console.Error.WriteLine($"Erreur : l'âge ne peut pas être négatif (reçu: {age})");
11} else {
12  Console.WriteLine($"Âge valide : {age} ans");
13}
      

Section 06

6 Tableau comparatif

Un récapitulatif visuel des trois flux dans les trois langages :

Flux	Rôle	JS Node.js	PHP	C#
stdin	Lire une entrée	process.stdin rl.question()	STDIN fgets(STDIN)	Console.ReadLine()
stdout	Résultat normal	console.log() process.stdout.write()	echo fwrite(STDOUT, …)	Console.WriteLine() Console.Write()
stderr	Messages d'erreur	console.error() process.stderr.write()	fwrite(STDERR, …)	Console.Error.WriteLine()

Programme complet — les trois flux ensemble

        
        
        
      

1const readline = require('readline');
2const rl = readline.createInterface({ input: process.stdin });
3
4rl.question('Entrez un nombre positif : ', (saisie) => {
5  const nombre = Number(saisie); // conversion texte → nombre
6
7  if (isNaN(nombre) || nombre <= 0) {
8    // ← stderr : signale le problème
9    console.error('Erreur : ce n\'est pas un nombre positif !');
10  } else {
11    // ← stdout : affiche le résultat
12    console.log(`Le double de ${nombre} est : ${nombre * 2}`);
13  }
14  rl.close();
15});
      

1<?php
2echo 'Entrez un nombre positif : ';
3
4// ← stdin : lecture de l'entrée
5$saisie = trim(fgets(STDIN));
6$nombre = (float) $saisie;
7
8if (!is_numeric($saisie) || $nombre <= 0) {
9  // ← stderr
10  fwrite(STDERR, "Erreur : ce n'est pas un nombre positif !\n");
11} else {
12  // ← stdout
13  echo "Le double de $nombre est : " . ($nombre * 2) . "\n";
14}
      

1using System;
2
3Console.Write("Entrez un nombre positif : ");
4
5// ← stdin
6string saisie = Console.ReadLine();
7
8if (!double.TryParse(saisie, out double nombre) || nombre <= 0) {
9  // ← stderr
10  Console.Error.WriteLine("Erreur : ce n'est pas un nombre positif !");
11} else {
12  // ← stdout
13  Console.WriteLine($"Le double de {nombre} est : {nombre * 2}");
14}
      

Section 07

7 Exercices

Trois exercices pour pratiquer. Commence par le premier, puis avance à ton rythme.

Exercice 1 Facile

Bonjour, Monde personnalisé

Écris un programme qui demande le prénom de l'utilisateur, puis affiche un message de bienvenue personnalisé sur la sortie standard.

Lire le prénom depuis stdin
Afficher "Bonjour, [prénom] !" sur stdout
Tester avec ton propre prénom

Réutilise les exemples de la section 3 — c'est presque le même code !

Exercice 2 Moyen

Calculatrice simple avec gestion d'erreur

Demande deux nombres à l'utilisateur, puis effectue leur addition. Si l'utilisateur entre une valeur non numérique, affiche un message d'erreur sur stderr.

Lire deux valeurs depuis stdin (deux questions séparées)
Vérifier que les deux valeurs sont bien des nombres
Si oui → afficher la somme sur stdout
Si non → afficher "Erreur : valeur invalide" sur stderr

Pour vérifier si une valeur est un nombre : isNaN() en JS, is_numeric() en PHP, double.TryParse() en C#.

Exercice 3 Avancé

Convertisseur Celsius / Fahrenheit

Le programme demande une température en Celsius et un choix de conversion. Il affiche le résultat sur stdout. Si la température saisie est en dehors de la plage physiquement possible (< −273,15 °C), il signale une erreur sur stderr.

Demander la température (stdin)
Vérifier qu'elle est > −273,15 (zéro absolu)
Afficher la conversion : °F = °C × 9/5 + 32 sur stdout
Si invalide → message explicite sur stderr
Bonus : proposer aussi la conversion inverse (°F → °C)

Pense à séparer clairement les cas "tout va bien" (stdout) et "quelque chose cloche" (stderr). C'est ça le cœur de cet exercice.

Section 08 — Bonus

8 Redirection dans le terminal

Un des grands avantages d'avoir des flux séparés : tu peux les rediriger indépendamment depuis le terminal, sans toucher au code.

📌 Pourquoi c'est utile ?

Imagine un programme qui traite des milliers de lignes. Tu veux garder les résultats dans un fichier, mais voir les erreurs à l'écran en temps réel. La redirection le permet en une seule commande.

Les opérateurs de redirection

>

Redirige stdout vers un fichier
écrase le fichier existant

>>

Redirige stdout vers un fichier
ajoute à la suite (append)

2>

Redirige stderr vers un fichier
le 2 désigne le flux erreur

<

Redirige un fichier vers stdin
le programme lit le fichier

2>&1

Fusionne stderr dans stdout
tout dans le même flux

|

Pipe : connecte stdout
vers l'entrée d'un autre programme

Exemples concrets en terminal

Terminal

$ node monprog.js # exécution normale

$ node monprog.js > resultats.txt

# stdout → fichier, stderr reste visible dans le terminal

$ node monprog.js 2> erreurs.txt

# stderr → fichier, stdout reste visible dans le terminal

$ node monprog.js > resultats.txt 2> erreurs.txt

# stdout et stderr chacun dans leur fichier

$ node monprog.js < donnees.txt

# stdin vient d'un fichier : le programme lit donnees.txt

$ echo "42" | node monprog.js

# le texte "42" devient l'entrée du programme via pipe

🧠 Retiens les chiffres

Dans un système, chaque flux a un numéro : 0 = stdin, 1 = stdout, 2 = stderr. C'est pourquoi on écrit 2> pour rediriger les erreurs.

Même logique en PHP et C#

Les commandes de redirection sont les mêmes dans le terminal, peu importe le langage :

Terminal

$ php monprog.php > resultats.txt 2> erreurs.txt

$ dotnet run > resultats.txt 2> erreurs.txt

Section 09

9 Solutions des exercices

✋ Essaie d'abord !

Tente les exercices par toi-même avant de regarder les solutions. C'est en faisant des erreurs qu'on apprend le mieux.

            
            
            
          

1const readline = require('readline');
2const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
3
4const ZERO_ABSOLU = -273.15;
5
6rl.question('Température en Celsius : ', (saisie) => {
7  const celsius = Number(saisie);
8
9  if (isNaN(celsius)) {
10    console.error('Erreur : valeur non numérique.');
11    rl.close(); return;
12  }
13  if (celsius < ZERO_ABSOLU) {
14    console.error(`Erreur : impossible d'avoir moins de ${ZERO_ABSOLU}°C (zéro absolu).`);
15    rl.close(); return;
16  }
17
18  // Conversion
19  const fahrenheit = celsius * 9 / 5 + 32;
20  console.log(`${celsius}°C = ${fahrenheit.toFixed(2)}°F`);
21
22  // Bonus : inverse
23  const retour = (fahrenheit - 32) * 5 / 9;
24  console.log(`(vérification inverse : ${retour.toFixed(2)}°C)`);
25  rl.close();
26});
          

1<?php
2define('ZERO_ABSOLU', -273.15);
3
4echo 'Température en Celsius : ';
5$saisie = trim(fgets(STDIN));
6
7if (!is_numeric($saisie)) {
8  fwrite(STDERR, "Erreur : valeur non numérique.\n");
9  exit(1);
10}
11$celsius = (float)$saisie;
12
13if ($celsius < ZERO_ABSOLU) {
14  fwrite(STDERR, "Erreur : impossible d'avoir moins de " . ZERO_ABSOLU . "°C.\n");
15  exit(1);
16}
17
18$fahrenheit = $celsius * 9 / 5 + 32;
19echo number_format($celsius, 2) . "°C = " . number_format($fahrenheit, 2) . "°F\n";
20
21// Bonus
22$retour = ($fahrenheit - 32) * 5 / 9;
23echo "(vérification inverse : " . number_format($retour, 2) . "°C)\n";
          

1using System;
2
3const double ZERO_ABSOLU = -273.15;
4
5Console.Write("Température en Celsius : ");
6string saisie = Console.ReadLine() ?? "";
7
8if (!double.TryParse(saisie, out double celsius)) {
9  Console.Error.WriteLine("Erreur : valeur non numérique.");
10  return;
11}
12if (celsius < ZERO_ABSOLU) {
13  Console.Error.WriteLine($"Erreur : impossible d'avoir moins de {ZERO_ABSOLU}°C.");
14  return;
15}
16
17double fahrenheit = celsius * 9.0 / 5.0 + 32;
18Console.WriteLine($"{celsius:F2}°C = {fahrenheit:F2}°F");
19
20// Bonus
21double retour = (fahrenheit - 32) * 5.0 / 9.0;
22Console.WriteLine($"(vérification inverse : {retour:F2}°C)");
          

Section 10

10 Quiz — Teste tes connaissances

Six questions pour valider ce que tu as appris. Clique sur la réponse que tu penses correcte.

Résumé

Ce que tu as appris

⌨️

stdin

Ce que l'utilisateur fournit au programme

🖥️

stdout

Les résultats normaux du programme

⚠️

stderr

Les messages d'erreur, séparés du reste

↪️

Redirection

Flux séparés, pilotables depuis le terminal

✅ Le schéma universel

Tout programme = Entrée → Traitement → Sortie. Ce schéma s'applique en JS, PHP, C#, Python, Java, et dans tous les langages que tu rencontreras.