JavaScript - Syntaxe et variables

Variables

En JavaScript, une variable permet de stocker une valeur en mémoire afin de la réutiliser ou l'afficher plus tard dans le programme.

Aujourd’hui, pour déclarer une variable, on utilise presque exclusivement let et const.

let age = 30;
let nom = "Jean";
const PI = 3.14;

• let : variable modifiable, portée limitée au bloc {}
• const : variable non modifiable (constante)
• var : ancienne syntaxe, à éviter (problèmes de portée et de lisibilité)

👉 Bonne pratique :

• utiliser const par défaut
• utiliser let uniquement si la valeur doit changer
• Tu verras var dans d'anciens tutoriels. Il fonctionne, mais il a des comportements imprévisibles. On ne l'utilise plus.

Types de données

JavaScript est un langage à typage dynamique : le type est déterminé automatiquement lors de l'affectation d'une valeur.

let nombre = 10;                 // Number
let pi = 3.1415;                // Number
let prenom = "Alice";           // String
let estConnecte = true;         // Boolean
let fruits = ["pomme", "banane"]; // Array
let personne = { nom: "Jean", age: 30 }; // Object

Types courants : Number, String, Boolean

string — chaîne de caractères

Du texte, toujours entre guillemets (simples, doubles, ou backticks).

let ville = "Bruxelles";
let message = 'Bonjour tout le monde';
let phrase = `La ville est ${ville}`; // template literal

Les backticks (`) permettent d'insérer des variables directement dans le texte avec ${} — c'est très pratique.

let prenom = "Lucas";
let age = 16;
console.log(`Je m'appelle ${prenom} et j'ai ${age} ans.`);
// → Je m'appelle Lucas et j'ai 16 ans.

number — nombre

Entiers et décimaux, sans guillemets.

let temperature = -3;
let prix = 9.99;
let annee = 2025;

boolean — vrai ou faux

Exactement deux valeurs possibles : true ou false.

let estConnecte = true;
let aPayé = false;

Les booléens sont au cœur de toutes les conditions et décisions du programme.

Conventions de nommage

Le code qu'on écrit est lu par d'autres humains (et par son futur soi). Un bon nommage, ça évite des heures de confusion.

camelCase — la convention JS

En JavaScript, les variables et fonctions s'écrivent en camelCase : la première lettre est minuscule, chaque mot suivant commence par une majuscule.

// ✅ Correct
let nombreDEleves = 28;
let prixUnitaire = 4.5;
let nomUtilisateur = "Amir";

// ❌ À éviter
let nombre_d_eleves = 28;  // snake_case (Python, pas JS)
let PrixUnitaire = 4.5;    // PascalCase (réservé aux classes)
let p = 4.5;               // trop court, sans sens

Autres règles

• Nom descriptif : scoreJoueur plutôt que sj ou x
• Commence par une lettre : pas de chiffre en début (3prix → ❌)
• Pas d'accents ni d'espaces : nombreEtudiants et non nombreÉtudiants
• Respecte la casse : age, Age et AGE sont trois variables différentes

// Exemple concret bien nommé
const nombreDeVies = 3;
let scoreActuel = 0;
let nomDuJoueur = prompt("Ton pseudo ?");

console.log(`${nomDuJoueur} commence avec ${nombreDeVies} vies.`);

Un bon nom de variable, c'est un commentaire gratuit. Si tu dois ajouter un commentaire pour expliquer ce que contient une variable, c'est souvent signe que son nom n'est pas assez clair.

Opérateurs arithmétiques

Les opérateurs permettent de manipuler les valeurs numériques.

Exemples:

let a = 10;
let b = 3;

console.log(a + b);  // → 13  (addition)
console.log(a - b);  // → 7   (soustraction)
console.log(a * b);  // → 30  (multiplication)
console.log(a / b);  // → 3.333...  (division)
console.log(a % b);  // → 1   (modulo : reste de la division)
console.log(a ** b); // → 1000  (puissance)

Le modulo (%) est très utile en pratique : il permet de savoir si un nombre est pair, de créer des cycles, etc.

console.log(8 % 2);  // → 0  (pair)
console.log(7 % 2);  // → 1  (impair)

### PEMDAS
JavaScript respecte strictement la règle PEMDAS, comme la plupart des langages de programmation.

PEMDAS définit l’ordre de priorité des opérations arithmétiques :

- Parentheses → ()
- Exposants → **
- Multiplication → *
- Division → /
- Addition → +
- Subtraction → -

Si 2 opérations ont la même priorité, elles sont exécutées de gauche à droite.

```javascript
let resultat = 20 / 5 * 2;
console.log(resultat);

Résultat: 8. Division et multiplication ont la même priorité, l’évaluation se fait de gauche à droite.

Division entière

Contrairement à Python, JavaScript ne possède pas d’opérateur de division entière. On utilise donc Math.floor().

let resultat = Math.floor(10 / 3); // 3

Points-virgules

Les points-virgules ; marquent la fin d’une instruction.

JavaScript peut parfois s’en passer, mais il est fortement recommandé de les utiliser.

let x = 5;
let y = 10;

Conclusion

Cette page couvre les fondations indispensables de JavaScript : variables, types, opérateurs et structure du code. Ces bases sont importantes avant d’aborder les conditions, les boucles, les fonctions et la programmation Web dynamique.