Ruang Nama Matematik & BigInt

Math.sqrt iaitu sqrt ialah sebahagian daripada ruang nama Matematik.

// 2 cara untuk mendapatkan punca kuasa dua.
Math.sqrt(100); // 10, Kaedah 1
100*(1/2); // 10, Kaedah 2
8*(1/3); // 2, berfungsi untuk akar padu juga

Math.max() & Math.min():

Math.max(23,54,12,6,32,98,87,34,11); // 98
// Adakah paksaan menaip juga
Math.min(23,54,12,'6',32,98,87,34,11); // 6
// Tidak melakukan penghuraian
Math.min(23,54,12,'6px',32,98,87,34,11); // NaN

Pemalar terbina pada objek Matematik:

Math.PI * (Number.parseFloat('10px')**(2)); // Mendapatkan kawasan

Hasilkan no b/w 1-6:

Math.trunc(Math.random() * 6) 1;

Hasilkan rawak tanpa b/w had atas-bawah:

const randomInt = (min, maks) => Math.floor(Math.random() * (max-min)) 1 min;
randomInt(10,20);

// Semua Math.method() ini melakukan pemaksaan taip.
Math.trunc(25.4); // 25
Math.round(25.4); // 25
Math.floor(25.4); // 25
Math.ceil(25.4); // 26

Math.floor ialah pilihan yang lebih baik untuk nombor negatif.

Math.trunc(-25.4); // -25
Math.floor(-25.4); // -26

// Membundarkan perpuluhan: .toFixed mengembalikan rentetan, bukan nombor
(2.5).kepadaTetap(0); // '3'
(2.5).kepadaTetap(3); // '2.500'
(2.345).kepadaTetap(2); // '2.35'

// Tambahkan tanda unari untuk menukarnya kepada tidak.
(2.345).kepadaTetap(2); // 2.35

// Nombor adalah primitif, oleh itu mereka tidak mempunyai kaedah. JADI di belakang tabir, JS akan melakukan tinju, iaitu mengubah primitif menjadi tanpa objek, melakukan operasi dan kemudian apabila operasi selesai, mengubahnya kembali kepada primitif.

Pengendali Modular atau Baki:

5 % 2; // 1

8 % 3; // 2
8 / 3; // 2.6666666666666665

// Ganjil atau Genap
const isEven = n => n%2 === 0;
isEven(20);
isEven(21);
isEven(22);

Kes penggunaan: Digunakan untuk berfungsi dengan semua baris ganjil, baris genap, kali ke-dsb.

Pemisah Berangka: [ES2021]

Digunakan untuk mewakili nombor yang sangat besar
Ini adalah garis bawah yang boleh diletakkan di antara nombor. Enjin mengabaikan garis bawah ini, ia mengurangkan kekeliruan untuk pembangun.
Cth. diameter const = 287_460_000_000;
diameter; // 287460000000

harga konst = 342_25;
harga; // 34225

yuran const1 = 1_500;
yuran const2 = 15_00;
yuran1 === yuran2; // benar

Skor bawah boleh diletakkan di antara nombor SAHAJA.
Ia tidak boleh diletakkan bersebelahan dengan titik perpuluhan.
Ia juga tidak boleh diletakkan pada permulaan atau penghujung no.

const PI = 3.14_15;
PI; // 3.1415

Semua adalah contoh pemisah angka yang tidak sah

const PI = 3.1415; // Tidak boleh diletakkan pada permulaan.
const PI = 3.1415; // Tidak boleh diletakkan pada akhirnya.
const PI = 3_.1415; // Tidak boleh diletakkan bersebelahan dengan titik perpuluhan.
const PI = 3.1415; // Tidak boleh diletakkan bersebelahan dengan titik perpuluhan.
const PI = 3._1415; // Dua berturut-turut tidak boleh diletakkan.

Menukar Rentetan kepada Nombor:

Nombor('2500'); // 2500
Nombor('25_00'); // NaN , Oleh itu kita hanya boleh menggunakan apabila nombor terus diberikan kepada pembolehubah. Oleh itu, jika tidak disimpan dalam rentetan atau mendapat tidak daripada API, maka untuk mengelakkan ralat, jangan gunakan pemisah angka '_'.
Begitu juga untuk parseInt iaitu apa-apa sahaja selepas _ dibuang seperti yang ditunjukkan di bawah:
parseInt('25_00'); // 25

BigInt

Jenis integer khas, diperkenalkan pada ES2020
Nombor diwakili secara dalaman sebagai 64 bit iaitu 64 1s atau 0s untuk mewakili sebarang nombor. Hanya 53 digunakan untuk menyimpan digit, baki digunakan untuk menyimpan kedudukan titik perpuluhan dan tanda. Oleh itu, terdapat had pada saiz nombor iaitu ((2*53) - 1). Ini adalah no terbesar yang JS boleh wakili dengan selamat. Asasnya ialah 2, kerana kami bekerja dalam bentuk binari semasa menyimpan.
2*53 - 1; // 9007199254740991
Nombor.MAX_SAFE_INTEGER; // 9007199254740991

Sesuatu yang lebih besar daripada ini adalah tidak selamat iaitu tidak boleh diwakili dengan tepat. Ketepatan akan hilang untuk nombor yang lebih besar daripada ini seperti yang ditunjukkan dalam digit terakhir. Kadang-kadang ia mungkin berkesan, sedangkan kadang-kadang tidak.
Nombor.MAX_SAFE_INTEGER 1; // 9007199254740992
Nombor.MAX_SAFE_INTEGER 2; // 9007199254740992
Nombor.MAX_SAFE_INTEGER 3; // 9007199254740994
Nombor.MAX_SAFE_INTEGER 4; // 9007199254740996

Sekiranya kita mendapat no yang lebih besar daripada API yang lebih besar daripada ini, maka JS tidak akan dapat menanganinya. Jadi untuk menyelesaikan isu di atas, BigInt jenis data primitif baharu telah diperkenalkan pada ES2020. Ini boleh menyimpan integer sebesar yang kita mahu.

'n' ditambahkan pada penghujung tidak untuk menjadikannya BigInt. Cth.
nombor const = 283891738917391283734234324223122313243249821n;
bilangan; // 283891738917391283734234324223122313243249821n

BigInt ialah cara JS untuk memaparkan nombor yang begitu besar.
Cara lain menggunakan Constructor Fn untuk mencipta nombor BigInt.
const x = BigInt(283891738917391283734234324223122313243249821);
x; // 283891738917391288062871194223849945790676992n

Operasi: Semua operator aritmetik berfungsi sama dengan BigInt;
const x = 100n 100n;
x; // 200n

const x = 10n * 10n;
x; // 100n

Elakkan mencampurkan nombor BigInt dengan nombor biasa

konst x = 100n;
const y = 10;
z = x*y; // Ralat

Untuk menjadikannya berfungsi, gunakan pembina BigInt Fn:
z = x * BigInt(y);
z; // 1000n

Pengecualian daripadanya ialah pengendali perbandingan & pengendali unary.

20n > 19; // benar
20n === 20; // false, === menghalang JS daripada melakukan paksaan jenis. Kedua-dua LHS & RHS mempunyai jenis primitif yang berbeza, oleh itu menghasilkan 'palsu'.

jenis 20n; // 'bigint'
jenis 20; // 'nombor'

20n == 20; // benar, kerana JS menaip paksaan untuk membandingkan hanya nilai dan bukan jenis dengan menukar BigInt kepada nombor biasa.
Perkara yang sama berlaku untuk ini juga: 20n == '20'; // benar

Pengecualian:

Nombor BigInt tidak ditukar kepada rentetan apabila menggunakan operator.
nombor const = 248923874328974239473829n
"num is large i.e. " num; // 'bilangan besar iaitu 248923874328974239473829'

Nota:
Math.sqrt tidak berfungsi dengan BigInt.
Semasa pembahagian BigInts, ia membuang bahagian perpuluhan.
10 / 3; // 3.3333333333333335
10n / 3n; // 3n
12n / 3n; // 4n

Jenis primitif baharu ini menambahkan beberapa keupayaan baharu pada bahasa JS untuk menjadikannya berfungsi dengan nombor besar.

Atas ialah kandungan terperinci Ruang Nama Matematik & BigInt. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!