Berapa banyak jenis jenis berangka javascript yang ada?

Hanya terdapat satu jenis angka dalam JavaScript: jenis titik terapung. JavaScript secara dalaman menyimpan nombor sebagai jenis titik terapung 64-bit, jadi sebenarnya tiada jenis integer dalam JavaScript. Mengikut format nombor dalam JavaScript, julat integer yang boleh diwakili ialah "[-2^53 ~ 2^53]", termasuk nilai sempadan tetapi perlu diperhatikan bahawa indeks tatasusunan, operator bit, dsb. menggunakan 32; -bit integer.

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi JavaScript 1.8.5, komputer Dell G3.

Dalam JavaScript, hanya terdapat satu jenis angka, yang secara dalaman diwakili sebagai nombor titik terapung 64-bit. Jadi sebenarnya tiada jenis integer dalam JavaScript.

print(3/2); // 1.5

Dapat dilihat bahawa nilai-nilai diproses sebagai nombor titik terapung.

Kerana JavaScript secara dalaman menyimpan nombor dalam jenis titik terapung 64-bit, tanpa mengira integer atau perpuluhan. Apa yang mengelirukan ialah beberapa operasi bit mesti memerlukan integer untuk dijalankan, jadi nombor titik terapung 64-bit ditukar secara automatik kepada integer 32-bit. Kemudian lakukan operasi bit. Dalam JavaScript, 1 dan 1.0 adalah sama

1 == 1.0 true
0.1+0.2 == 0.3 false
0.3/0.1 = 2.99999999996
(0.3-0.2) === (0.2-0.1) false

Ringkasnya, berhati-hati dengan operasi yang melibatkan perpuluhan

Ikuti format nombor dalam JavaScript (format titik terapung 64-bit yang ditakrifkan oleh IEEE- 754 ), julat integer yang boleh diwakili ialah [-2^53 ~ 2^53], termasuk nilai sempadan. Walau bagaimanapun, perlu diingatkan bahawa pengindeksan tatasusunan, pengendali bitwise, dsb. menggunakan integer 32-bit.

Ketepatan tertinggi nilai titik terapung ialah 17 tempat perpuluhan, tetapi ketepatannya jauh lebih rendah daripada integer semasa melakukan pengiraan aritmetik. Sebagai contoh, hasil penambahan 0.1 kepada 0.2 bukan 0.3, tetapi 0.30000000000000004. Ralat pembundaran kecil ini menjadikannya mustahil untuk menguji nilai titik terapung tertentu.

Oleh kerana nombor titik terapung binari boleh mewakili 1/2, 1/8, dsb. dengan tepat, tetapi tidak boleh mewakili 1/10, 1/100 dsb. Jadi nombor mudah seperti 0.1 tidak boleh diwakili dengan tepat.

Disebabkan isu ketepatan dengan nombor titik terapung, keputusan yang tidak dijangka mungkin diperoleh semasa perbandingan:

print((0.1+0.2) == 0.3); // false
print(0.1+0.2);          // 0.30000000000000004
print(0.3);              // 0.3

print((10/3-3) == (1/3));// false
print(10/3-3);           // 0.3333333333333335
print(1/3);              // 0.3333333333333333

Untuk integer, selagi integer dalam 53 digit digunakan, tidak Akan ada ketepatan masalah, jadi anda boleh menggunakannya dengan yakin.

Selain diwakili dalam perpuluhan, integer juga boleh diwakili oleh literal dalam perlapanan (asas 8) atau perenambelasan (asas 16). Antaranya, digit pertama literal perlapanan mestilah sifar (0), diikuti dengan urutan digit perlapanan (0 hingga 7). Jika nilai dalam literal melebihi julat, sifar pendahuluan diabaikan dan nilai berikut ditafsirkan sebagai nilai perpuluhan.

Literal oktal tidak sah dalam mod ketat dan akan menyebabkan enjin JavaScript yang menyokong mod ini menimbulkan ralat.

Dua digit pertama nilai literal heksadesimal mestilah 0x, diikuti dengan mana-mana digit heksadesimal (0~9 dan A~F). Antaranya, huruf A hingga F boleh menjadi huruf besar atau huruf kecil.

Memandangkan menyimpan nilai titik terapung memerlukan ruang memori dua kali lebih banyak daripada menyimpan nilai integer, ECMAScript tidak akan membuang masa untuk menukar nilai titik terapung kepada nilai integer. Jelas sekali, jika titik perpuluhan tidak diikuti oleh sebarang digit, maka nilai itu boleh disimpan sebagai nilai integer. Begitu juga, jika nilai titik terapung itu sendiri mewakili integer (seperti 1.0), maka nilai itu juga akan ditukar kepada integer.

Objek berangka

Sama seperti nilai rentetan sepadan dengan objek rentetan, nilai berangka juga mempunyai objek berangka yang sepadan, iaitu Bilangan .

Nilai berangka juga boleh terus memanggil sifat yang sepadan dengan nilai berangka:

print((6).toString()); // 6

Perhatikan bahawa dalam contoh ini, nilai berangka perlu ditambah dalam kurungan, jika tidak, noktah akan dianggap sebagai titik perpuluhan.

Penggunaan Nombor adalah serupa dengan penggunaan String Ia boleh melakukan penukaran jenis, mencipta objek berangka, dsb.

Apabila melakukan penukaran jenis, jika penukaran tidak berjaya, Number mengembalikan NaN, perkara yang sama berlaku apabila menggunakan objek berangka.

var a = Number('x');
print(typeof a, a);       // number NaN
var b = new Number('x'); 
print(typeof b, b);       // object [Number: NaN]

Nombor mempunyai 5 atribut khas (baca sahaja), iaitu:

• MAX_VALUE : Nilai positif maksimum, lebih besar nilainya akan menjadi Infiniti

• MIN_VALUE : Nilai positif minimum, lebih kecil nilainya akan menjadi 0

• NaN :Bukan Nombor

• NEGATIVE_INFINITY: Infiniti negatif, iaitu, -Infiniti

• POSITIVE_INFINITY: Infiniti positif, iaitu, Infiniti

print(Number.MAX_VALUE);         // 1.7976931348623157e+308
print(Number.MIN_VALUE);         // 5e-324
print(Number.NaN);               // NaN
print(Number.NEGATIVE_INFINITY); // -Infinity
print(Number.POSITIVE_INFINITY); // Infinity

Infiniti

Apabila hasil operasi berangka melebihi had atas nombor yang boleh diwakili oleh JavaScript, hasilnya ialah nilai infiniti khas (Jika nombor negatif, nilai melebihi bilangan yang JavaScript boleh mewakili julat nombor negatif, hasilnya ialah -Infinity.

Apabila hasil operasi menghampiri sifar secara tak terhingga dan lebih kecil daripada nilai minimum yang boleh diwakili oleh JavaScript (aliran bawah), hasilnya ialah 0. Apabila nombor negatif mengalir ke bawah, hasilnya ialah -0 dan nombor positif limpahan bawah, hasilnya ialah 0.

JavaScript mentakrifkan pembolehubah global Infinity dan NaN, yang kedua-duanya pembolehubah baca sahaja.

由于内存的限制，ECMAScript并不能保存世界上所有的数值。ECMAScript能够表示的最小数值保存在Number.MIN_VALUE中——在大多数浏览器中，这个值是5e-324；能够表示的最大数值保存在Number.MAX_VALUE中——在大多数浏览器中，这个值是1.7976931348623157e+308。如果某次计算的结果得到了一个超出JavaScript数值范围的值，那么这个数值将被自动转换成特殊的Infinity值。具体来说，如果这个数值是负数，则会被转换成-Infinity（负无穷），如果这个数值是正数，则会被转换成Infinity（正无穷）。 

如果某次计算返回了正或负的Infinity值，那么该值将无法继续参与下一次的计算，因为Infinity不是能够参与计算的数值。要想确定一个数值是不是有穷的（换句话说，是不是位于最小和最大的数值之间），可以使用isFinite()函数。

NaN

NaN是一个特殊的数值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）。

对于NaN，要记住的一点是，只要运算中出现NaN，结果就一定是NaN，就算是"NaN*0"这样的运算，也一样是NaN。只要对NaN运行比较运行，结果就一定是false，就算"NaN==NaN"/"NaN!=NaN"等，都是false。

要判断一个值是否为NaN，可以使用isNaN()函数：

print(isNaN(NaN));  // true
print(isNaN(0/0));  // true

在基于对象调用isNaN()函数时，会首先调用对象的valueOf()方法，然后确定该方法返回的值是否可以转换为数值。如果不能，则基于这个返回值再调用toString()方法，再测试返回值。

也可以使用x!==x来判断x是否为NaN，只有在x为NaN的时候，这个表达式的值才为true。

inFinite()

isFinite函数用于判断一个数是否为“正常”的数值：

print(isFinite(Number.NaN));               // false
print(isFinite(Number.NEGATIVE_INFINITY)); // false
print(isFinite(Number.POSITIVE_INFINITY)); // false

除了以上3个特殊值外，其他值的结果都为true

假如x是一个普通数值，则有：

x/0 = Infinity
x%0 = NaN
x/Infinity = 0
x%Infinity = x
0/0 = NaN
0%0 = NaN
Infinity/x = Infinity
Infinity%x = NaN
Infinity/Infinity = NaN
Infinity%Infinity = NaN

完整输出如下：

print(0 / 0);           // NaN
print(3 / 0);           // Infinity
print(Infinity / 0);    // Infinity
print(0 % 0);           // NaN
print(3 % 0);           // NaN
print(Infinity % 0);    // NaN
----------
print(0 / 4);           // 0
print(3 / 4);           // 0.75
print(Infinity / 4);    // Infinity
print(0 % 4);           // 0
print(3 % 4);           // 3
print(Infinity % 4);    // NaN
----------
print(0 / Infinity);           // 0
print(3 / Infinity);           // 0
print(Infinity / Infinity);    // NaN
print(0 % Infinity);           // 0
print(3 % Infinity);           // 3
print(Infinity % Infinity);    // NaN

负零与正零

负零与正零的值相等，不过毕竟带有符号，在一些运算中会有符号方面的差别，比如：

var zero = 0; 
var negz = -0;

此时，zero 等于 negz ， 但1/zero 却不等于 1/negz。

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

Atas ialah kandungan terperinci Berapa banyak jenis jenis berangka javascript yang ada?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!