Préparation pour Ecmascript 6: Nouvelles méthodes de numéro

Cet article couvre les méthodes de numéros nouvelles et améliorées dans ES6 (ECMAScript 6).

Cela fait partie d'une série sur les nouvelles fonctionnalités d'ES6, dans lesquelles nous avons également discuté de nouvelles méthodes disponibles pour les types de données de chaîne et de tableau, mais aussi de nouveaux types de données comme MAP et faiblemap.

Je vais vous présenter les nouvelles méthodes et constantes ajoutées au type de données du nombre. Certaines des méthodes de nombre couvertes, comme nous le verrons, ne sont pas du tout nouvelles, mais elles ont été améliorées et / ou déplacées sous le bon objet (par exemple, isnan ()). Comme toujours, nous allons également mettre les nouvelles connaissances acquises en action avec quelques exemples. Donc, sans plus tarder, commençons.

Les plats clés

• ES6 a introduit plusieurs nouvelles méthodes de nombre, dont Number.IsInteger (), Number.isnan (), Number.Fiscinite (), Number.issaFeInteger (), Number.ParseInt () et Number.Parsefloat ().
• Number.IsInteger () vérifie si la valeur passée est un entier, numéro.isnan () teste si une valeur est égale à NAN, et Number.Fiscinite () tests si une valeur transmise est un nombre fini.
• Number.issaFeInteger () teste si la valeur passée est un nombre qui est un entier sûr, défini comme un entier qui peut être exactement représenté comme un numéro de double précision IEEE-754.
• Number.Parseint () et Number.Parsefloat () ne sont pas nouveaux, mais ils ont été déplacés sous l'objet de nombre à des fins de modularisation des globaux. Ils analysent un argument de chaîne et renvoient respectivement un entier et un numéro de point flottant.
• ES6 a également introduit deux valeurs constantes liées: numéro.max_safe_integer et numéro.min_safe_integer qui représentent l'entier maximum et minimum sûr en javascript.

numéro.IsInteger ()

La première méthode que je souhaite couvrir est numéro.IsInteger (). C'est un nouvel ajout à JavaScript, et c'est quelque chose que vous avez peut-être défini et utilisé par vous-même dans le passé. Il détermine si la valeur transmise à la fonction est un entier ou non. Cette méthode renvoie true si la valeur passée est un entier et faux autrement. La mise en œuvre de cette méthode a été assez facile, mais il est toujours bon de l'avoir nativement. L'une des solutions possibles pour recréer cette fonction est:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

juste pour le plaisir, j'ai essayé de recréer cette fonction et je me suis retrouvé avec une approche différente:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && Math.floor(number) === number;
</span><span>};
</span>

Ces deux fonctions sont bonnes et utiles, mais elles ne respectent pas les spécifications ECMAScript 6. Donc, si vous voulez polyfillonner cette méthode, vous avez besoin de quelque chose d'un peu plus complexe, comme nous le verrons sous peu. Pour le moment, commençons par découvrir la syntaxe de Number.IsInteger ():

<span>Number.isInteger(number)
</span>

L'argument de nombre représente la valeur que vous souhaitez tester.

Certains exemples de l'utilisation de cette méthode sont illustrés ci-dessous:

<span>// prints 'true'
</span><span>console.log(Number.isInteger(19));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger(3.5));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger([1, 2, 3]));
</span>

Une démo en direct du code précédent est présentée ci-dessous et est également disponible sur jsbin.

La méthode est prise en charge dans Node et tous les navigateurs modernes, à l'exception d'Internet Explorer. Si vous devez prendre en charge les navigateurs plus âgés, vous pouvez utiliser un polyfill, comme celui disponible sur le réseau de développeurs Mozilla sur la page des méthodes. Ceci est également reproduit ci-dessous pour votre commodité:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

numéro.isnan ()

Si vous avez écrit un code JavaScript dans le passé, cette méthode ne devrait pas être nouvelle pour vous. Depuis un certain temps maintenant, JavaScript a une méthode appelée isnan () qui est exposée via l'objet Window. Cette méthode teste si une valeur est égale à NAN, auquel cas il renvoie vrai, ou autrement faux. Le problème avec Window.isnan () est qu'il a un problème en ce qu'il renvoie également vrai pour les valeurs que converti en nombre sera nan. Pour vous donner une idée concrète de ce problème, toutes les affirmations suivantes renvoient vrai:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && Math.floor(number) === number;
</span><span>};
</span>

Ce dont vous pourriez avoir besoin est une méthode qui ne renvoie pas vrai uniquement si la valeur NAN est passée. C’est pourquoi Ecmascript 6 a introduit la méthode nombre.isnan (). Sa syntaxe est à peu près ce à quoi vous vous attendez:

<span>Number.isInteger(number)
</span>

Ici, la valeur est la valeur que vous souhaitez tester. Quelques exemples d'utilisations de cette méthode sont illustrés ci-dessous:

<span>// prints 'true'
</span><span>console.log(Number.isInteger(19));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger(3.5));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger([1, 2, 3]));
</span>

Comme vous pouvez le voir, testant les mêmes valeurs que nous obtenons des résultats différents.

Une démo en direct de l'extrait précédent est illustrée ci-dessous et est également disponible sur jsbin.

La méthode est prise en charge dans Node et tous les navigateurs modernes, à l'exception d'Internet Explorer. Si vous souhaitez prendre en charge d'autres navigateurs, un polyfill très simple pour cette méthode est le suivant:

<span>if (!Number.isInteger) {
</span>  <span>Number.isInteger = function isInteger (nVal) {
</span>    <span>return typeof nVal === 'number' &&
</span>      <span>isFinite(nVal) &&
</span>      nVal <span>> -9007199254740992 &&
</span>      nVal <span>      <span>Math.floor(nVal) === nVal;
</span>  <span>};
</span><span>}
</span></span>

La raison pour laquelle cela fonctionne est parce que Nan est la seule valeur non réflexive en JavaScript, ce qui signifie que c'est la seule valeur qui n'est pas égale à elle-même.

numéro.fisInite ()

Cette méthode partage la même histoire que la précédente. Dans JavaScript, il existe une méthode appelée Window.Sifinite () qui teste si une valeur passée est un nombre fini ou non. Malheureusement, il renvoie également vrai pour les valeurs que converti en nombre sera un nombre fini. Des exemples de ce numéro sont démontrés ci-dessous:

<span>// prints 'true'
</span><span>console.log(window.isNaN(0/0));
</span>
<span>// prints 'true'
</span><span>console.log(window.isNaN('test'));
</span>
<span>// prints 'true'
</span><span>console.log(window.isNaN(undefined));
</span>
<span>// prints 'true'
</span><span>console.log(window.isNaN({prop: 'value'}));
</span>

Pour cette raison, dans Ecmascript 6, il existe une méthode appelée isFinite () qui appartient au nombre. Sa syntaxe est la suivante:

<span>Number.isNaN(value)
</span>

Ici, la valeur est la valeur que vous souhaitez tester. Si vous testez les mêmes valeurs à partir de l'extrait précédent, vous pouvez voir que les résultats sont différents:

<span>// prints 'true'
</span><span>console.log(Number.isNaN(0/0));
</span>
<span>// prints 'true'
</span><span>console.log(Number.isNaN(NaN));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isNaN(undefined));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isNaN({prop: 'value'}));
</span>

Une démo en direct de l'extrait précédent est illustrée ci-dessous et est également disponible sur jsbin.

La méthode est prise en charge dans Node et tous les navigateurs modernes, à l'exception d'Internet Explorer. Vous pouvez en trouver un polyfill sur la page de la méthode sur MDN.

numéro.issafeInteger ()

La méthode Number.issaFeInteger () est un ajout complètement nouveau à ES6. Il teste si la valeur passée est un nombre qui est un entier sûr, auquel cas il renvoie vrai. Un entier sûr est défini comme un entier qui satisfait les deux conditions suivantes:

• Le nombre peut être exactement représenté comme un numéro de double précision IEEE-754
• La représentation de l'IEEE-754 du nombre ne peut être le résultat de l'arrondi tout autre entier pour s'adapter à la représentation IEEE-754.

Sur la base de cette définition, les entiers sûrs sont tous les entiers de - (2 ⁵³ - 1) inclus à 2 ⁵³ - 1 inclus. Ces valeurs sont importantes et nous en discuterons un peu plus à la fin de cette section.

La syntaxe de cette méthode est:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

Ici, la valeur est la valeur que vous souhaitez tester. Quelques exemples d'utilisations de cette méthode sont illustrés ci-dessous:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && Math.floor(number) === number;
</span><span>};
</span>

Une démo en direct de ce code est présentée ci-dessous et également disponible sur jsbin.

le nombre.issafeInteger () est pris en charge dans le nœud et tous les navigateurs modernes, à l'exception d'Internet Explorer. Un polyfill pour cette méthode, extrait de ES6-SHIM par Paul Miller, est:

<span>Number.isInteger(number)
</span>

Notez que ce polyfill repose sur la méthode Number.IsInteger () discutée auparavant, vous devez donc polyfillonner ce dernier également pour utiliser celui-ci.

ecmascript 6 a également introduit deux valeurs constantes liées: numéro.max_safe_integer et numéro.min_safe_integer. Le premier représente l'entier sûr maximal en JavaScript - c'est-à-dire 2 ⁵³ - 1 - tandis que le second l'entier sûr minimum, qui est - (2 ⁵³ - 1). Comme vous le notez peut-être, ce sont les mêmes valeurs que j'ai citées plus tôt.

nombre.parseint () et numéro.parsefloat ()

les méthodes nombres.parseint () et numéro.parsefloat () sont couvertes dans la même section car, contrairement à d'autres méthodes similaires mentionnées dans cet article, elles existaient déjà dans une version précédente d'Ecmascript, mais ne sont pas différentes de leur ancienne version mondiale. Ainsi, vous pouvez les utiliser de la même manière que vous avez fait jusqu'à présent et vous pouvez vous attendre aux mêmes résultats. Le but d'ajouter ces méthodes au nombre est la modularisation des globaux.

Pour le bien de l'exhaustivité, je signale leur syntaxe:

<span>// prints 'true'
</span><span>console.log(Number.isInteger(19));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger(3.5));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger([1, 2, 3]));
</span>

Ici, String représente la valeur que vous souhaitez analyser et Radix est le radix que vous souhaitez utiliser pour convertir la chaîne.

l'extrait suivant montre quelques exemples d'utilisations:

<span>if (!Number.isInteger) {
</span>  <span>Number.isInteger = function isInteger (nVal) {
</span>    <span>return typeof nVal === 'number' &&
</span>      <span>isFinite(nVal) &&
</span>      nVal <span>> -9007199254740992 &&
</span>      nVal <span>      <span>Math.floor(nVal) === nVal;
</span>  <span>};
</span><span>}
</span></span>

Une démo en direct de ce code est affichée ci-dessous et est également disponible sur jsbin.

Ces méthodes sont prises en charge dans le nœud et tous les navigateurs modernes, à l'exception d'Internet Explorer. Dans le cas où vous souhaitez les polyfiller, vous pouvez simplement appeler leur méthode globale connexe comme indiqué ci-dessous:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

Prise en charge du navigateur

Le graphique suivant représente la prise en charge du navigateur pour les extensions de l'objet de numéro intégré dans ES6. Souris sur les boîtes pour voir l'utilisation en pourcentage des versions de navigateur respectives.

Puis-je utiliser le nombre ES6? Données sur la prise en charge de la fonction ES6-Number à travers les principaux navigateurs de Caniuse.com.

ES6 Méthodes de nombre: Enveloppement

Dans ce didacticiel, nous avons couvert les nouvelles méthodes et constantes ajoutées dans ECMAScript 6 qui fonctionnent avec le type de données de nombre. Il convient de noter que ES6 a également ajouté une autre constante que je n'ai pas mentionnée jusqu'à présent. Ceci est Number.epsilon et représente la différence entre une et la plus petite valeur supérieure à celle qui peut être représentée comme un nombre. Avec cette dernière note, nous avons conclu notre voyage pour le type de données de nombre.

Questions fréquemment posées (FAQ) sur les méthodes de nombre ES6

Quelles sont les nouvelles méthodes de numéro ES6 et comment fonctionnent-elles?

ES6 ont introduit plusieurs nouvelles méthodes de nombre qui facilitent le travail avec les nombres en JavaScript. Ceux-ci incluent Number.isfinite (), Number.IsInteger (), Number.isnan (), Number.Parsefloat () et Number.ParseInt (). Chacune de ces méthodes remplit une fonction spécifique. Par exemple, Number.SifInite () vérifie si une valeur est un nombre fini, tandis que Number.IsInteger () vérifie si une valeur est un entier. Number.isnan () vérifie si une valeur est nan (pas un nombre), et numéro.parsefloat () et numéro.parseint () analysent un argument de chaîne et renvoyez un numéro de point flottant et un entier respectivement.

Comment la méthode Number.epsilon fonctionne-t-elle dans ES6?

Numéro.epsilon dans ES6 est une nouvelle constante qui représente le plus petit intervalle entre deux nombres représentables. Il est particulièrement utile lors de la comparaison des nombres de points flottants pour l'égalité. En raison de la façon dont les nombres de points flottants sont représentés dans les ordinateurs, ils peuvent ne pas être exactement égaux même s'ils semblent l'être. Number.epsilon peut être utilisé pour vérifier si la différence entre deux nombres est inférieure à ce plus petit intervalle, indiquant qu'ils sont efficacement égaux.

Quel est le but de la méthode Number.issaFeInteger () dans ES6?

La méthode Number.issaFeInteger () dans ES6 est utilisée pour déterminer si une valeur est un entier sûr. Un entier sûr est un nombre qui peut être exactement représenté comme un numéro de double précision IEEE-754, ce qui signifie qu'il se situe dans la plage de - (2 ^ 53 - 1) et 2 ^ 53 - 1. Cette méthode est utile lorsque vous souhaitez Assurez-vous qu'un nombre peut être représenté avec précision en JavaScript, qui peut être important dans certaines opérations mathématiques.

En quoi la méthode Number.ParseInt () diffère-t-elle de la fonction globale ParseInt ()?

La méthode Number.ParseInt () dans ES6 est essentiellement la même que la fonction globale ParseInt (), mais c'est partie de l'objet numéro. Cela signifie que vous pouvez l'appeler comme une méthode sur l'objet numéro, plutôt que comme une fonction autonome. La fonctionnalité est la même - il convertit une chaîne en un entier à un radix ou une base spécifiée.

Quelle est la signification du nombre.max_safe_integer et nombre.min_safe_integer Constants dans ES6?

Les constantes Number.Max_Safe_Integer et Number.Min_Safe_Integer Les constantes dans ES6 représentent les valeurs entières maximales et minimales de sécurité dans JavaScript. Un entier sûr est celui qui peut être représenté exactement comme un numéro de double précision IEEE-754. Ces constantes sont utiles lorsque vous devez vérifier si un nombre se trouve dans la gamme entière sûre, qui peut être important dans certaines opérations mathématiques.

Comment puis-je utiliser la méthode numéro.isnan () dans ES6?

La méthode Number.isnan () dans ES6 est utilisée pour déterminer si une valeur est nan (pas un nombre). Ceci est différent de la fonction ISNAN () globale, qui convertit son argument en nombre avant de le tester. Number.isnan () n'effectue pas cette conversion, donc elle ne renvoie que si l'argument est la valeur NAN réelle, et non si l'argument est une valeur qui ne peut pas être convertie en un nombre.

L'utilisation de la méthode Number.Sifinite () dans ES6?

La méthode Number.isfinite () dans ES6 est utilisée pour déterminer si une valeur est un nombre fini. Ceci est différent de la fonction mondiale isfinite (), qui convertit son argument en nombre avant de le tester. Number.Sifinite () n'effectue pas cette conversion, donc elle ne renvoie que si l'argument est un nombre fini, et non si l'argument est une valeur qui ne peut pas être convertie en un nombre.

Comment fait La méthode Number.Parsefloat () fonctionne dans ES6?

La méthode Number.Parsefloat () dans ES6 est essentiellement la même que la fonction globale parsefloat (), mais elle fait partie de l'objet Number. Cela signifie que vous pouvez l'appeler comme une méthode sur l'objet numéro, plutôt que comme une fonction autonome. La fonctionnalité est la même - elle analyse un argument de chaîne et renvoie un numéro de point flottant.

Comment puis-je utiliser la méthode Number.IsInteger () dans ES6?

Le nombre.IsInteger () La méthode dans ES6 est utilisée pour déterminer si une valeur est un entier. Cette méthode renvoie vrai si la valeur est un nombre qui n'est pas l'infini, pas NAN, et peut être exprimé sans composant fractionnaire. Il est utile lorsque vous devez vérifier si un nombre est un entier, qui peut être important dans certaines opérations mathématiques.

Quelles sont les applications pratiques des nouvelles méthodes de numéro ES6?

Les nouvelles méthodes de numéro ES6 fournissent des moyens plus robustes et précis de travailler avec des chiffres en JavaScript. Ils peuvent être utilisés pour vérifier si un nombre est fini, un entier, Nan ou un entier sûr, et pour analyser les cordes en chiffres. Ces méthodes peuvent être particulièrement utiles dans les opérations mathématiques, la validation des données et partout ailleurs où un contrôle précis sur les nombres est requis.

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!