20 août 2021

Nombres

En JavaScript moderne, il existe deux types de nombres :

  1. Les nombres normaux en JavaScript sont stockés au format 64 bits IEEE-754, également connu sous le nom de “nombres à virgule flottante double précision”. Ce sont des chiffres que nous utilisons le plus souvent, et nous en parlerons dans ce chapitre.

  2. Les nombres BigInt pour représenter des entiers de longueur arbitraire. Ils sont parfois nécessaires, car un nombre régulier ne peut pas dépasser de manière précise 253 ou être inférieur à -253. Comme les bigints sont utilisés dans quelques zones spéciales, nous leur consacrons un chapitre spécial BigInt.

Donc, ici, nous allons parler de chiffres réguliers. Augmentons nos connaissances à leur sujet.

Plus de façons d’écrire un nombre

Imaginez que nous ayons besoin d’écrire 1 milliard. Le moyen évident est:

let milliard = 1000000000;

Nous pouvons également utiliser l’underscore _ comme séparateur :

let billion = 1_000_000_000;

Ici l’underscore _ joue le rôle de “sucre syntaxique”, il rend le nombre plus lisible. Le moteur JavaScript ignore simplement _ entre les chiffres, donc c’est exactement le même milliard que ci-dessus.

Dans la vraie vie cependant, nous essayons d’éviter d’écrire de longues séquences de zéros. Nous sommes trop paresseux pour ça. Nous essaierons d’écrire quelque chose comme “1 milliard” pour un milliard ou “7,3 milliards” pour 7 milliards 300 millions. La même chose est vraie pour la plupart des grands nombres.

En JavaScript, nous pouvons raccourcir un nombre en y ajoutant la lettre "e" et en spécifiant le nombre de zéros :

let milliards = 1e9;  // 1 milliard, littéralement: 1 et 9 zéros

alert( 7.3e9 );  // 7.3 milliards (pareil que 7,300,000,000 ou 7_300_000_000)

En d’autres termes, e multiplie le nombre de 1 avec le nombre de zéros donné.

1e3 === 1 * 1000 // e3 signifie *1000
1.23e6 === 1.23 * 1000000 // e6 signifie *1000000

Maintenant, écrivons quelque chose de très petit. Disons, 1 microseconde (un millionième de seconde):

let ms = 0.000001;

Comme avant, l’utilisation de "e" peut nous aider. Si nous voulons éviter d’écrire les zéros explicitement, nous pourrions dire la même chose avec :

let ms = 1e-6; // six zéros à gauche de 1

Si nous comptons les zéros dans 0.000001, il y en a 6. Donc logiquement, c’est 1e-6.

En d’autres termes, un nombre négatif après "e" signifie une division par 1 avec le nombre donné de zéros:

// -3 divise par 1 avec 3 zéros
1e-3 === 1 / 1000; // 0.001

// -6 divise par 1 avec 6 zéros
1.23e-6 === 1.23 / 1000000; // 0.00000123

Nombres hexadécimaux, binaires et octaux

Les nombres Hexadécimaux sont souvent utilisés en JavaScript pour représenter des couleurs, encoder des caractères et pour beaucoup d’autres choses. Alors, naturellement, il existe un moyen plus court de les écrire: 0x puis le nombre.

Par exemple:

alert( 0xff ); // 255
alert( 0xFF ); // 255 (même résultat car la casse n'a pas d'importance)

Les systèmes numériques binaires et octaux sont rarement utilisés, mais sont également supportés avec les préfixes 0b et 0o:

let a = 0b11111111; // forme binaire de 255
let b = 0o377; // forme octale de 255

alert( a == b ); // true, car a et b valent le même nombre 255

Cependant ça ne fonctionne qu’avec ces 3 systèmes de numération. Pour les autres systèmes numérique, nous devrions utiliser la fonction parseInt (que nous verrons plus loin dans ce chapitre)

La méthode toString(base)

La méthode num.toString(base) retourne une chaîne de caractères représentant num dans le système numérique de la base donnée.

Par exemple:

let num = 255;

alert( num.toString(16) );  // ff
alert( num.toString(2) );   // 11111111

La base peut varier de 2 à 36. Par défaut, il s’agit de 10.

Les cas d’utilisation courants sont:

  • base=16 est utilisé pour les couleurs hexadécimales, les encodages de caractères, etc. les chiffres peuvent être 0..9 ou A..F.

  • base=2 est principalement utilisé pour le débogage d’opérations binaires, les chiffres pouvant être 0 ou 1.

  • base=36 est le maximum, les chiffres peuvent être 0..9 ou A..Z. L’alphabet latin entier est utilisé pour représenter un nombre. Un cas amusant mais utile pour la base 36 consiste à transformer un identifiant numérique long en quelque chose de plus court, par exemple pour créer une URL courte. On peut simplement le représenter dans le système numérique avec base 36:

    alert( 123456..toString(36) ); // 2n9c
Deux points pour appeler une méthode

Veuillez noter que deux points sur 123456..toString(36) n’est pas une faute de frappe. Si nous voulons appeler une méthode directement sur un nombre, comme toString dans l’exemple ci-dessus, nous devons placer deux points .. avant la méthode.

Si nous plaçions un seul point: 123456.toString(36), il y aurait une erreur, car la syntaxe JavaScript applique la partie décimale après le premier point et il lirait toString(36) comme étant la partie décimale de 123456 ce qui n’est pas le cas. Si nous plaçons un point de plus, alors JavaScript sait que la partie décimale est vide et peut maintenant appliquer la méthode.

Il est aussi possible d’écrire (123456).toString(36).

Arrondir

Arrondir est l’une des opérations les plus utilisées pour travailler avec des nombres.

Il existe plusieurs fonctions intégrées pour arrondir:

Math.floor
Arrondis: 3.1 devient 3, et -1.1 devient -2.
Math.ceil
Arrondis: 3.1 devient 4, et -1.1 devient -1.
Math.round
Arrondit à l’entier le plus proche: 3,1 devient 3, 3,6 devient 4, le cas du milieu : 3,5 arrondit également à 4.
Math.trunc (non pris en charge par Internet Explorer)
Supprime tout ce qui suit le point décimal sans avoir arrondi: 3.1 devient 3, -1.1 devient -1.

Voici le tableau pour résumer les différences entre eux:

Math.floor Math.ceil Math.round Math.trunc
3.1 3 4 3 3
3.6 3 4 4 3
-1.1 -2 -1 -1 -1
-1.6 -2 -1 -2 -1

Ces fonctions couvrent toutes les manières possibles de traiter la partie décimale d’un nombre. Mais que se passe-t-il si nous voulons arrondir le nombre à un certain chiffre après la virgule ?

Par exemple, nous avons 1.2345 et voulons l’arrondir à 2 chiffres, pour obtenir seulement 1.23.

Il y a deux façons de le faire:

  1. Multiplier et diviser.

    Par exemple, pour arrondir le nombre au deuxième chiffre après la décimale, nous pouvons multiplier le nombre par 100 (ou une plus grande puissance de 10), appeler la fonction d’arrondi puis la diviser.

    let num = 1.23456;
    
    alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
  2. La méthode toFixed(n) arrondit le nombre à n chiffres après le point et renvoie unechaîne de caractères du résultat.

    let num = 12.34;
    alert( num.toFixed(1) ); // "12.3"

    Ceci arrondit à la valeur la plus proche, similaire à Math.round:

    let num = 12.36;
    alert( num.toFixed(1) ); // "12.4"

    Veuillez noter que le résultat de toFixed est une chaîne de caractères. Si la partie décimale est plus courte qu’indiquée, des zéros sont ajoutés à la fin:

    let num = 12.34;
    alert( num.toFixed(5) ); // "12.34000", ajout de zéros pour faire exactement 5 chiffres

    Nous pouvons le convertir en un nombre en utilisant le plus unaire + ou un appel Number(): +num.toFixed(5).

Calculs imprécis

En interne, un nombre est représenté au format 64 bits IEEE-754, il y a donc exactement 64 bits pour stocker un nombre : 52 d’entre eux sont utilisés pour stocker les chiffres, 11 d’entre eux stockent la position du point décimal(ils sont zéro pour les nombres entiers), et 1 bit est pour le signe.

Si un nombre est trop grand, le stockage 64 bits serait saturé, donnant potentiellement une infinité:

alert( 1e500 ); // infini

Ce qui est peut-être un peu moins évident, mais qui arrive souvent, est la perte de précision.

Voyons ce test (faux!)

alert( 0.1 + 0.2 == 0.3 ); // faux

Si on vérifie si la somme de 0.1 et 0.2 est égale à 0.3 on obtient faux.

Étrange! Qu’est-ce que c’est alors si ce n’est pas 0.3?

alert( 0.1 + 0.2 ); // 0.30000000000000004

Aie! Il y a plus de conséquences qu’une comparaison incorrecte ici. Imaginez que vous créez un site d’ecommerce et que le visiteur ajoute 0.10$ et 0.20$ de marchandises dans son panier. Le montant total de la commande sera de 0.30000000000000004. Cela surprendrait n’importe qui.

Mais pourquoi cela se produit-il ?

Un nombre est stocké en mémoire sous sa forme binaire, une séquence de uns et de zéros. Mais les fractions telles que 0.1, 0.2, qui semblent simples dans le système numérique décimal, sont en réalité des fractions sans fin dans leur forme binaire.

En d’autres termes, qu’est-ce que 0.1 ? C’est un divisé par dix 1/10, un dixième. Dans le système numérique décimal, ces nombres sont facilement représentables. Comparez-le à un tiers: 1/3. Cela devient une fraction sans fin 0.33333(3).

Ainsi, la division par puissances 10 est garantie de bien fonctionner dans le système décimal, mais la division par 3 ne l’est pas. Pour la même raison, dans le système de numération binaire, la division par des puissances de 2 est garantie, mais 1/10 devient une fraction binaire sans fin.

Il n’existe aucun moyen de stocker exactement 0.1 ou exactement 0.2 à l’aide du système binaire, tout comme il n’existe aucun moyen de stocker un tiers sous forme de fraction décimale.

Le format numérique IEEE-754 résout ce problème en arrondissant au nombre le plus proche possible. Ces règles d’arrondissement ne nous permettent normalement pas de voir cette “petite perte de précision”, mais elle existe.

Nous pouvons voir cela en action:

alert( 0.1.toFixed(20) ); // 0.10000000000000000555

Et quand on additionne deux nombres, leurs “pertes de précision” s’additionnent.

C’est pourquoi 0.1 + 0.2 n’est pas exactement 0.3.

Pas seulement JavaScript

Le même problème existe dans de nombreux autres langages de programmation.

PHP, Java, C, Perl, Ruby donnent exactement le même résultat, car ils sont basés sur le même format numérique.

Pouvons-nous contourner le problème? Bien sûr, il y a plusieurs façons:

  1. Nous pouvons arrondir le résultat à l’aide d’une méthode toFixed(n):

    let sum = 0.1 + 0.2;
    alert( sum.toFixed(2) ); // 0.30

    Veuillez noter que toFixed renvoie toujours une chaîne de caractères. Il s’assure qu’il a 2 chiffres après le point décimal. C’est pratique si nous avons un magasin en ligne et devons montrer 0.30$. Pour les autres cas, nous pouvons utiliser le plus unaire + pour le contraindre en un nombre:

    let sum = 0.1 + 0.2;
    alert( +sum.toFixed(2) ); // 0.3
  2. Nous pouvons temporairement transformer des nombres en nombres entiers en les multipliant pour effectuer des calculs, puis les diviser pour avoir les valeurs voulues. Cela fonctionne comme ceci:

    alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3

    Cela fonctionne parce que lorsque nous faisons 0.1 * 10 = 1 et 0.2 * 10 = 2, les deux nombres deviennent des nombres entiers et il n’y a pas de perte de précision.

  3. Si nous avions affaire à un magasin, la solution la plus radicale consisterait à stocker tous les prix en centimes et à ne pas utiliser de fractions du tout. Mais que se passe-t-il si nous appliquons une réduction de 30%? En pratique, il est rarement réalisable d’éviter totalement les fractions. Les solutions ci-dessous permettent d’éviter ce piège.

La chose amusante

Essayez de lancer ceci:

// Bonjour! Je suis un nombre auto-croissant!
alert( 9999999999999999 ); // affiche 10000000000000000

La cause est encore une fois le manque de précision. Le nombre comporte 64 bits, dont 52 peuvent être utilisés pour stocker des chiffres, mais cela ne suffit pas. Alors, les cihffres les moins significatifs disparaissent.

JavaScript ne déclenche pas d’erreur dans de tels événements. il fait de son mieux pour adapter le nombre au format souhaité, mais malheureusement, ce format n’est pas assez grand.

Deux zéros

Une autre conséquence amusante de la représentation interne des nombres est l’existence de deux zéros: 0 et‑0.

C’est parce qu’un signe est représenté par un seul bit, il peut donc être défini ou non pour n’importe quel nombre, y compris un zéro.

Dans le plupart des cas, la distinction est imperceptible, car les opérateurs peuvent les traiter de la même manière.

Tests: isFinite et isNaN

Vous rappelez-vous de ces deux valeurs numériques spéciales?

  • Infinite (et -Infinite) sont des valeurs numériques spéciales qui sont supérieures (inférieure) à tout.
  • NaN représente une erreur.

Ils appartiennent au type number, mais ne sont pas des numéros “normaux”. Il existe donc des fonctions spéciales pour les vérifier:

  • isNaN(valeur) convertit son argument en un nombre puis le teste pour qu’il soit NaN:

    alert( isNaN(NaN) ); // true
    alert( isNaN("str") ); // true

    Mais avons-nous besoin de cette fonction? Ne pouvons-nous pas simplement utiliser la comparaison === NaN? Désolé, mais la réponse est non. La valeur NaN est unique en ce sens qu’elle ne vaut rien, y compris elle-même:

    alert( NaN === NaN ); // false
  • isFinite(valeur) convertit son argument en un nombre et renvoie true s’il s’agit d’un nombre régulier, pas de NaN / Infinity / -Infinity:

    alert( isFinite("15") ); // true
    alert( isFinite("str") ); // false, car c'est une valeur non régulière: NaN
    alert( isFinite(Infinity) ); // false, car c'est aussi une valeur non régulière: Infinity

Parfois, isFinite est utilisé pour valider si une valeur de chaîne de caractères est un nombre régulier:

let num = +prompt("Entrez un nombre", '');

// sera vrai, sauf si vous entrez Infinity, -Infinity ou NaN
alert( isFinite(num) );

Veuillez noter qu’une chaîne de caractères vide ou une chaîne de caractères contenant seulement un espace est traitée comme 0 dans toutes les fonctions numérique, y compris isFinite.

Comparer avec Object.is

Il existe une méthode intégrée spéciale Object.is qui compare des valeurs telles que ===, mais qui est plus fiable pour deux cas extrêmes :

  1. Cela fonctionne avec Nan: Object.is(NaN, NaN) === true, c’est une bonne chose.
  2. Les valeurs 0 et -0 sont différentes: Object.is(0, -0) === false, techniquement c’est vrai, car le numéro a en interne un bit de signe qui peut être différent même si tous les autres bits sont à zéro.

Dans tous les autres cas, Object.is(a, b) est identique à a === b.

Ce mode de comparaison est souvent utilisé dans la spécification JavaScript. Lorsqu’un algorithme interne doit comparer deux valeurs pour être exactement identiques, il utilise Object.is(appelé en interne SameValue).

parseInt et parseFloat

La conversion numérique à l’aide d’un plus + ou Number() est strict. Si une valeur n’est pas exactement un nombre, elle échoue:

alert( +"100px" ); // NaN

La seule exception concerne les espaces au début ou à la fin de la chaîne de caractères, car ils sont ignorés.

Mais dans la vraie vie, nous avons souvent des valeurs en unités, comme "100px" ou "12pt" en CSS. En outre, dans de nombreux pays, le symbole monétaire se situe après le montant. Nous avons donc "19€" et souhaitons en extraire une valeur numérique.

C’est à quoi servent parseInt et parseFloat.

Ils “lisent” un nombre d’une chaîne jusqu’à ce qu’ils ne puissent plus. En cas d’erreur, le numéro rassemblé est renvoyé. La fonction parseInt renvoie un entier, tandis que parseFloat renvoie un nombre à virgule:

alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5

alert( parseInt('12.3') ); // 12, seule la partie entière est renvoyée
alert( parseFloat('12.3.4') ); // 12.3, le deuxième point arrête la lecture

Il y a des situations où parseInt / parseFloat retournera NaN. Cela arrive quand on ne peut lire aucun chiffre:

alert( parseInt('a123') ); // NaN, le premier symbole arrête le processus
Le second argument de parseInt(str, radix)

La fonction parseInt() a un second paramètre optionnel. Il spécifie la base du système numérique, ce qui permet à parseInt d’analyser également les chaînes de nombres hexadécimaux, binaires, etc.:

alert( parseInt('0xff', 16) ); // 255
alert( parseInt('ff', 16) ); // 255, sans 0x cela fonctionne également

alert( parseInt('2n9c', 36) ); // 123456

Autres fonctions mathématiques

JavaScript a un objet Math intégré qui contient une petite bibliothèque de fonctions et de constantes mathématiques.

Quelques exemples:

Math.random()

Retourne un nombre aléatoire de 0 à 1 (1 non compris)

alert( Math.random() ); // 0.1234567894322
alert( Math.random() ); // 0.5435252343232
alert( Math.random() ); // ... (tout nombre aléatoire)
Math.max(a, b, c...) / Math.min(a, b, c...)

Retourne le plus grand / le plus petit des nombres indiqués en argument.

alert( Math.max(3, 5, -10, 0, 1) ); // 5
alert( Math.min(1, 2) ); // 1
Math.pow(n, power)

Renvoie n élevé à la puissance power donnée.

alert( Math.pow(2, 10) ); // 2 puissance 10 = 1024

Il y a plus de fonctions et de constantes dans l’objet Math, y compris la trigonométrie, que vous pouvez trouver dans la documentation de l’objet Math.

Résumé

Pour écrire de nombres avec beaucoup de zéros :

  • Ajoutez "e" avec le nombre de zéros au nombre. Comme: 123e6 est 123 avec 6 zéros soit 123000000.
  • Un nombre négatif après le "e" entraîne la division du nombre par 1 avec des zéros donnés. Comme: 123-e6 est 123 avec 6 zéros après la virgule soit 0.000123 (123 millionièmes).

Pour différents systèmes de numération :

  • Il est possible d’écrire des nombres directement dans les systèmes hex (0x), octal(0o) et binaire (0b).
  • parseInt(str, base) passe la chaîne de caractères str vers un système numérique avec une base donnée : 2 ≤ base ≤ 36.
  • num.toString(base) convertit un nombre en chaîne de caractères dans le système numérique de la base donnée.

Pour convertir des valeurs telles que 12pt et 100px en un nombre :

  • Utiliser parseInt/parseFloat pour la conversion “soft”, qui lit un nombre dans une chaîne de caractères, puis renvoie la valeur qu’ils pouvaient lire avant l’erreur.

Pour les fractions :

  • Arrondissez en utilisant Math.floor, Math.ceil, Math.trunc, Math.round ou num.toFixed(précision).
  • Assurez-vous de ne pas perdre de précision lorsque vous travaillez avec des fractions.

Plus de fonctions mathématiques :

  • Voir l’objet Math quand vous en avez besoin. La bibliothèque est très petite, mais peut couvrir les besoins de base.

Exercices

importance: 5

Créez un script qui invite le visiteur à entrer deux nombres, puis affiche leur somme.

[Lancer la démo]

P.S. Il y a un piège avec les types.

let a = +prompt("Le premier numéro?", "");
let b = +prompt("Le second numéro?", "");

alert( a + b );

Notez le plus unaire + avant le prompt. Il convertit immédiatement la valeur en nombre.

Sinon, a et b seraient des string et leur somme serait leur concaténation, c’est à dire: "1" + "2" = "12".

importance: 4

Selon la documentation, Math.round et toFixed arrondissent tous les deux au nombre le plus proche: 0..4 arrondi par défaut (à la baisse) tantdis que 5..9 arrondi par excès (à la hausse).

Par exemple:

alert( 1.35.toFixed(1) ); // 1.4

Dans l’exemple similaire ci-dessous, pourquoi est-ce que 6.35 est arrondi à 6.3 et non 6.4?

alert( 6.35.toFixed(1) ); // 6.3

Comment arrondir 6.35 de la bonne manière?

En interne, la fraction décimale 6.35 est un fichier binaire sans fin. Comme toujours dans de tels cas, il est stocké avec une perte de précision.

Voyons cela:

alert( 6.35.toFixed(20) ); // 6.34999999999999964473

La perte de précision peut causer à la fois une augmentation et une diminution d’un nombre. Dans ce cas particulier, le nombre diminue un peu, c’est pourquoi il a été arrondi à 3.

Et quand est-il de 1.35?

alert( 1.35.toFixed(20) ); // 1.35000000000000008882

Ici, la perte de précision rend le nombre un peu plus grand, c’est pourquoi il a été arrondi à 4.

Comment pouvons-nous résoudre le problème avec 6.35 si nous voulons qu’il soit arrondi correctement ?

Nous devons le rapprocher d’un nombre entier avant d’arrondir:

alert( (6.35 * 10).toFixed(20) ); // 63.50000000000000000000

Notez que 63.5 n’a aucune perte de précision. C’est parce que la partie décimale 0.5 est en réalité 1/2. Les fractions divisées par les puissances de 2 sont représentées sans perte de précision dans le système binaire, on peut maintenant les arrondir:

alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(arrondi) -> 6.4
importance: 5

Créez une fonction readNumber qui invite à entrer un nombre jusqu’à ce que le visiteur saisisse une valeur numérique valide.

La valeur résultante doit être renvoyée sous forme de nombre.

Le visiteur peut également arrêter le processus en entrant une ligne vide ou en appuyant sur “CANCEL”. Dans ce cas, la fonction doit renvoyer null.

[Lancer la démo]

Open a sandbox with tests.

function readNumber() {
  let num;

  do {
    num = prompt("Entrez un nombre s'il vous plaît", 0);
  } while ( !isFinite(num) );

  if (num === null || num === '') return null;

  return +num;
}

alert(`Read: ${readNumber()}`);

La solution est un peu plus complexe qu’elle n’y paraît car nous devons gérer des lignes null / vides.

Nous répétons donc la demande jusqu’à ce qu’il s’agisse d’un “nombre régulier”. Les lignes null (cancel) et vide répondent également à cette condition car, sous forme numérique, elles valent 0.

Après que nous nous sommes arrêtés, nous devons traiter spécialement les lignes null et vides (retourner null), car les convertit en nombre renverrait 0.

Ouvrez la solution avec des tests dans une sandbox.

importance: 4

Cette boucle est infinie. Ça ne finit jamais. Pourquoi?

let i = 0;
while (i != 10) {
  i += 0.2;
}

C’est parce que je n’aurais jamais égalé 10.

Exécutez-le pour voir les valeurs réelles de i:

let i = 0;
while (i < 11) {
  i += 0.2;
  if (i > 9.8 && i < 10.2) alert( i );
}

Aucun d’entre eux n’est exactement 10.

De telles choses se produisent à cause des pertes de précision lors de l’ajout de fractions comme 0.2.

Conclusion: évitez les contrôles d"égalité lorsque vous travaillez avec des fractions décimales."

importance: 2

La fonction intégrée Math.random() crée une valeur aléatoire de 0 à 1 (1 non compris).

Ecrivez la fonction random(min, max) pour générer un nombre aléatoire compris entre min et max (max non compris).

Quelques exemples:

alert( random(1, 5) ); // 1.2345623452
alert( random(1, 5) ); // 3.7894332423
alert( random(1, 5) ); // 4.3435234525

Nous devons “mapper” toutes les valeurs de l’intervalle 0…1 en valeurs de min à max.

Cela peut être fait en deux étapes:

  1. Si nous multiplions un nombre aléatoire de 0… 1 par max-min, l’intervalle des valeurs possible augmente de 0..1 à 0..max-min.
  2. Maintenant, si nous ajoutons min, l’intervalle possible devient de min à max.

La fonction:

function random(min, max) {
  return min + Math.random() * (max - min);
}

alert( random(1, 5) );
alert( random(1, 5) );
alert( random(1, 5) );
importance: 2

Créez une fonction randomInteger(min, max) qui génère un nombre entier aléatoire compris entre min et max (min et max inclut).

Tout nombre compris dans l’intervalle min..max doit apparaître avec la même probabilité.

Quelques exemples:

alert( randomInteger(1, 5) ); // 1
alert( randomInteger(1, 5) ); // 3
alert( randomInteger(1, 5) ); // 5

Vous pouvez utiliser la solution de la tâche précédente comme base.

La solution simple mais fausse

La solution la plus simple mais fausse serait de générer une valeur de min à max et de l’arrondir:

function randomInteger(min, max) {
  let rand = min + Math.random() * (max - min);
  return Math.round(rand);
}

alert( randomInteger(1, 3) );

La fonction marche, mais elle est incorrecte. La probabilité d’obtenir les valeurs min et max est deux fois inférieure à toute autre.

Si vous exécutez l’exemple ci-dessous plusieurs fois, vous verrez facilement que 2 apparaît le plus souvent.

Cela se produit car Math.round() obtient des nombres aléatoires à partir de l’intervalle 1..3 et les arrondit comme ici:

values from 1    ... to 1.4999999999  devient 1
values from 1.5  ... to 2.4999999999  devient 2
values from 2.5  ... to 2.9999999999  devient 3

Maintenant, nous pouvons clairement voir que 1 obtient deux fois moins de valeurs que 2. Et la même chose avec 3.

La bonne solution

il existe de nombreuses solutions correctes à la tâche. L’une d’elles consiste à ajuster les limites d’intervalle. Pour garantir les mêmes intervalles, nous pouvons générer des valeurs comprises entre 0.5 et 3.5, ajoutant ainsi les probabilités requises:

function randomInteger(min, max) {
  // maintenant rand est entre (min-0.5) et (max+0.5)
  let rand = min - 0.5 + Math.random() * (max - min + 1);
  return Math.round(rand);
}

alert( randomInteger(1, 3) );

Une autre solution pourrait être d’utiliser Math.floor pour un nombre aléatoie compris entre min et max+1.

function randomInteger(min, max) {
  // ici rand est de min à (max+1)
  let rand = min + Math.random() * (max + 1 - min);
  return Math.floor(rand);
}

alert( randomInteger(1, 3) );

Maintenant,tous les intervalles sont mappés de cette façon:

values from 1  ... to 1.9999999999  devient 1
values from 2  ... to 2.9999999999  devient 2
values from 3  ... to 3.9999999999  devient 3

Tous les intervalles ont la même longueur, rendant la distribution finale uniforme.

Carte du tutoriel

Commentaires

lire ceci avant de commenter…
  • Si vous avez des améliorations à suggérer, merci de soumettre une issue GitHub ou une pull request au lieu de commenter.
  • Si vous ne comprenez pas quelque chose dans l'article, merci de préciser.
  • Pour insérer quelques bouts de code, utilisez la balise <code>, pour plusieurs lignes – enveloppez-les avec la balise <pre>, pour plus de 10 lignes - utilisez une sandbox (plnkr, jsbin, codepen…)