Comportement étrange de l'analyse de parseInt() en JavaScript

Cet article vous présentera le comportement étrange de l'analyse de parseInt() en JavaScript. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

[Apprentissage recommandé : Tutoriel avancé javascript]

parseInt() est une fonction JS intégrée pour analyser des chaînes numériques entières dans . Par exemple, l'analyse de la chaîne numérique '100' :

const number = parseInt('100');
number; // 100

Comme prévu, '100' est analysée comme un entier 100.

parseInt(numericalString, radix) accepte également un deuxième paramètre : de 2 à 36, représentant la base de la chaîne. Par exemple, spécifier 16 signifie que la valeur analysée est un nombre hexadécimal. Veuillez noter que 10 n'est pas la valeur par défaut, les plus courantes sont 2, 8, 10 et 16.

Par exemple, nous utilisons parseInt pour analyser une chaîne numérique en binaire :

const number = parseInt('100', 2);
number; // 4

100 Le nombre binaire correspondant est 4, donc 4 est renvoyé.

1. Comportement étrange de parseInt()

parseInt(numericalString)Convertissez toujours son premier argument en chaîne (si ce n'est pas une chaîne), puis convertissez ce numérique les chaînes sont analysées en valeurs entières.

C'est pourquoi vous pouvez ( mais ne devriez pas) utiliser parseInt() pour extraire la partie entière d'un nombre à virgule flottante :

parseInt(0.5);      // => 0
parseInt(0.05);     // => 0
parseInt(0.005);    // => 0
parseInt(0.0005);   // => 0
parseInt(0.00005);  // => 0
parseInt(0.000005); // => 0

Extraire la partie entière de un nombre à virgule flottante, comme 0.5, 0.05, etc., le résultat est 0, ce qui est comme prévu.

Que diriez-vous d'extraire la partie entière de 0.0000005 ?

parseInt(0.0000005); // => 5

parseInt() Analyse un nombre à virgule flottante 0.0000005 en 5. Pourquoi parseInt(0.0000005) se comporte-t-il ainsi ?

2. Résolvez le parseInt() comportement étrange

Regardons à nouveau le premier paramètre de parseInt(numericalString) : si ce n'est pas une chaîne, convertissez-la en une chaîne, puis analysée, et l'entier analysé est renvoyé.

Cela pourrait être le premier indice.

Ensuite, nous essayons de convertir manuellement le flottant en une représentation sous forme de chaîne :

String(0.5);      // => '0.5'
String(0.05);     // => '0.05'
String(0.005);    // => '0.005'
String(0.0005);   // => '0.0005' 
String(0.00005);  // => '0.00005'
String(0.000005); // => '0.000005'

String(0.0000005); // => '5e-7'

La conversion explicite en string(0.0000005) chaîne se comporte différemment des autres flottants : sa représentation est Utiliser une forme exponentielle.

C'est le deuxième indice important !

Lorsque la notation de l'exposant est analysée comme un entier, nous obtenons le nombre 5

parseInt(0.0000005); // => 5
// same as
parseInt(5e-7);      // => 5
// same as
parseInt('5e-7');    // => 5

parseInt('5e-7')Considérez le premier nombre '5', mais sautez le 'e-7'.

Le mystère est résolu ! Étant donné que parseInt() convertit toujours son premier argument en chaîne, les nombres à virgule flottante inférieurs à 10负6次方 seront exprimés sous forme d'exposant. Ensuite parseInt() extrait l'entier de la notation exponentielle de float .

De plus, afin d'extraire en toute sécurité la partie entière du nombre à virgule flottante, il est recommandé d'utiliser la fonction Math.floor() :

Math.floor(0.5);      // => 0
Math.floor(0.05);     // => 0
Math.floor(0.005);    // => 0
Math.floor(0.0005);   // => 0
Math.floor(0.00005);  // => 0
Math.floor(0.000005); // => 0

Math.floor(0.0000005); // => 0

Résumé3.

parseInt() est une fonction qui analyse une chaîne numérique en un entier.

Des précautions doivent être prises lorsque vous essayez d'utiliser parseInt() pour extraire la partie entière d'un nombre à virgule flottante.

Les nombres à virgule flottante inférieurs à 10 élevés à la puissance -6 (par exemple, 0,0000005, soit 5*10-7) sont écrits en notation exponentielle lorsqu'ils sont convertis en chaînes (par exemple, 5e-7 est la notation exponentielle de 0,0000005) . C'est pourquoi l'utilisation d'un si petit nombre à virgule flottante dans parseInt() conduit à des résultats inattendus : seule la partie importante de la notation de l'exposant (comme le 5e-7 dans 5 ) est analysée.

Alors maintenant tout le monde peut essayer d'expliquer pourquoi parseInt(999999999999999999999) est égal à 1 ?

Adresse originale en anglais : https://dmitripavlutin.com/parseint-mystery-javascript/

Auteur : Dmitri Pavlutin

Plus de programmation liée Pour connaissances, veuillez visiter : Vidéos de programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!