Les maths. La langue universelle. Celle qui ne ment pas, sauf quand on la force. JavaScript a son propre quartier général pour les calculs : l'objet Math. Pas besoin de l'instancier. Il est juste là, comme une calculatrice greffée dans le langage.
Pourquoi s'en soucier ? Parce que tout est nombre. Un pourcentage de risque, une probabilité de succès, un angle de tir, une distance de sécurité, une durée aléatoire pour brouiller les pistes.
7.1 Objet Math - L'Arsenal des Chiffres
Constantes : Les Vérités Immobiles
// PI. Le ratio cercle/diamètre. 3.14159...
console.log(Math.PI); // 3.141592653589793
// La base du logarithme naturel (e). ~2.718.
console.log(Math.E); // 2.718281828459045
// Racine carrée de 2. ~1.414.
console.log(Math.SQRT2); // 1.4142135623730951
// Et d'autres...
console.log(Math.SQRT1_2); // √½ ≈ 0.707
console.log(Math.LN2); // ln(2) ≈ 0.693
console.log(Math.LN10); // ln(10) ≈ 2.302
console.log(Math.LOG2E); // log₂(e) ≈ 1.442
console.log(Math.LOG10E); // log₁₀(e) ≈ 0.434
Arrondis et Troncatures : Forcer les Nombres à Obéir
let prix = 19.99;
let taxe = 4.567;
// Math.round() → Arrondi au plus proche
console.log(Math.round(prix)); // 20
console.log(Math.round(taxe)); // 5
console.log(Math.round(4.49)); // 4
console.log(Math.round(-2.5)); // -2 (à retenir)
// Math.floor() → Arrondi vers le BAS (plancher)
console.log(Math.floor(prix)); // 19
console.log(Math.floor(taxe)); // 4
console.log(Math.floor(-2.7)); // -3 (attention aux négatifs)
// Math.ceil() → Arrondi vers le HAUT (plafond)
console.log(Math.ceil(prix)); // 20
console.log(Math.ceil(taxe)); // 5
console.log(Math.ceil(-2.1)); // -2
// Math.trunc() → Tronque la partie décimale (ES6)
console.log(Math.trunc(prix)); // 19
console.log(Math.trunc(taxe)); // 4
console.log(Math.trunc(-2.7)); // -2 (différent de floor !)
// Résumé visuel pour 2.7 et -2.7 :
// Value | floor | ceil | round | trunc
// 2.7 | 2 | 3 | 3 | 2
// -2.7 | -3 | -2 | -3 | -2
Minimum et Maximum : Les Limites
let scores = [88, 92, 75, 99, 64];
// Math.min() → Le plus petit
console.log(Math.min(10, 20, 5)); // 5
console.log(Math.min(...scores)); // 64 (avec spread operator)
console.log(Math.min()); // Infinity (appel sans args)
// Math.max() → Le plus grand
console.log(Math.max(10, 20, 5)); // 20
console.log(Math.max(...scores)); // 99
console.log(Math.max()); // -Infinity
// Pour un tableau, on peut aussi faire :
console.log(Math.min.apply(null, scores)); // 64 (vieille méthode)
Puissances et Racines : L'Essence des Forces
// Math.pow(x, y) → x à la puissance y (ancienne)
console.log(Math.pow(2, 3)); // 8 (2³)
console.log(Math.pow(4, 0.5)); // 2 (racine carrée)
// Opérateur ** (ES7) → Même chose, plus lisible
console.log(2 ** 3); // 8
console.log(4 ** 0.5); // 2
// Math.sqrt() → Racine carrée
console.log(Math.sqrt(16)); // 4
console.log(Math.sqrt(2)); // 1.414...
// Math.cbrt() → Racine cubique (ES6)
console.log(Math.cbrt(27)); // 3
console.log(Math.cbrt(-8)); // -2
// Math.hypot() → Hypoténuse (racine carrée de la somme des carrés)
console.log(Math.hypot(3, 4)); // 5 (3² + 4² = 25, √25 = 5)
console.log(Math.hypot(1, 1, 1)); // √3 ≈ 1.732
Aléatoire : Le Hasard Contrôlé
// Math.random() → Nombre aléatoire entre 0 (inclus) et 1 (exclu)
console.log(Math.random()); // 0.123456... (change à chaque appel)
// Dés à 6 faces (1-6)
let de = Math.floor(Math.random() * 6) + 1;
// Nombre entre min (inclus) et max (exclus)
function aleatoire(min, max) {
return Math.floor(Math.random() * (max - min)) + min;
}
console.log(aleatoire(5, 10)); // 5, 6, 7, 8 ou 9
// Nombre entre min et max (inclus)
function aleatoireInclus(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(aleatoireInclus(5, 10)); // 5 à 10
// Aléatoire avec décimales
function aleatoireDecimal(min, max) {
return Math.random() * (max - min) + min;
}
console.log(aleatoireDecimal(1.5, 3.5)); // Entre 1.5 et 3.5
Trigonométrie : Les Angles de la Manœuvre
// Les angles sont en RADIANS, pas degrés !
// Conversion : radians = degrés * π / 180
let angle45 = 45 * Math.PI / 180; // π/4 rad
// Sinus, Cosinus, Tangente
console.log(Math.sin(0)); // 0
console.log(Math.sin(Math.PI/2)); // 1
console.log(Math.cos(0)); // 1
console.log(Math.cos(Math.PI)); // -1
console.log(Math.tan(Math.PI/4)); // ~1
// Arcsinus, Arccosinus, Arctangente (retournent en radians)
console.log(Math.asin(0)); // 0
console.log(Math.acos(0)); // π/2
console.log(Math.atan(1)); // π/4
// atan2(y, x) → Angle du point (x,y) par rapport à l'origine
// Retourne entre -π et π, utile pour les directions
console.log(Math.atan2(1, 1)); // π/4 (45°)
console.log(Math.atan2(1, -1)); // 3π/4 (135°)
Logarithmes : L'Échelle des Puissances
// Math.log() → Logarithme naturel (base e)
console.log(Math.log(Math.E)); // 1
console.log(Math.log(1)); // 0
console.log(Math.log(10)); // ~2.302
// Math.log10() → Logarithme base 10 (ES6)
console.log(Math.log10(100)); // 2
console.log(Math.log10(1000)); // 3
// Math.log2() → Logarithme base 2 (ES6)
console.log(Math.log2(8)); // 3
console.log(Math.log2(1024)); // 10
// Logarithme dans une base quelconque
function logBase(x, base) {
return Math.log(x) / Math.log(base);
}
console.log(logBase(8, 2)); // 3
Valeur Absolue et Signe
// Math.abs() → Valeur absolue (enlève le signe)
console.log(Math.abs(5)); // 5
console.log(Math.abs(-5)); // 5
console.log(Math.abs(0)); // 0
// Math.sign() → Signe du nombre (ES6)
console.log(Math.sign(5)); // 1
console.log(Math.sign(-5)); // -1
console.log(Math.sign(0)); // 0
console.log(Math.sign(-0)); // -0 (oui, ça existe)
Utilitaires Divers
// Math.exp(x) → e à la puissance x
console.log(Math.exp(0)); // 1
console.log(Math.exp(1)); // ~2.718
// Méthodes 32 bits (pour les bas niveaux)
console.log(Math.clz32(1)); // 31 (compte les zéros à gauche en binaire)
console.log(Math.imul(2, 3)); // 6 (multiplication 32 bits entiers)
// Arrondi à la puissance de 2 la plus proche (ES6)
console.log(Math.fround(1.337)); // Précision simple (32 bits)
// Exposant et mantisse (ES6)
let num = 123.456;
console.log(Math.expm1(num)); // e^x - 1
console.log(Math.log1p(num)); // ln(1 + x)
7.2 Cas Concrets - Applications dans l'Ombre
Calcul de Distance (2D)
function distance(x1, y1, x2, y2) {
return Math.hypot(x2 - x1, y2 - y1);
}
// Distance entre le lieu du crime et l'alibi
console.log(distance(10, 20, 50, 60)); // ~56.57
Génération d'Identifiants Uniques Simplifiée
function genererCode(longueur = 8) {
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
let code = '';
for (let i = 0; i < longueur; i++) {
code += chars[Math.floor(Math.random() * chars.length)];
}
return code;
}
console.log(genererCode()); // "X7B9K2R4"
Conversion Degrés ↔ Radians
function degToRad(deg) {
return deg * Math.PI / 180;
}
function radToDeg(rad) {
return rad * 180 / Math.PI;
}
console.log(degToRad(180)); // π
console.log(radToDeg(Math.PI)); // 180
Vérification de Parité (sans modulo)
function estPair(n) {
return Math.floor(n / 2) === n / 2;
}
console.log(estPair(4)); // true
console.log(estPair(7)); // false
Calcul de Pourcentage avec Arrondi Intelligent
function pourcentage(part, total, decimales = 1) {
const pct = (part / total) * 100;
const facteur = 10 ** decimales;
return Math.round(pct * facteur) / facteur;
}
console.log(pourcentage(3, 9)); // 33.3
console.log(pourcentage(1, 3, 2)); // 33.33
Résumé du Module Math :
- Constantes :
PI,E- Les vérités universelles. - Arrondis :
round,floor,ceil,trunc- Forcer les nombres à se ranger. - Extrêmes :
min,max- Trouver les limites. - Puissances :
pow,sqrt,cbrt- Manipuler l'énergie des nombres. - Aléatoire :
random- Le seul vrai hasard dans cette histoire. - Trigonométrie :
sin,cos,atan2- La géométrie des angles morts. - Logarithmes :
log,log10,log2- Mesurer l'échelle des choses.
Math est une boîte à outils froide, précise, sans état d'âme. Comme une lame. Tu ne la sors que quand tu as besoin d'exactitude. Le reste du temps, les approximations suffisent. Mais quand la précision compte, c'est la seule chose qui ne trahira pas.