JavaScript
Constantes intégrées

Opérations qui renvoient NaN

Les opérations mathématiques sur des valeurs autres que les nombres renvoient NaN.

"a" + 1
"b" * 3
"cde" - "e"
[1, 2, 3] * 2

Une exception: les tableaux à un seul numéro.

[2] * [3]  // Returns 6

Rappelez-vous également que l'opérateur + concatène les chaînes.

"a" + "b"  // Returns "ab"

Diviser zéro par zéro renvoie NaN .

0 / 0         // NaN

Note: En mathématiques en général (contrairement à la programmation JavaScript), la division par zéro n'est pas possible.

Fonctions de bibliothèque mathématique renvoyant NaN

En règle générale, les fonctions Math auxquelles sont attribués des arguments non numériques renverront NaN.

Math.floor("a")

La racine carrée d'un nombre négatif renvoie NaN, car Math.sqrt ne prend pas en charge les nombres imaginaires ou complexes .

Math.sqrt(-1)

Tester NaN avec isNaN ()

window.isNaN()

La fonction globale isNaN() peut être utilisée pour vérifier si une valeur ou une expression isNaN() valeur NaN . Cette fonction (en bref) vérifie d’abord si la valeur est un nombre, si ce n’est pas le convertit (*), puis vérifie si la valeur résultante est NaN . Pour cette raison, cette méthode de test peut entraîner une confusion .

^{(*) La méthode de "conversion" n'est pas simple, voir ECMA-262 18.2.3 pour une explication détaillée de l'algorithme.}

Ces exemples vous aideront à mieux comprendre le comportement isNaN() :

isNaN(NaN);          // true
isNaN(1);            // false: 1 is a number
isNaN(-2e-4);        // false: -2e-4 is a number (-0.0002) in scientific notation
isNaN(Infinity);     // false: Infinity is a number
isNaN(true);         // false: converted to 1, which is a number
isNaN(false);        // false: converted to 0, which is a number
isNaN(null);         // false: converted to 0, which is a number
isNaN("");           // false: converted to 0, which is a number
isNaN(" ");          // false: converted to 0, which is a number
isNaN("45.3");       // false: string representing a number, converted to 45.3
isNaN("1.2e3");      // false: string representing a number, converted to 1.2e3
isNaN("Infinity");   // false: string representing a number, converted to Infinity
isNaN(new Date);     // false: Date object, converted to milliseconds since epoch
isNaN("10$");        // true : conversion fails, the dollar sign is not a digit
isNaN("hello");      // true : conversion fails, no digits at all
isNaN(undefined);    // true : converted to NaN
isNaN();             // true : converted to NaN (implicitly undefined)
isNaN(function(){}); // true : conversion fails
isNaN({});           // true : conversion fails
isNaN([1, 2]);       // true : converted to "1, 2", which can't be converted to a number

Ce dernier est un peu délicat: vérifier si un Array est NaN . Pour ce faire, le constructeur Number() convertit d'abord le tableau en chaîne, puis en nombre; c'est la raison pour laquelle isNaN([]) et isNaN([34]) renvoient toutes les deux false , mais isNaN([1, 2]) et isNaN([true]) renvoient toutes les deux true : parce qu'ils sont convertis en "" , "34" , "1,2" et "true" respectivement. En général, un tableau est considéré comme NaN par isNaN() sauf s'il ne contient qu'un élément dont la représentation sous forme de chaîne peut être convertie en un nombre valide .

// The one and only 
Number.isNaN(NaN);          // true

// Numbers
Number.isNaN(1);            // false
Number.isNaN(-2e-4);        // false
Number.isNaN(Infinity);     // false

// Values not of type number
Number.isNaN(true);         // false
Number.isNaN(false);        // false
Number.isNaN(null);         // false
Number.isNaN("");           // false
Number.isNaN(" ");          // false
Number.isNaN("45.3");       // false
Number.isNaN("1.2e3");      // false
Number.isNaN("Infinity");   // false
Number.isNaN(new Date);     // false
Number.isNaN("10$");        // false
Number.isNaN("hello");      // false
Number.isNaN(undefined);    // false
Number.isNaN();             // false
Number.isNaN(function(){}); // false
Number.isNaN({});           // false
Number.isNaN([]);           // false
Number.isNaN([1]);          // false
Number.isNaN([1, 2]);       // false
Number.isNaN([true]);       // false

nul

null est utilisé pour représenter l'absence intentionnelle d'une valeur d'objet et est une valeur primitive. Contrairement à undefined , ce n'est pas une propriété de l'objet global.

Il est égal à undefined mais non identique à celui-ci.

null == undefined; // true
null === undefined; // false

ATTENTION : Le typeof null est 'object' .

typeof null; // 'object';

Pour vérifier correctement si une valeur est null , comparez-la avec l' opérateur d'égalité stricte

var a = null;

a === null; // true

indéfini et nul

À première vue, il peut sembler que null et undefined sont fondamentalement les mêmes, mais il existe des différences subtiles mais importantes.

undefined est l'absence d'une valeur dans le compilateur, car là où il devrait être une valeur, il n'y en a pas eu, comme dans le cas d'une variable non affectée.

• undefined est une valeur globale représentant l'absence d'une valeur affectée.
  • typeof undefined === 'undefined'
• null est un objet qui indique qu'une variable a été explicitement assignée "no value".
  • typeof null === 'object'

Définir une variable à undefined signifie que la variable n'existe pas. Certains processus, tels que la sérialisation JSON, peuvent dépouiller les propriétés undefined des objets. En revanche, null propriétés null indiquent qu'elles seront conservées, de sorte que vous pouvez explicitement transmettre le concept d'une propriété "vide".

L'évaluation suivante à undefined :

• Une variable lorsqu'elle est déclarée mais sans valeur (c.-à-d. Définie)

  • let foo;
    console.log('is undefined?', foo === undefined);
    // is undefined? true
    

• Accéder à la valeur d'une propriété qui n'existe pas

  • let foo = { a: 'a' };
    console.log('is undefined?', foo.b === undefined);
    // is undefined? true
    

• La valeur de retour d'une fonction qui ne renvoie pas de valeur

  • function foo() { return; }
    console.log('is undefined?', foo() === undefined);
    // is undefined? true
    

• La valeur d'un argument de fonction déclaré mais omis de l'appel de fonction

  • function foo(param) { 
      console.log('is undefined?', param === undefined);
    }
    foo('a');
    foo();
    // is undefined? false
    // is undefined? true
    

undefined est également une propriété de l'objet window global.

// Only in browsers
console.log(window.undefined); // undefined
window.hasOwnProperty('undefined'); // true    

L'infini et l'infini

1 / 0; // Infinity
// Wait! WHAAAT?

Infinity est une propriété de l'objet global (donc une variable globale) qui représente l'infini mathématique. C'est une référence à Number.POSITIVE_INFINITY

Il est supérieur à toute autre valeur, et vous pouvez l'obtenir en divisant par 0 ou en évaluant l'expression d'un nombre si important qu'il déborde. Cela signifie en fait qu'il n'y a pas de division par 0 erreur dans JavaScript, il y a Infinity!

Il y a aussi -Infinity qui est l'infini mathématique négatif, et il est inférieur à toute autre valeur.

Pour obtenir -Infinity vous -Infinity Infinity ou obtenez une référence dans Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Maintenant, amusez-vous avec des exemples:

Infinity > 123192310293; // true
-Infinity < -123192310293; // true
1 / 0; // Infinity
Math.pow(123123123, 9123192391023); // Infinity
Number.MAX_VALUE * 2; // Infinity
23 / Infinity; // 0
-Infinity; // -Infinity
-Infinity === Number.NEGATIVE_INFINITY; // true
-0; // -0 , yes there is a negative 0 in the language
0 === -0; // true
1 / -0; // -Infinity
1 / 0 === 1 / -0; // false
Infinity + Infinity; // Infinity

var a = 0, b = -0;

a === b; // true
1 / a === 1 / b; // false

// Try your own!

NaN

NaN signifie "Pas un numéro". Lorsqu'une fonction ou une opération mathématique en JavaScript ne peut pas renvoyer un nombre spécifique, elle renvoie la valeur NaN place.

C'est une propriété de l'objet global et une référence à Number.NaN

window.hasOwnProperty('NaN'); // true
NaN; // NaN

Peut-être confus, NaN est toujours considéré comme un numéro.

typeof NaN; // 'number'

Ne vérifiez pas NaN à l'aide de l'opérateur d'égalité. Voir plutôt isNaN

NaN == NaN  // false
NaN === NaN // false

Nombre de constantes

Le constructeur Number contient des constantes intégrées qui peuvent être utiles

Number.MAX_VALUE;          // 1.7976931348623157e+308
Number.MAX_SAFE_INTEGER;   // 9007199254740991

Number.MIN_VALUE;          // 5e-324
Number.MIN_SAFE_INTEGER;   // -9007199254740991

Number.EPSILON;            // 0.0000000000000002220446049250313

Number.POSITIVE_INFINITY;  // Infinity
Number.NEGATIVE_INFINITY;  // -Infinity

Number.NaN;                // NaN

Dans de nombreux cas, les différents opérateurs en Javascript rompent avec les valeurs en dehors de la plage de ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Notez que Number.EPSILON représente la différence entre un et le plus petit Number supérieur à un, et donc la plus petite différence possible entre deux valeurs Number différentes. Une des raisons d'utiliser ceci est due à la nature de la manière dont les nombres sont stockés par JavaScript. Voir Vérifier l'égalité de deux nombres.