Résumé des nouvelles méthodes numériques dans ES6 (à lire absolument)

Cet article vous présente un résumé des nouvelles méthodes numériques de ES6 (à lire absolument). 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 vous sera utile.

Cet article présente les nouvelles méthodes numériques dans ES6 (ECMAScript 6).

Cet article vous présentera de nouvelles méthodes et constantes pour ajouter des Number types de données. Bien entendu, les méthodes employées ici ne sont pas entièrement nouvelles, mais elles peuvent déjà être déplacées directement dans et/ou (par exemple isNaN()). Nous allons mettre en pratique cela avec quelques exemples.

Number.isInteger()

La première méthode que je souhaite présenter est Number.isInteger(). C'est nouveau pour JavaScript et vous avez peut-être déjà défini et utilisé cette méthode. Il détermine si la valeur transmise à la fonction est un entier. Si la valeur de la fonction est vraie, cette méthode renvoie, si elle est fausse, elle se termine. La mise en œuvre de cette méthode est très simple et correspond à une syntaxe JavaScript native. Une des façons de réécrire cette fonction est :

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

Juste pour le plaisir, j'ai réécrit cette fonction avec une approche complètement différente :

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

Alors que les deux méthodes ci-dessus peuvent déterminer si le paramètre transmis est un entier, mais ils ne sont pas conformes à la spécification ECMAScript 6. Ainsi, si vous souhaitez réécrire strictement dans le respect des spécifications ES6, veuillez commencer par la syntaxe suivante :

    Number.isInteger(number)

Le numéro du paramètre représente la valeur à tester.

Un exemple utilisant cette méthode ressemble à ceci :

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

Cette méthode est prise en charge par Node.js et tous les navigateurs modernes, à l'exception d'Internet Explorer. Si vous devez prendre en charge des navigateurs plus anciens, vous pouvez utiliser un polyfill, tel que celui disponible sur le Mozilla Developer Network pour Firefox. Jetez un œil au code ci-dessous :

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

Number.isNaN()

Si vous avez déjà écrit du code JavaScript, cette méthode ne sera pas nouvelle pour vous. JavaScript a une méthode appelée isNaN() exposée via l'objet window. Cette méthode est utilisée pour déterminer si la valeur du test est égale à NaN. Elle renvoie vrai, sinon elle renvoie faux. Cependant, il y a un problème avec l'appel direct de window.isNaN(). Lorsque la valeur de test est forcée à être convertie en nombre, cette méthode renvoie une valeur vraie. Pour vous donner une idée concrète du problème, toutes les déclarations suivantes renvoient : true

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

Ce que vous voulez probablement, c'est une méthode qui ne renvoie true que si la valeur transmise est NaN. C'est pourquoi ECMAScript 6 a introduit Number.isNaN(). Sa syntaxe est la suivante :

    Number.isNaN(value)
    这value是您要测试的值。此方法的一些示例用法如下所示：
    
    // prints 'true'
    console.log(Number.isNaN(0/0));
    
    // prints 'true'
    console.log(Number.isNaN(NaN));
    
    // prints 'false'
    console.log(Number.isNaN(undefined));
    
    // prints 'false'
    console.log(Number.isNaN({prop: 'value'}));

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

Cette méthode est prise en charge par 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 :

    Number.isNaN = Number.isNaN || function (value) {
      return value !== value;
    };

NaN est la seule valeur non-self en JavaScript, ce qui signifie que c'est la seule valeur qui n'est pas égale à lui-même.

Number.isFinite()

Cette méthode a le même arrière-plan que la méthode précédente. En JavaScript, il existe une telle méthode window.isFinite(), qui est utilisée pour tester si la valeur transmise est un nombre fini. Malheureusement, il renvoie également une valeur vraie qui est contrainte à un nombre, un exemple ressemble à ceci :

    // prints 'true'
    console.log(window.isFinite(10));
    
    // prints 'true'
    console.log(window.isFinite(Number.MAX_VALUE));
    
    // prints 'true'
    console.log(window.isFinite(null));
    
    // prints 'true'
    console.log(window.isFinite([]));

Pour cette raison, dans ECMAScript 6, il existe une méthode appelée isFinite(). La syntaxe est la suivante :

    Number.isFinite(value)

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

    
    // prints 'true'
    console.log(Number.isFinite(10));
    
    // prints 'true'
    console.log(Number.isFinite(Number.MAX_VALUE));
    
    // prints 'false'
    console.log(Number.isFinite(null));
    
    // prints 'false'
    console.log(Number.isFinite([]));

Cette méthode est prise en charge par Node et tous les navigateurs modernes, à l'exception d'Internet Explorer. Vous pouvez trouver son polyfill sur la page méthodes sur MDN.

Number.isSafeInteger()

Number.isSafeInteger() est un tout nouvel ajout à ES6. Il teste si la valeur transmise est un entier sûr, auquel cas elle renvoie vrai. Un entier sûr est défini comme un entier qui satisfait aux deux conditions suivantes :

• Le nombre peut être représenté exactement comme un double IEEE-754

• nombre La représentation IEEE-754 ne peut pas être le résultat de l'arrondi d'un autre nombre entier pour correspondre à la représentation IEEE-754.

Selon cette définition, un entier sûr est compris entre - (2 à la puissance 53 - 1) incluant 2 à la puissance 53 - 1 contient tous les entiers.

    
    
    Number.isSafeInteger(value)
    这value是您要测试的值。此方法的一些示例用法如下所示：
    
    // prints 'true'
    console.log(Number.isSafeInteger(5));
    
    // prints 'false'
    console.log(Number.isSafeInteger('19'));
    
    // prints 'false'
    console.log(Number.isSafeInteger(Math.pow(2, 53)));
    
    // prints 'true'
    console.log(Number.isSafeInteger(Math.pow(2, 53) - 1));

Number.isSafeInteger() est pris en charge dans tous les navigateurs modernes, à l'exception d'Internet Explorer. Le polyfill pour cette méthode a été tiré de es6-shim par Paul Miller, comme ceci :

    
    Number.isSafeInteger = Number.isSafeInteger || function (value) {
      return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
    };

Veuillez noter que ce polyfill repose sur la méthode Number.isInteger() discutée précédemment, vous devez donc One à polyfill pour utiliser cette méthode.

ECMAScript 6 introduit également deux valeurs constantes liées : Number.MAX_SAFE_INTEGER et Number.MIN_SAFE_INTEGER. Le premier représente le plus grand entier sûr en JavaScript, qui est 2 à la puissance 53 - 1, tandis que le second représente le plus petit entier sûr, qui est - (2 à la puissance 53 - 1).

Les méthodes Number.parseInt() et Number.parseFloat()

Les méthodes Number.parseInt() et Number.parseFloat() appartiennent toutes deux à la même section car elles ne sont pas mentionnées dans cet article. d'autres méthodes similaires, elles existaient déjà dans les versions précédentes d'ECMAScript. Par conséquent, vous pouvez les utiliser de la même manière qu’actuellement et obtenir les mêmes résultats. La syntaxe est la suivante :

    // Signature of Number.parseInt
    Number.parseInt(string, radix)
    
    // Signature of Number.parseFloat
    Number.parseFloat(string)

où chaîne représente la valeur à analyser et base est la chaîne de base que vous souhaitez utiliser pour la conversion.

L'extrait de code suivant montre un exemple d'utilisation :

    // Prints '-3'
    console.log(Number.parseInt('-3'));
    
    // Prints '4'
    console.log(Number.parseInt('100', 2));
    
    // Prints 'NaN'
    console.log(Number.parseInt('test'));
    
    // Prints 'NaN'
    console.log(Number.parseInt({}));
    
    // Prints '42.1'
    console.log(Number.parseFloat('42.1'));
    
    // Prints 'NaN'
    console.log(Number.parseFloat('test'));
    
    // Prints 'NaN'
    console.log(Number.parseFloat({}));

Node和所有现代浏览器都支持这些方法，Internet Explorer除外。如果您想要使用它们，您可以简单地调用它们的全局方法，如下所示：

    // Polyfill Number.parseInt
    Number.parseInt = Number.parseInt || function () {
      return window.parseInt.apply(window, arguments);
    };
    
    // Polyfill Number.parseFloat
    Number.parseFloat = Number.parseFloat || function () {
      return window.parseFloat.apply(window, arguments);
    };

相关推荐：

ES5与ES6数组方法总结

关于ES6中字符串string常用的新增方法分享

ES6里关于数字新增判断详解

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!