Quelles sont les nouvelles méthodes de l'objet numéro es6 ?

es6 Les nouvelles méthodes numériques sont : 1. "Number.isFinite()", qui peut déterminer si la valeur spécifiée est une valeur finie ; 2. "Number.isNaN()", qui peut détecter si la variable est un NaN. ; 3. "Number.parseInt()" peut convertir une chaîne en un entier ; 4. "Number.parseFloat()" peut convertir une chaîne en un nombre à virgule flottante ; 5. "Number.isInteger()" peut déterminer si le la valeur est entière.

L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.

Dans ES5, il existe une conversion de type dans les méthodes globales isFinite () et isNaN (), ce qui conduit à une ambiguïté dans le résultat du jugement final. ES6 fournit deux nouvelles méthodes, Number.isFinite () et Number.isNaN (), sur l'objet Number pour rendre les jugements numériques plus robustes. Permettez-moi ensuite d'examiner ces deux méthodes.

Number.isFinite()

---

Dans ES5, il existe une fonction globale isFinite() qui est utilisée pour déterminer si la valeur du paramètre transmise est une valeur limitée. Si le paramètre est une chaîne, elle le sera. être d'abord converti en valeur A, puis vérifier.

isFinite(Infinity);  // false
isFinite(NaN);       // false
isFinite(-Infinity); // false

isFinite(0);         // true
isFinite(2e64);      // true
isFinite('2e64');    // true

isFinite("0");       // true

Comme le montre le code ci-dessus, la chaîne sera d'abord convertie en valeur numérique puis jugée. La fonction isFinite() fournie sur l'objet ES6 Number est plus robuste que la fonction globale isFinite(). cette méthode ne forcera pas la conversion d'un paramètre non numérique en valeur numérique, ce qui signifie que seules les valeurs de type numérique et les valeurs finies renverront vrai.

Number.isFinite(Infinity);  // false
Number.isFinite(NaN);       // false
Number.isFinite(-Infinity); // false

Number.isFinite(0);         // true
Number.isFinite(2e64);      // true
Number.isFinite('2e64');	// false

Number.isFinite('0');       // false

Number.isNaN()

---

Contrairement à d'autres valeurs en JavaScript, NaN ne peut pas être déterminé par les opérateurs d'égalité (== et ===), car NaN == NaN et NaN == = NaN renverra faux. Il est donc nécessaire de déterminer si une valeur est NaN.

1. Génération de valeurs NaN

NaN se produit lorsque le résultat d'une opération arithmétique renvoie une valeur indéfinie ou non représentable. Cependant, NaN n'est pas nécessairement utilisé pour indiquer qu'une valeur est en dehors de la plage de représentation.

• Lorsque certaines valeurs non numériques sont converties en valeurs numériques, NaN sera obtenu.

• 0 divisé par 0 renverra NaN - mais les autres nombres divisés par 0 ne renverront pas NaN.

Nous savons que nous pouvons utiliser la méthode Number() pour la conversion de type. Voici des exemples de conversion de type forcée en NaN :

Number(undefined)				// NaN
Number('undefined')				// NaN
Number('string')				// NaN
Number({})						// NaN
Number('10,3')					// NaN
Number('123ABC')				// NaN
Number(new Date().toString())	// NaN

Comme le montre l'exemple ci-dessus, de nombreuses valeurs​​sont converties en NaN sous conversion de type forcée Pour cela, il est sans aucun doute problématique de juger la valeur. Regardons le problème de isNaN ().

2. Problème avec isNaN()

Par défaut, il existe une méthode globale isNaN() qui est utilisée pour déterminer s'il s'agit d'une valeur NaN. Elle nécessite de recevoir un paramètre de type numérique, mais lorsque le paramètre. n'est pas de type Nombre, la fonction isNaN Elle tentera d'abord de convertir ce paramètre en valeur numérique, puis jugera si le résultat converti est NaN.

Exemple :

isNaN(NaN);       // true
isNaN(undefined); // true
isNaN('undefined')// true
isNaN({});        // true

isNaN(true);      // false
isNaN(null);      // false
isNaN(37);        // false

// strings
isNaN("37");      // false: 可以被转换成数值37
isNaN("37.37");   // false: 可以被转换成数值37.37
isNaN("37,5");    // true
isNaN('123ABC');  // true:  parseInt("123ABC")的结果是 123, 但是Number("123ABC")结果是 NaN
isNaN("");        // false: 空字符串被转换成0
isNaN(" ");       // false: 包含空格的字符串被转换成0

// dates
isNaN(new Date());                // false
isNaN(new Date().toString());     // true

isNaN("imooc")   // true: "blabla"不能转换成数值
                 // 转换成数值失败， 返回NaN

Combiné avec les résultats de l'exemple ci-dessus sur la façon dont NaN est généré, nous pouvons voir que l'utilisation de isNaN pour déterminer si la valeur renvoyée est vraie n'est évidemment pas le résultat souhaité. Pour résoudre ce problème, ES6 a été corrigé. Examinons la méthode isNaN dans ES6.

3. Number.isNaN () Détails

ES6 fournit Number.isNaN(x) Ce sera une méthode fiable pour détecter si la variable x est un NaN grâce à cette méthode. la valeur est convertie en type.

Number.isNaN(NaN);        // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0)       // true

// 下面这几个如果使用全局的 isNaN() 时，会返回 true。
Number.isNaN("NaN");      // false，字符串 "NaN" 不会被隐式转换成数字 NaN。
Number.isNaN(undefined);  // false
Number.isNaN('undefined');// false
Number.isNaN({});         // false
Number.isNaN("blabla");   // false

Number.isNaN(true);   	 // false
Number.isNaN(null);   	 // false
Number.isNaN(37);   	 // false
Number.isNaN("37");   	 // false
Number.isNaN("37.37");	 // false
Number.isNaN("");   	 // false
Number.isNaN(" ");   	 // false

Grâce à l'exemple ci-dessus, il couvre essentiellement toutes les situations des programmes existants, et il n'y aura aucun problème causé par l'utilisation de global isNaN(). Il est recommandé d'utiliser la méthode Number.isNaN(x) pour déterminer s'il s'agit de NaN. Si la fonction Number.isNaN n'est pas prise en charge, vous pouvez utiliser l'expression (x != x) pour détecter si la variable x est NaN, ce qui sera plus fiable.

Number.parseInt()&Number.parseFloat()

---

Afin de maintenir l'unité des méthodes, les parseInt() et parseFloat() globaux sont transplantés dans l'objet ES6 Number.

Les deux fonctions Number.isFinite() et Number.isNaN() fournies sur l'objet Number de ES6 sont les mêmes. Comment prouver que ces deux méthodes sous Number ne sont transplantées que globalement ? Vous pouvez utiliser l'opérateur === pour juger, comme le montre l'exemple suivant :

Number.parseInt === parseInt;				// true
Number.parseFloat === parseFloat;		// true

Les résultats renvoyés par le code ci-dessus sont tous vrais, indiquant que ces deux fonctions sont identiques à la fonction globale et n'ont pas changé. Pour les méthodes d'utilisation spécifiques, veuillez vous référer aux fonctions parseInt() et parseFloat() dans ES5.

// ES5的写法
parseInt('12.34') 						// 12
parseFloat('123.45#') 				// 123.45

// ES6的写法
Number.parseInt('12.34') 			// 12
Number.parseFloat('123.45#')  // 123.45

Portez ces deux méthodes globales vers l'objet Number, afin de réduire progressivement les méthodes globales et de rendre le langage progressivement modulaire.

Number.isInteger()

---

Avant d'apprendre cette fonction, voyons d'abord comment déterminer qu'une valeur est un entier ?

1、判断一个值为整数

一种方法是：任何整数都会被 1 整除，即余数是 0。利用这个规则来判断是否是整数。就有如下函数：

function isInteger(value) {
	return typeof value === 'number' && value%1 === 0;
}
isInteger(5) 		// true
isInteger(5.5) 	// false
isInteger('') 	// false
isInteger('8') 	// false
isInteger(true) // false
isInteger([]) 	// false

另一种方法是：使用 Math.round、Math.ceil、Math.floor 判断，因为整数取整后还是等于自己。利用这个特性来判断是否是整数，使用 Math.floor 示例，如下：

function isInteger(value) {
	return Math.floor(value) === value;
}
isInteger(5) 		// true
isInteger(5.5) 	// false
isInteger('') 	// false
isInteger('8') 	// false
isInteger(true) // false
isInteger([]) 	// false

上面的两种方法算是比较常用的判断方式，其他的一些方式都存在一些问题，这里就不一一列举了。但是，这两种方法都不够简洁，ES6 把判断整数提升到了语言层面，下面我们来看下 Number.isInteger() 的使用。

2、Number.isInteger () 的用法

Number.isInteger() 是 ES6 新增的函数，用来判断给定的参数是否为整数。

Number.isInteger(25) // true
Number.isInteger(25.1) // false

如果被检测的值是整数，则返回 true，否则返回 false。注意 NaN 和正负 Infinity 不是整数。

Number.isInteger(0);         // true
Number.isInteger(1);         // true
Number.isInteger(-100000);   // true

Number.isInteger(0.8);       // false
Number.isInteger(Math.PI);   // false

Number.isInteger(Infinity);  // false
Number.isInteger(-Infinity); // false
Number.isInteger("100");     // false
Number.isInteger(true);      // false
Number.isInteger(false);     // false
Number.isInteger([1]);       // false

上面的代码基本涵盖了 JavaScript 中的值的判断，在一些不支持 ES6 语法的浏览器中可以使用上面的两种方式进行 Polyfill 处理。

Number.isSafeInteger()

---

Number.isSafeInteger() 是 ES6 新增的函数，用来判断传入的参数值是否是一个 “安全整数”（safe integer）在数值扩展的 小节 我们介绍了最大安全整数和最小安全整数，不记得的同学可以跳过去看看。

一个安全整数是一个符合下面条件的整数：

• 可以准确地表示为一个 IEEE-754 双精度数字；

• 其 IEEE-754 表示不能是舍入任何其他整数以适应 IEEE-754 表示的结果。

比如，2e53 - 1 是一个安全整数，它能被精确表示，在任何 IEEE-754 舍入模式（rounding mode）下，没有其他整数舍入结果为该整数。作为对比，2e53 就不是一个安全整数，它能够使用 IEEE-754 表示，但是 2e53 + 1 不能使用 IEEE-754 直接表示，在就近舍入（round-to-nearest）和向零舍入中，会被舍入为 2e53。

安全整数范围为 -(2e53 - 1)到 2e53 - 1 之间的整数，包含 -(2e53 - 1)和 2e53 - 1。

Number.isSafeInteger(3);                    // true
Number.isSafeInteger(Math.pow(2, 53))       // false
Number.isSafeInteger(Math.pow(2, 53) - 1)   // true
Number.isSafeInteger(NaN);                  // false
Number.isSafeInteger(Infinity);             // false
Number.isSafeInteger("3");                  // false
Number.isSafeInteger(3.1);                  // false
Number.isSafeInteger(3.0);                  // true

【相关推荐：javascript视频教程、编程视频】

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!