Was sind die neuen Methoden des ES6-Nummernobjekts?

es6 Die neuen Zahlenmethoden sind: 1. „Number.isFinite()“, die bestimmen kann, ob der angegebene Wert ein endlicher Wert ist; 2. „Number.isNaN()“, die erkennen kann, ob die Variable eine NaN ist 3. „Number.parseInt()“ kann einen String in eine Ganzzahl umwandeln. 4. „Number.parseFloat()“ kann einen String in eine Gleitkommazahl umwandeln Der Wert ist eine Ganzzahl.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, ECMAScript Version 6, Dell G3-Computer.

In ES5 gibt es eine Typkonvertierung in den globalen Methoden isFinite() und isNaN(), was zu Mehrdeutigkeiten im endgültigen Beurteilungsergebnis führt. ES6 bietet zwei neue Methoden, Number.isFinite() und Number.isNaN(), für das Number-Objekt, um numerische Urteile robuster zu machen. Als nächstes möchte ich einen Blick auf diese beiden Methoden werfen.

Number.isFinite()

---

In ES5 gibt es eine globale isFinite()-Funktion, mit der ermittelt wird, ob der übergebene Parameterwert ein begrenzter Wert ist zuerst in einen A-Wert umgewandelt und dann überprüft werden.

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

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

isFinite("0");       // true

Wie aus dem obigen Code ersichtlich ist, wird die Zeichenfolge zuerst in einen numerischen Wert konvertiert und dann beurteilt. Die im ES6-Nummernobjekt bereitgestellte Funktion isFinite() ist robuster als die globale Funktion isFinite(). Diese Methode ist nicht Erzwingt die Konvertierung eines nicht numerischen Parameters in einen numerischen Wert, was bedeutet, dass nur numerische Typwerte und endliche Werte true zurückgeben.

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()

---

Im Gegensatz zu anderen Werten in JavaScript kann NaN nicht mit den Gleichheitsoperatoren (== und ===) beurteilt werden, da NaN == NaN und NaN == = NaN gibt false zurück. Daher ist es notwendig zu bestimmen, ob ein Wert NaN ist.

1. Generierung von NaN-Werten

NaN tritt auf, wenn das Ergebnis einer arithmetischen Operation einen undefinierten oder nicht darstellbaren Wert zurückgibt. NaN wird jedoch nicht unbedingt verwendet, um anzuzeigen, dass ein Wert außerhalb des Darstellungsbereichs liegt.

• Wenn einige nicht numerische Werte in numerische Werte umgewandelt werden, wird NaN erhalten.

• 0 dividiert durch 0 ergibt NaN – andere Zahlen dividiert durch 0 ergeben jedoch kein NaN.

Wir wissen, dass wir die Methode Number() für die Typkonvertierung verwenden können. Hier sind Beispiele für die erzwungene Typkonvertierung in NaN:

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

Wie aus dem obigen Beispiel ersichtlich ist, werden viele Werte in konvertiert Dafür ist es zweifellos problematisch, den Wert von isNaN () zu beurteilen.

2. Problem mit isNaN()

Standardmäßig gibt es eine globale Methode isNaN(), die verwendet wird, um zu bestimmen, ob es sich um einen NaN-Wert handelt. Sie erfordert den Empfang eines Parameters vom numerischen Typ ist nicht vom Typ Zahl, die Funktion isNaN. Sie versucht zunächst, diesen Parameter in einen numerischen Wert umzuwandeln, und beurteilt dann, ob das konvertierte Ergebnis NaN ist.

Beispiel:

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

In Kombination mit den Ergebnissen des obigen Beispiels zur Generierung von NaN können wir sehen, dass die Verwendung von isNaN zur Bestimmung, ob der zurückgegebene Wert wahr ist, offensichtlich nicht das gewünschte Ergebnis ist. Um dieses Problem zu beheben, wurde ES6 gepatcht. Schauen wir uns die isNaN-Methode in ES6 an.

3. Number.isNaN () Details

ES6 stellt eine zuverlässige Methode dar, um festzustellen, ob die Variable x ein NaN ist Der Wert wird in einen Typ umgewandelt.

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

Durch das obige Beispiel werden grundsätzlich alle Situationen vorhandener Programme abgedeckt, und die Verwendung von global isNaN () verursacht keine Probleme. Es wird empfohlen, die Methode Number.isNaN(x) zu verwenden, um zu bestimmen, ob es sich um NaN handelt. Wenn die Funktion Number.isNaN nicht unterstützt wird, können Sie den Ausdruck (x != x) verwenden, um zu ermitteln, ob die Variable x NaN ist, was zuverlässiger ist.

Number.parseInt()&Number.parseFloat()

---

Um die Einheit der Methoden aufrechtzuerhalten, werden die globalen parseInt() und parseFloat() in das ES6-Nummernobjekt übertragen.

Die beiden Funktionen Number.isFinite () und Number.isNaN (), die für das Number-Objekt von ES6 bereitgestellt werden, sind identisch. Wie kann man beweisen, dass diese beiden Methoden unter Number nur global übertragen werden? Zur Beurteilung können Sie den Operator === verwenden, wie im folgenden Beispiel gezeigt:

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

Die vom obigen Code zurückgegebenen Ergebnisse sind alle wahr, was darauf hinweist, dass diese beiden Funktionen mit der globalen Funktion identisch sind und sich nicht geändert haben. Informationen zu bestimmten Verwendungsmethoden finden Sie in den Funktionen parseInt() und parseFloat() in ES5.

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

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

Portieren Sie diese beiden globalen Methoden auf das Number-Objekt, um die globalen Methoden schrittweise zu reduzieren und die Sprache schrittweise modular zu gestalten.

Number.isInteger()

---

Bevor wir diese Funktion lernen, werfen wir zunächst einen Blick darauf, wie wir feststellen, dass ein Wert eine Ganzzahl ist.

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视频教程、编程视频】

Das obige ist der detaillierte Inhalt vonWas sind die neuen Methoden des ES6-Nummernobjekts?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!