Les nombres sont un élément fondamental de tout langage de programmation, et JavaScript ne fait pas exception. Comprendre comment manipuler et exploiter efficacement les nombres est essentiel pour tout développeur. Dans cet article, nous explorerons les différentes fonctions numériques en JavaScript, en fournissant des explications détaillées, des exemples et des commentaires pour vous aider à les maîtriser.

Introduction aux nombres en JavaScript

En JavaScript, les nombres sont stockés sous forme de valeurs à virgule flottante de 64 bits (double précision) conformément à la norme IEEE 754. Cela signifie qu'il existe un seul type de nombre en JavaScript qui peut représenter à la fois des nombres entiers et des nombres à virgule flottante.

let intNumber = 42;
let floatNumber = 3.14;
console.log(intNumber); // Output: 42
console.log(floatNumber); // Output: 3.14

Créer des nombres

Les nombres peuvent être créés à l'aide de littéraux ou du constructeur Number.

let literalNumber = 100;
let constructorNumber = new Number(100);
console.log(literalNumber); // Output: 100
console.log(constructorNumber); // Output: [Number: 100]

Propriétés des nombres

• MAX_VALUE : le plus grand nombre possible.

console.log(Number.MAX_VALUE); // Output: 1.7976931348623157e 308

• MIN_VALUE : le plus petit nombre possible.

console.log(Number.MIN_VALUE); // Output: 5e-324

• NaN : représente une valeur qui n'est pas un nombre.

console.log(Number.NaN); // Output: NaN

• NEGATIVE_INFINITY : représente l'infini négatif.

console.log(Number.NEGATIVE_INFINITY); // Output: -Infinity

• POSITIVE_INFINITY : représente l'infini positif.

console.log(Number.POSITIVE_INFINITY); // Output: Infinity

Méthodes numériques

1. toString()

Convertit un nombre en chaîne.

let num = 123;
console.log(num.toString()); // Output: "123"

2. àFixe()

Formate un nombre en utilisant la notation à virgule fixe.

let num = 123.456;
console.log(num.toFixed(2)); // Output: "123.46"

3. àExponentiel()

Renvoie une chaîne avec un nombre arrondi et écrit en notation exponentielle.

let num = 123456;
console.log(num.toExponential(2)); // Output: "1.23e 5"

4. àPrécision()

Formate un nombre selon une longueur spécifiée.

let num = 123.456;
console.log(num.toPrecision(4)); // Output: "123.5"

5. valeurDe()

Renvoie la valeur primitive d'un objet Number.

let numObj = new Number(123);
console.log(numObj.valueOf()); // Output: 123

Fonctions numériques globales

1. estNaN()

Détermine si une valeur est NaN.

console.log(isNaN(NaN)); // Output: true
console.log(isNaN(123)); // Output: false

2. estFinite()

Détermine si une valeur est un nombre fini.

console.log(isFinite(123)); // Output: true
console.log(isFinite(Infinity)); // Output: false

3. parseInt()

Analyse une chaîne et renvoie un entier.

console.log(parseInt("123")); // Output: 123
console.log(parseInt("123.45")); // Output: 123
console.log(parseInt("abc")); // Output: NaN

4. parseFloat()

Analyse une chaîne et renvoie un nombre à virgule flottante.

console.log(parseFloat("123.45")); // Output: 123.45
console.log(parseFloat("123")); // Output: 123
console.log(parseFloat("abc")); // Output: NaN

5. Nombre()

Convertit une valeur en nombre.

console.log(Number("123")); // Output: 123
console.log(Number("123.45")); // Output: 123.45
console.log(Number("abc")); // Output: NaN

Objet mathématique

L'objet Math de JavaScript fournit une gamme de fonctions et de constantes mathématiques.

1. Math.abs()

Renvoie la valeur absolue d'un nombre.

console.log(Math.abs(-123)); // Output: 123

2. Math.ceil()

Arrondit un nombre à l'entier le plus proche.

console.log(Math.ceil(123.45)); // Output: 124

3. Math.sol()

Arrondit un nombre à l'entier le plus proche.

console.log(Math.floor(123.45)); // Output: 123

4. Math.round()

Arrondit un nombre à l'entier le plus proche.

console.log(Math.round(123.45)); // Output: 123
console.log(Math.round(123.56)); // Output: 124

5. Math.max()

Renvoie le plus grand de zéro ou plusieurs nombres.

console.log(Math.max(1, 2, 3)); // Output: 3

6. Math.min()

Renvoie le plus petit de zéro ou plusieurs nombres.

console.log(Math.min(1, 2, 3)); // Output: 1

7. Math.pow()

Renvoie la base à la puissance de l'exposant.

console.log(Math.pow(2, 3)); // Output: 8

8. Math.sqrt()

Renvoie la racine carrée d'un nombre.

console.log(Math.sqrt(16)); // Output: 4

9. Math.random()

Renvoie un nombre aléatoire compris entre 0 et 1.

console.log(Math.random()); // Output: A random number between 0 and 1

10. Math.trunc()

Renvoie la partie entière d'un nombre en supprimant tous les chiffres fractionnaires.

console.log(Math.trunc(123.45)); // Output: 123

Exemples pratiques

Exemple 1 : Générer un entier aléatoire

function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min   1))   min;
}
console.log(getRandomInt(1, 10)); // Output: A random integer between 1 and 10

Exemple 2 : Calculer la factorielle d'un nombre

function factorial(n) {
    if (n === 0) return 1;
    return n * factorial(n - 1);
}
console.log(factorial(5)); // Output: 120

Exemple 3 : Vérifier si un nombre est premier

function isPrime(num) {
    if (num 




  
  
  Conclusion


La maîtrise des fonctions numériques JavaScript est essentielle pour des opérations mathématiques et une manipulation de données efficaces. Des conversions et analyses de base aux calculs mathématiques plus avancés, JavaScript fournit un ensemble d'outils robustes pour travailler avec les nombres. En comprenant et en utilisant ces fonctions, vous pouvez écrire du code plus propre et plus efficace et résoudre un large éventail de défis de programmation.

Ce guide complet a couvert les fonctions numériques les plus importantes en JavaScript, avec des exemples et des explications. Pratiquez ces fonctions et expérimentez différents cas d'utilisation pour consolider votre compréhension et améliorer vos compétences en codage.