Nombres et opérations avec eux

3.1 Type Number

Les nombres en JavaScript jouent un rôle crucial lors du traitement des données et des calculs. Le langage offre de nombreuses possibilités pour travailler avec les nombres, y compris divers types d'opérations et de méthodes intégrées.

En JavaScript, il existe un seul type de données pour les nombres — Number. Ce type de données représente à la fois les entiers et les nombres à virgule flottante. En outre, depuis 2020, le type BigInt a été introduit pour travailler avec des entiers très grands.

Exemples :

    
      let integer = 42;           // Entier
      let float = 3.14;           // Nombre à virgule flottante
      let bigInt = 12345678901234567890n; // Grand entier
    
  

Opérations avec les nombres

Opérations arithmétiques :

Incrément et décrément

Opérations combinées

3.2 Méthodes intégrées

En JavaScript, il y a un objet intégré Math pour effectuer diverses opérations mathématiques.

1. Math.round():

Arrondit un nombre au plus proche entier.

    
      let rounded = Math.round(4.6); // 5
    
  

2. Math.ceil():

Arrondit un nombre à la hausse au plus proche entier.

    
      let ceil = Math.ceil(4.2); // 5
    
  

3. Math.floor():

Arrondit un nombre à la baisse au plus proche entier.

    
      let floor = Math.floor(4.8); // 4
    
  

4.Math.random():

Renvoie un nombre aléatoire entre 0 et 1.

    
      let random = Math.random();
    
  

5. Math.max() et Math.min():

Renvoient la valeur maximale et minimale d'un ensemble de nombres.

    
      let max = Math.max(1, 2, 3, 4); // 4
      let min = Math.min(1, 2, 3, 4); // 1
    
  

6. Math.sqrt():

Renvoie la racine carrée d'un nombre.

    
      let sqrt = Math.sqrt(16); // 4
    
  

7. Math.pow():

Renvoie un nombre élevé à une puissance spécifiée.

    
      let pow = Math.pow(2, 3); // 8
    
  

3.3 Analyse des chaînes en nombres

Fonction parseInt():

Convertit une chaîne en entier.

    
      let int = parseInt('123'); // 123
    
  

Fonction parseFloat():

Convertit une chaîne en nombre à virgule flottante.

    
      let float = parseFloat('3.14'); // 3.14
    
  

Fonction Number():

Convertit une valeur en nombre.

    
      let num = Number('42'); // 42
    
  

Vérification des valeurs

Fonction isNaN():

Vérifie si une valeur est NaN (Not-a-Number).

    
      let isNotNumber = isNaN('hello'); // true
    
  

Fonction isFinite():

Vérifie si une valeur est un nombre fini (si c'est l'infini ou pas).

    
      let finite = isFinite(10); // true
      let notFinite = isFinite(Infinity); // false
    
  

3.4 Particularités des nombres en JavaScript

1. Limites numériques

En JavaScript, les nombres sont représentés au format à virgule flottante double précision, ce qui a certaines limites :

• Valeur maximale : Number.MAX_VALUE
• Valeur minimale : Number.MIN_VALUE
• Infini positif : Infinity
• Infini négatif : -Infinity
• Pas un nombre (NaN): valeur qui n'est pas un nombre

2. Précision des nombres

Travailler avec des nombres à virgule flottante peut entraîner des problèmes de précision :

    
      let sum = 0.1 + 0.2;
      console.log(sum); // 0.30000000000000004
    
  

C'est partout dans tous les langages de programmation – JavaScript n'est pas une exception.

3.Nombres entiers sécurisés

En JavaScript, il y a une notion de nombres entiers "sécurisés", qui peuvent être représentés exactement en tant que nombres à virgule flottante :

• Entier sécurisé maximal : Number.MAX_SAFE_INTEGER (253 - 1)
• Entier sécurisé minimal : Number.MIN_SAFE_INTEGER (-(253 - 1))