Voici la traduction de l'article du russe vers le français, en respectant toutes les règles :

Qu'est-ce que c'est et pourquoi ?

Imagine que tu es caissier dans un magasin de bonbons. Un client s'approche et dit : « Donnez-moi 3 chocolats à 50 roubles et 2 limonades à 70 roubles ». Pour calculer le total, tu dois multiplier (3 × 50 et 2 × 70), puis additionner les résultats. Et si le client donne 500 roubles, tu dois soustraire le montant des achats pour rendre la monnaie. Si les bonbons sont vendus par paquets de 4 et qu'il en faut 10, tu devras diviser pour savoir combien de paquets prendre.

En JavaScript, les opérations arithmétiques fonctionnent exactement comme en cours de maths. Sauf qu'au lieu d'écrire sur du papier, tu donnes des ordres à l'ordinateur. L'ordinateur calcule instantanément et ne se trompe jamais (sauf si tu te trompes dans la commande).

Pourquoi un programmeur en a-t-il besoin ? Imagine que tu écris un jeu où un personnage ramasse des pièces. Chaque pièce ajoute 10 points. Tu dois savoir ajouter 10 au score actuel. Ou encore, si tu fais une calculatrice pour les cours de physique, tu auras besoin de toutes les opérations à la fois.

En JavaScript, il y a 5 opérations arithmétiques de base :

• + — addition (comme à l'école)
• - — soustraction
• * — multiplication (astérisque, car il n'y a pas de signe × sur le clavier)
• / — division (slash, car il n'y a pas de signe ÷)
• % — reste de la division (c'est nouveau ! Il montre ce qu'il reste si on divise entièrement)

Contrairement à Python, où la division donne toujours un nombre décimal (par exemple, 10 / 3 = 3.333...), en JavaScript aussi il y a des nombres décimaux, mais il y a une astuce : les nombres entiers en JS peuvent se comporter de manière inattendue s'ils sont grands. Mais on verra ça plus tard.

La règle principale : l'ordinateur effectue les opérations dans le même ordre qu'en maths : d'abord multiplication et division, puis addition et soustraction. Les parenthèses changent l'ordre. Souviens-toi : d'abord les parenthèses, puis multiplication/division, puis addition/soustraction.

Exemples de code avec explications

Passons directement aux exemples. Ouvre la console du navigateur (F12 → onglet Console) ou n'importe quel éditeur en ligne et essaie de taper le code. Tous les exemples peuvent être copiés et exécutés.

Exemple 1 : Addition et soustraction — comme au magasin

// Tu avais 150 roubles. Tu as acheté un pâté à 45 roubles.
// Combien d'argent reste-t-il ?
let bylo = 150;
let potratil = 45;
let ostalos = bylo - potratil;
console.log("Reste des roubles :", ostalos); // Affiche : Reste des roubles : 105

// Et maintenant, imagine que maman a donné 50 roubles de plus pour une glace.
let dobavka = 50;
let vsego = ostalos + dobavka;
console.log("Maintenant, total d'argent :", vsego); // Affiche : Maintenant, total d'argent : 155

// D'ailleurs, on peut écrire directement les nombres, sans variables :
console.log(100 + 200); // 300
console.log(500 - 250); // 250

Explication : Les variables sont comme des boîtes avec des étiquettes. Dans la boîte bylo, on a mis le nombre 150. Quand on écrit bylo - potratil, l'ordinateur sort les nombres des boîtes et les soustrait. Le résultat est mis dans une nouvelle boîte ostalos. console.log est la commande « affiche le résultat dans la console ».

En Python, la même chose ressemblerait presque pareil, sauf que let n'est pas nécessaire (en Python, on écrit simplement bylo = 150). JavaScript nécessite let (ou const, ou var) pour déclarer une variable.

Exemple 2 : Multiplication — calcul du coût d'un achat

// Tu achètes 4 cahiers à 25 roubles chacun.
// Combien dois-tu payer ?
let cenaTetradi = 25;
let kolichestvo = 4;
let stoimost = cenaTetradi * kolichestvo;
console.log("Coût des cahiers :", stoimost); // 100

// Et si tu dois acheter 3 paquets de biscuits à 89 roubles et 2 jus à 55 roubles ?
let pechenie = 89 * 3; // 267
let sok = 55 * 2;      // 110
let itog = pechenie + sok;
console.log("Total à payer :", itog); // 377

// On peut calculer directement dans console.log :
console.log("Vérification :", 89 * 3 + 55 * 2); // Donne aussi 377

// La multiplication en programmation, c'est l'astérisque *.
// En maths, on écrit ×, mais il n'y en a pas sur le clavier, donc on utilise *.
console.log(10 * 10); // 100
console.log(7 * 8);   // 56

Explication : Remarque : nous n'avons pas écrit (89 * 3) + (55 * 2), même si c'est aussi possible. L'ordinateur sait que la multiplication s'effectue avant l'addition. Mais si tu veux être sûr, mets des parenthèses. Elles ne gênent pas et rendent le code plus clair.

Conseil : mets toujours des parenthèses dans les expressions complexes, comme en maths. (a + b) * c n'est pas la même chose que a + b * c.

Exemple 3 : Division — on partage la pizza

// Tu as une pizza de 8 parts. Vous êtes 3 amis (et toi, le quatrième).
// Combien de parts chacun aura-t-il si on partage équitablement ?
let kuskov = 8;
let druzei = 4; // toi + 3 amis
let kazhdomu = kuskov / druzei;
console.log("Chacun a des parts :", kazhdomu); // 2

// Et si la pizza a 10 parts et que vous êtes 4 ?
console.log(10 / 4); // 2.5 — chacun a 2 parts et demie

// La division peut donner des nombres décimaux. En JavaScript, on les appelle "nombres à virgule flottante".
console.log(7 / 2); // 3.5
console.log(1 / 3); // 0.3333333333333333 (beaucoup de chiffres après la virgule)

// Important : si on divise 0 par n'importe quel nombre, on obtient 0 :
console.log(0 / 5); // 0

// Et si on divise un nombre par 0 ? On obtient Infinity (infini) :
console.log(10 / 0); // Infinity — c'est une valeur spéciale en JS

Explication : En Python, la division / donne aussi un nombre décimal. Mais en Python, il y a aussi // — la division entière (combien de parts entières). En JavaScript, cet opérateur n'existe pas (mais il existe des moyens d'obtenir un nombre entier — via Math.floor ou Math.trunc, on verra ça plus tard).

Souviens-toi : diviser par zéro en maths est impossible, mais l'ordinateur ne plante pas — il donne Infinity (infini).