Les cours

Les bases de la programmation, notion par notion. Chaque cours commence par la
logique de l'algorithme, puis montre sa traduction en C, JavaScript et PHP.
Comprendre le raisonnement une fois pour l'écrire ensuite dans n'importe quel langage.

1 Le squelette d'un programme En cours
2 Variables et types En cours
3 Entrées et sorties En cours
4 Les opérateurs En cours
5 Les structures conditionnelles En cours
6 Les boucles En cours
7 Les tableaux En cours
8 Procédures et fonctions En cours
9 Les fichiers En cours
10 Récapitulatif des syntaxes En cours

1 — Le squelette d'un programme · aperçu

Chaque langage a son point d'entrée. C : compilé en binaire, tout part de main(), bibliothèques via #include. Java : compilé en bytecode exécuté par la JVM, tout vit dans une classe et démarre par main. JavaScript : interprété côté client, dans le navigateur — visible et modifiable par l'utilisateur. PHP : interprété côté serveur entre <?php ?> — le navigateur ne reçoit que le HTML produit. Cette distinction client/serveur est la première chose à retenir.

// C — compilé, point d'entrée main()
#include <stdio.h>

int main() {
    // instructions
    return 0;
}

// Java — tout est dans une classe
public class Programme {
    public static void main(String[] args) {
        // instructions
    }
}

<!-- JavaScript — côté client -->
<script>
  // instructions
</script>

<!-- PHP — côté serveur -->
<?php
    // instructions
?>

2 — Variables et types · aperçu

Une variable est un emplacement nommé en mémoire. C et Java : typage statique, le type est déclaré et ne change jamais (int, float/double, char, plus String et boolean en Java). JS et PHP : typage dynamique, le type est déduit de la valeur. Piège permanent : toute saisie utilisateur arrive en chaîne de caractères, donc "5" + "3" donne "53". Il faut convertir explicitement.

// C                          // Java
int nb = 10;                  int nb = 10;
float surface = 15.5;         double surface = 15.5;
char lettre = 'A';            String nom = "Stacy";
                              final double PI = 3.14;

// JS — let / const          // PHP — préfixe $
let nb = 10;                 $nb = 10;
const PI = 3.14;             $pi = 3.14;

let x = parseFloat(saisie);  $x = floatval($saisie);  // conversion

3 — Entrées et sorties · aperçu

Lire et afficher dépend du contexte d'exécution. C : scanf / printf, pilotés par formats (%d entier, %f réel) et & devant la variable lue. Java : un objet Scanner sur System.in pour lire, System.out.println() pour afficher. JS : prompt() renvoie du texte, sortie via alert(), document.write() ou console.log(). PHP : pas de saisie directe — les données viennent d'un formulaire HTML, récupérées dans $_POST et validées par isset() avant traitement.

// C — formats et esperluette
int nb;
printf("Donnez un nombre : ");
scanf("%d", &nb);
printf("Saisi : %d\n", nb);

// Java — Scanner
import java.util.Scanner;

Scanner sc = new Scanner(System.in);
System.out.print("Donnez un nombre : ");
int nb = sc.nextInt();          // nextDouble() / nextLine()
System.out.println("Saisi : " + nb);

// JS — prompt renvoie du texte
let nb = parseInt(prompt("Donnez un nombre :"));
alert("Saisi : " + nb);

// PHP — le formulaire est l'entrée
<form method="POST">
    <input type="text" name="nb">
    <input type="submit" name="Valider" value="Valider">
</form>
<?php
    if (isset($_POST["Valider"])) {
        echo "Saisi : " . intval($_POST["nb"]);
    }
?>

4 — Les opérateurs · aperçu

Arithmétique identique partout, parenthèses pour lever toute ambiguïté. Deux pièges : la division par zéro, à toujours tester avant, et la division entière en C et Java (7 / 2 vaut 3). Le modulo % donne le reste : c'est l'outil de la divisibilité et de la parité. Ne jamais confondre = (affecte) et == (compare) ; === compare aussi le type en JS et PHP, et en Java on compare les chaînes avec .equals(), jamais avec ==. Concaténation : + en C-like et JS, . en PHP.

Arithmétique   +   -   *   /   %(modulo)
Comparaison    ==   !=   <   >   <=   >=
Identité       ===  !==        (JS et PHP)
Chaînes        .equals()       (Java)
Logique        &&(ET)   ||(OU)   !(NON)
Affectation    =        ≠ ==

6 % 3        // → 0   3 divise 6
6 % 4        // → 2   4 ne divise pas 6
n % 2 == 0   // n est pair

7 / 2        // → 3 en C et Java (division entière)
             // → 3.5 en JS et PHP

5 — Les structures conditionnelles · aperçu

if / else a la même syntaxe dans les quatre langages. On imbrique pour des cas hiérarchisés, on chaîne avec else if pour des cas de même niveau, on utilise switch pour comparer une variable à des valeurs fixes. Règle d'or : les cas particuliers et les cas d'erreur passent avant le cas général — c'est ce qui protège le calcul qui suit.

// Syntaxe commune C / Java / JS / PHP
if (a == 0) {
    // cas particulier d'abord
} else if (a > 0) {
    // autre cas
} else {
    // cas restant
}

// Imbrication : sécuriser AVANT de calculer
if (a == 0) {
    if (b == 0) { message = "Une infinité de solutions"; }
    else        { message = "Aucune solution"; }
} else {
    x = -b / a;        // ici a ≠ 0 : division sûre
}

6 — Les boucles · aperçu

Une seule question détermine le choix : connaît-on le nombre de répétitions ? Oui → for, qui réunit initialisation, condition et incrémentation sur une ligne. Non → while, ou do...while si le bloc doit s'exécuter au moins une fois. Risque constant : la boucle infinie, quand la condition d'arrêt ne peut jamais devenir fausse. La syntaxe est identique partout, à la déclaration du compteur près.

// POUR — (1: init ; 2: condition ; 3: incrémentation)
for (int i = 1; i <= n; i++) { }    // C et Java
for (let i = 1; i <= n; i++) { }    // JS
for ($i = 1; $i <= $n; $i++) { }    // PHP

// TANT QUE — modifier la condition ici, sinon boucle infinie
while (condition) { }

// Boucle + condition : parcourir en filtrant
let resultats = [];
for (let i = 1; i <= n; i++) {
    if (n % i == 0) {
        resultats.push(i);
    }
}
console.log(resultats.join(", "));

7 — Les tableaux · aperçu

Un tableau regroupe sous un seul nom plusieurs valeurs de même type, repérées par un indice. Piège majeur : en algorithmique on compte souvent de 1 à n, mais dans les quatre langages l'indice commence à 0 — un tableau de 10 cases va de tab[0] à tab[9], d'où i < 10 et jamais i <= 10. C et Java : taille fixe, déclarée une fois pour toutes. JS et PHP : tableaux dynamiques qui grandissent à la demande, taille obtenue par .length ou count(). On parcourt un tableau avec une boucle for, et pour chercher un minimum ou un maximum on part de la première case, jamais de 0.

// C — taille fixe             // Java — taille fixe
float tab[10];                 double[] tab = new double[10];
tab[0] = 12.5;                 tab[0] = 12.5;
                               tab.length      // → 10

// Parcours : de 0 à taille - 1
for (i = 0; i < 10; i++) { }

// JS                          // PHP
let tab = [12.5, 8, 20];       $tab = [12.5, 8, 20];
tab.push(15);                  $tab[] = 15;
tab.length    // → 4           count($tab)     // → 4

// Saisie groupée "12;8;20" → tableau de nombres
let t = saisie.split(";").map(Number);
$t = array_map("floatval", explode(";", $saisie));

8 — Procédures et fonctions · aperçu

Découper un programme en sous-programmes nommés, c'est l'écrire une fois et l'appeler autant de fois qu'il faut. Une procédure exécute des actions et ne renvoie rien (void en C et Java). Une fonction calcule une valeur et la renvoie avec return ; l'appelant décide quoi en faire. Les paramètres transmettent les données : le paramètre formel (nb, dans la définition) reçoit une copie du paramètre effectif (unNb, à l'appel). En C, le sous-programme doit être écrit avant main() ; en Java, c'est une méthode static de la classe.

// C — procédure : void, pas de return
void mesDiviseurs(int nb) { /* affiche */ }

// C — fonction : type de retour + return
int estPair(int n) { return n % 2 == 0; }

// Java — méthodes static dans la classe
static void mesDiviseurs(int nb) { }
static boolean estPair(int n) { return n % 2 == 0; }

// JS — function, sans type
function estPair(n) { return n % 2 == 0; }

// PHP — function, paramètres en $
function estPair($n) { return $n % 2 == 0; }

// Appel : l'effectif est copié dans le formel
mesDiviseurs(unNb);         // unNb → nb
if (estPair(x)) { }         // la valeur renvoyée sert ici

9 — Les fichiers · aperçu

Un fichier conserve les données après la fin du programme. Toujours trois temps : ouvrir ("r" lecture, "w" écriture qui écrase, "a" ajout en fin), traiter, fermer. Toujours vérifier que l'ouverture a réussi : un fichier absent renvoie NULL en C, false en PHP, une exception en Java. On lit caractère par caractère jusqu'à la fin du fichier (EOF). Piège C : while (!feof(fs)) détecte la fin après une lecture ratée et recopie un caractère parasite — on teste plutôt ce que renvoie fgetc, stocké dans un int. JS dans le navigateur n'a pas accès au disque (sécurité) : il faut Node.js. PHP lit et écrit les fichiers du serveur.

// C — ouvrir / traiter / fermer
FILE *fs = fopen("source.txt", "r");
if (fs == NULL) { /* introuvable */ }
int car;                            // int : pour recevoir EOF
while ((car = fgetc(fs)) != EOF) {
    putchar(car);
}
fclose(fs);

// Java — read() renvoie -1 en fin de fichier
try (FileReader fs = new FileReader("source.txt")) {
    int car;
    while ((car = fs.read()) != -1) { }
}                                   // fermé automatiquement

// PHP — mêmes étapes, côté serveur
$fs = fopen("source.txt", "r");
while (($car = fgetc($fs)) !== false) {
    echo $car;
}
fclose($fs);

// JS — Node.js uniquement
const fs = require("fs");
let contenu = fs.readFileSync("source.txt", "utf8");

10 — Récapitulatif des syntaxes · aperçu

Les quatre langages partagent la même logique — séquence, condition, répétition, découpage — et ne diffèrent que par l'habillage. Maîtriser l'algorithme, c'est n'avoir plus qu'un tableau de correspondances à apprendre. Conventions valables partout : indentation par bloc, noms explicites, commentaires utiles, point-virgule en fin d'instruction.

             Déclarer   Lire                Afficher
C            int nb;    scanf("%d", &nb)    printf("%d", nb)
Java         int nb;    sc.nextInt()        System.out.println(nb)
JavaScript   let nb;    prompt("...")       console.log(nb)
PHP          $nb        $_POST["nb"]        echo $nb;

             Tableau                  Taille      Fonction
C            float t[10];             fixe        int f(int n) { }
Java         double[] t = new ...     t.length    static int f(int n) { }
JavaScript   let t = [];              t.length    function f(n) { }
PHP          $t = [];                 count($t)   function f($n) { }

Conversion   C: %d / %f   Java: Integer.parseInt()
             JS: parseInt()   PHP: intval()
Concaténer   Java et JS: "a" + b   PHP: "a" . $b
Indices      algo: 1 à n   code: 0 à n-1
Fichiers     C: fopen / fgetc / fputc / fclose
             Java: FileReader / FileWriter   PHP: fopen / fwrite
             JS: Node.js uniquement (module fs)
Exécution    C: natif   Java: JVM   JS: client   PHP: serveur

Le tronc commun :

  variables  →  stocker
  E / S      →  lire et afficher
  condition  →  choisir
  boucle     →  répéter
  tableau    →  regrouper
  fonction   →  découper et réutiliser
  fichier    →  conserver

Tout le reste n'est que syntaxe.