Apakah kaedah baharu bagi objek nombor es6?

Kaedah nombor baharu ES6 termasuk: 1. "Number.isFinite()", yang boleh menentukan sama ada nilai yang ditentukan ialah nilai terhingga; 2. "Number.isNaN()", yang boleh mengesan sama ada pembolehubah ialah NaN; 3. "Number.parseInt()", yang boleh menukar rentetan kepada integer 4. "Number.parseFloat()", yang boleh menukar rentetan menjadi nombor titik terapung; ()", yang boleh Menentukan sama ada nilai itu adalah integer.

Persekitaran pengendalian tutorial ini: sistem Windows 7, ECMAScript versi 6, komputer Dell G3.

Dalam ES5, terdapat penukaran jenis dalam kaedah isFinite () dan isNaN () global, yang membawa kepada kekaburan dalam keputusan penghakiman akhir. ES6 menyediakan dua kaedah baharu, Number.isFinite () dan Number.isNaN (), pada objek Number untuk membuat pertimbangan berangka lebih mantap Biar saya lihat kedua-dua kaedah ini seterusnya.

Number.isFinite()

Terdapat fungsi isFinite() global dalam ES5 untuk menentukan parameter yang diluluskan dalam Sama ada nilai ialah nombor terhad Jika parameter ialah rentetan, ia akan ditukar kepada nombor dahulu dan kemudian disahkan.

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

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

isFinite("0");       // true

Seperti yang dapat dilihat daripada kod di atas, rentetan juga akan ditukar kepada nilai berangka terlebih dahulu dan kemudian dinilai IsFinite() yang disediakan pada objek ES6 Number adalah lebih mantap dan adalah serupa dengan fungsi isFinite() global, kaedah ini tidak memaksa parameter bukan angka untuk ditukar kepada nilai angka, yang bermaksud bahawa hanya nilai jenis angka yang terhingga akan kembali benar.

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

Tidak seperti nilai lain dalam JavaScript, NaN tidak boleh melepasi pengendali kesamaan ( == dan ===) untuk menilai, kerana NaN == NaN dan NaN === NaN akan kembali palsu. Oleh itu, adalah perlu untuk menentukan sama ada nilai adalah NaN.

1. Penjanaan nilai NaN

NaN berlaku apabila hasil operasi aritmetik mengembalikan nilai yang tidak ditentukan atau tidak boleh diwakili. Walau bagaimanapun, NaN tidak semestinya digunakan untuk menunjukkan bahawa sesetengah nilai berada di luar julat perwakilan.

• Apabila beberapa nilai bukan angka dipaksa menjadi nilai angka, NaN akan diperolehi.

• 0 dibahagikan dengan 0 mengembalikan NaN - tetapi nombor lain dibahagikan dengan 0 tidak akan mengembalikan NaN.

Kami tahu bahawa kami boleh menggunakan kaedah Number() untuk penukaran jenis Berikut ialah contoh penukaran jenis paksa kepada NaN:

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

Seperti yang dapat dilihat. daripada contoh di atas, banyak nilai ditukar kepada NaN di bawah penukaran jenis paksa Sudah pasti bermasalah untuk menilai nilai tersebut Mari kita lihat masalah isNaN ().

2 Masalah dengan isNaN ()

Secara lalai, terdapat kaedah global isNaN () yang digunakan untuk menentukan sama ada ia adalah nilai NaN. . Ia memerlukan nilai yang diterima ialah parameter jenis berangka, tetapi apabila parameter bukan jenis Nombor, fungsi isNaN akan cuba menukar parameter itu kepada nilai berangka, dan kemudian menilai sama ada hasil yang ditukar ialah NaN.

Contoh:

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

Digabungkan dengan keputusan contoh di atas tentang cara NaN dijana, dapat dilihat bahawa menggunakan isNaN untuk menentukan sama ada nilai yang dikembalikan adalah benar jelas sekali bukan hasil yang kita inginkan. Sebagai tindak balas kepada masalah sedemikian, ES6 telah ditampal Mari kita lihat kaedah isNaN dalam ES6.

3. Butiran Number.isNaN ()

ES6 menyediakan Number.isNaN(x) Menggunakan kaedah ini untuk mengesan sama ada pembolehubah x ialah NaN pendekatan yang boleh dipercayai yang tidak memberikan nilai yang dinilai.

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

Melalui contoh di atas, ia pada asasnya merangkumi semua situasi program sedia ada, dan tidak akan ada masalah yang disebabkan oleh penggunaan global isNaN(). Adalah disyorkan untuk menggunakan kaedah Number.isNaN(x) untuk menentukan sama ada ia adalah NaN. Jika fungsi Number.isNaN tidak disokong, anda boleh menggunakan ungkapan (x != x) untuk mengesan sama ada pembolehubah x ialah NaN, yang akan lebih dipercayai.

Number.parseInt()&Number.parseFloat()

Untuk mengekalkan kesatuan kaedah, parseInt global ( ) dan parseFloat() dialihkan ke objek ES6 Number.

Dua fungsi Number.isFinite () dan Number.isNaN () yang disediakan pada objek Number ES6 adalah sama Bagaimana untuk membuktikan bahawa kedua-dua kaedah di bawah Number ini hanya dipindahkan secara global? Anda boleh menggunakan operator === untuk menilai, seperti yang ditunjukkan dalam contoh berikut:

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

Hasil yang dikembalikan oleh kod di atas semuanya benar, menunjukkan bahawa kedua-dua fungsi ini adalah sama dengan fungsi global dan tidak berubah. Untuk kaedah penggunaan tertentu, sila rujuk fungsi parseInt() dan parseFloat() dalam ES5.

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

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

Pindahkan kedua-dua kaedah global ini ke objek Nombor, untuk mengurangkan kaedah global secara beransur-ansur dan menjadikan bahasa modular secara beransur-ansur.

Number.isInteger()

Sebelum mempelajari fungsi ini, mari semak cara kita menilai nilai Untuk integer?

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

Atas ialah kandungan terperinci Apakah kaedah baharu bagi objek nombor es6?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!