Artikel ini akan melihat lebih dekat pada angka, operator matematika, cara untuk mengubah angka menjadi string dan sebaliknya, serta banyak poin penting lainnya.
Fungsi IsFinite
Fungsi isFinite memungkinkan Anda untuk memeriksa apakah sebuah argumen terbatas.
Sebagai tanggapan, fungsi ini mengembalikan nilai salah jika argumennya adalah Infinity, -Infinity, NaN, atau akan dimasukkan ke salah satu nilai numerik khusus ini. Jika tidak, fungsi ini akan mengembalikan nilai true.
IsFinite (73); // true isFinite (-1/0); // false isFinite (Infinity); // false isFinite (NaN); // false isFinite ("Text"); // Salah
Selain fungsi global isFinite, JavaScript juga memiliki metode Number.isFinite. Tidak seperti isFinite, itu tidak memaksa argumen menjadi angka.
IsFinite ("73"); // true Number.isFinite ("73"); // Salah
Fungsi IsNaN
Fungsi isNaN dirancang untuk menentukan apakah sebuah argumen berupa angka atau dapat dikonversi ke dalamnya. Jika demikian, maka fungsi isNaN mengembalikan nilai false. Jika tidak, itu mengembalikan nilai true.
IsNaN (NaN); // true isNaN ("25px"); // benar, karena 20px bukanlah angka isNaN (25.5); // false isNaN ("25.5"); // false isNaN (""); // salah, karena spasi atau beberapa spasi diubah menjadi 0 isNaN (null); // salah, karena null diubah menjadi 0 isNaN (true); // salah, karena true diubah menjadi 1 isNaN (false); // salah, karena false diubah menjadi 0
Jika tindakan ini perlu dilakukan tanpa transmisi tipe, gunakan metode Number.isNaN. Metode ini telah diperkenalkan ke dalam bahasa sejak ECMAScript 6.
Bagaimana saya bisa secara eksplisit mengonversi string menjadi angka?
Anda dapat secara eksplisit mengonversi string menjadi angka menggunakan metode berikut:
1. Gunakan operator + unaryuntuk ditempatkan sebelum nilai.
+ "7,35"; // 7,35 + "teks"; // NaN
Metode ini mengabaikan spasi kosong di depan dan di belakang serta \\ n (umpan baris).
+ "7,35"; //7,35 + "7,35 \\ n"; //7.35
Dengan menggunakan metode ini, Anda perlu memperhatikan fakta bahwa string kosong atau string yang terdiri dari spasi dan \\ n diterjemahkan ke angka 0. Selain itu, ini juga mengubah tipe data null dan nilai boolean menjadi angka .
Batal; // 0 + benar; // 1 + false; // 0 + ""; // 0
2. Fungsi parseInt. Fungsi ini dirancang untuk mengubah argumen ke integer... Berbeda dengan menggunakan operator unary +, metode ini memungkinkan Anda untuk mengubah string menjadi angka tidak semua karakter numerik... Ini mulai mengubah string mulai dari karakter pertama. Dan segera setelah ia menemukan karakter yang bukan digital, fungsi ini menghentikan pekerjaannya dan mengembalikan angka yang dihasilkan.
ParseInt ("18px"); // 18 parseInt ("33.3%"); // 33
Fungsi ini dapat bekerja dengan sistem bilangan yang berbeda (biner, oktal, desimal, heksadesimal). Radix ditentukan menggunakan 2 argumen.
ParseInt ("18px", 10); // 18 parseInt ("33.3%", 10); // 33 parseInt ("101", 2); // 5 parseInt ("B5", 16); // 181
Selain fungsi parseInt, JavaScript memiliki metode Number.parseInt. Metode ini tidak berbeda dengan fungsi parseInt dan diperkenalkan di JavaScript dengan spesifikasi ECMASCRIPT 2015 (6).
3. Fungsi parseFloat. ParseFloat mirip dengan parseInt, bedanya ParseFloat mengubah argumen menjadi pecahan.
ParseFloat ("33.3%"); //33.3
Selain itu, fungsi parseFloat, tidak seperti parseInt, tidak memiliki 2 argumen, dan oleh karena itu selalu mencoba untuk mempertimbangkan string sebagai angka dalam notasi desimal.
ParseFloat ("3.14"); parseFloat ("314e-2"); parseFloat ("0,0314E + 2");
Selain fungsi parseFloat, JavaScript memiliki metode Number.parseFloat. Metode ini tidak berbeda dengan fungsi parseFloat dan diperkenalkan di JavaScript dengan spesifikasi ECMASCRIPT 2015 (6).
Ubah angka menjadi string
Anda dapat mengubah angka menjadi string menggunakan metode toString.
(12.8) .toString (); //"12,8 "
Metode toString juga memungkinkan Anda untuk menentukan basis sistem bilangan, dengan mempertimbangkan yang diperlukan untuk secara eksplisit mentransmisikan nomor ke string:
(255) .toString (16); // "ff"
Bagaimana memeriksa apakah suatu variabel adalah angka
Anda dapat menentukan apakah nilai variabel adalah angka menggunakan salah satu metode berikut:
1. Menggunakan fungsi isNaN dan isFinite:
// myVar adalah variabel if (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar))) (// myVar adalah angka atau dapat dimasukkan ke dalamnya);
Sebagai fungsi:
// function function isNumeric (value) (return! isNaN (parseFloat (value)) && isFinite (parseFloat (value));) // use var myVar \u003d "12px"; console.log (isNumeric (myVar)); // benar
Metode ini memungkinkan Anda untuk menentukan apakah nilai yang ditentukan adalah angka atau dapat dikonversi. Opsi ini tidak memperlakukan string kosong, string spasi, , Infinity, -Infinity, true atau false sebagai angka.
2. Dengan menggunakan typeof operator dan isFinite, fungsi isNaN:
// fungsi yang memeriksa apakah nilainya adalah fungsi angka isNumber (nilai) (return typeof value \u003d\u003d\u003d "(! LANG: number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}
Fungsi ini menentukan apakah nilai yang ditentukan berjenis Number dan salah satu nilai khusus Infinity, -Infinity, dan NaN. Jika demikian, maka fungsi ini mengembalikan nilai true.
3. Menggunakan metode ECMAScript 6 Number.isInteger (nilai). Metode ini memungkinkan Anda untuk menentukan apakah nilai yang ditentukan adalah bilangan bulat.
Number.isInteger ("20"); // salah, karena metode ini tidak melakukan feed baris ke Number.isInteger (20); // benar, karena nilai yang diberikan adalah angka
Angka genap dan ganjil
Anda dapat memeriksa apakah suatu bilangan genap atau ganjil menggunakan fungsi berikut:
// Fungsi untuk memeriksa angka kemerataan fungsi isEven (n) (return n% 2 \u003d\u003d 0;) // Fungsi untuk memeriksa angka keanehan fungsi isOdd (n) (return Math.abs (n% 2) \u003d\u003d 1;)
Tetapi sebelum melakukan pemeriksaan seperti itu, disarankan untuk memastikan bahwa nilai yang ditentukan adalah angka:
Nilai \u003d 20; if (Number.isInteger (value)) (if (isEven (value)) (console.log ("Number" + value.toString () + "- even");))
Bilangan prima Javascript
Mari pertimbangkan contoh di mana kami menampilkan bilangan prima dari 2 hingga 100 menggunakan Javascript.
// Sebuah fungsi yang memeriksa apakah bilangan tersebut adalah fungsi utama isPrime (value) (if (isNaN (value) ||! IsFinite (value) || value% 1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);
Membulatkan angka dalam Javascript
Ada berbagai cara untuk membulatkan bilangan pecahan menjadi nilai integer di JavaScript.
1. Menggunakan metode yang dirancang khusus Math.floor, Math.ceil dan Math.round. Metode Math.floor membulatkan angka pecahan ke bilangan bulat terdekat, mis. buang saja bagian pecahannya. Math.ceil membulatkan angka pecahan ke atas ke bilangan bulat terdekat. Math.round membulatkan angka ke atas atau ke bawah tergantung pada nilai bagian pecahannya. Jika bagian pecahan lebih besar dari atau sama dengan 0,5, maka ke atas, jika tidak, ikal ke bawah.
Console.log (Math.floor (7.9)); // 7 console.log (Math.ceil (7.2)); // 8 console.log (Math.round (7.5)); // 8
2. Menggunakan metode toFixed (presisi). Metode ini membulatkan bagian pecahan sebuah angka ke presisi yang ditentukan. Hasil pembulatan dikembalikan sebagai string.
Console.log (7.987.toFixed (2)); //"7,99 "
Jika tidak ada cukup tempat desimal untuk membentuk presisi angka yang ditentukan, maka angka tersebut akan diisi dengan nol.
Console.log (7.987.toFixed (5)); //"7.98700 "
3. Melalui metode toPrecision. Metode ini merepresentasikan angka dengan presisi yang ditentukan. Selain itu, ia tidak hanya dapat membulatkan pecahan, tetapi juga seluruh bagian angka. Metode ini dapat merepresentasikan bilangan yang dihasilkan, bergantung pada hasilnya, dengan titik tetap atau dalam bentuk eksponensial.
Console.log ((1001) .toPrecision (2)); //"1.0e+3 "console.log ((1001) .toPrecision (5)); //"1001.0 "console.log ((12.4) .toPrecision (1)); // "1e + 1" console.log ((12.4) .toPrecision (2)); // "12" console.log ((12.4) .toPrecision (3)); //"12.4 "console.log ((12.4) .toPrecision (5)); //"12.400 "
4. Menggunakan operator logika BUKAN atau ATAU.
// melalui konsol.log negasi ganda logis (~~ 7.9); // 7 // dengan menggunakan logika OR dengan nol: console.log (7.9 ^ 0); // 7
Bagian bilangan bulat dan pecahan dari sebuah bilangan
Anda bisa mendapatkan bagian bilangan bulat dari sebuah angka menggunakan metode Math.floor () dan parseInt ():
Console.log (Math.floor (7.21)); // 7 console.log (parseInt (7.21)); // 7
Anda bisa mendapatkan bagian pecahan dari sebuah angka menggunakan operator persentase (%). Operator ini mengembalikan sisa yang akan diperoleh dengan membagi bilangan pertama dengan bilangan kedua. Dalam hal ini, 1 harus digunakan sebagai 2 angka.
Console.log (7,21% 1); // 0.20999999999999996 // akurat hingga 2 tempat desimal console.log ((7.21% 1) .toFixed (2)); // "0,21"
Selain itu, bagian pecahan juga dapat diperoleh dengan menggunakan perhitungan:
Nomor var \u003d 7.21; var fractionNumber \u003d bilangan - Math.floor (Math.abs (bilangan)); console.log (fractionNumber); // 0.20999999999999996
Apakah angkanya habis habis
Anda dapat menentukan apakah suatu angka habis dibagi menggunakan operator persen:
Var nomor \u003d 9; // jika sisa pembagian bilangan dengan 3 adalah 0, maka ya, sebaliknya tidak jika (bilangan% 3 \u003d\u003d 0) (console.log ("Number" + number + "habis dibagi 3");) else (konsol. log ("Angka" + angka + "tidak habis dibagi 3");)
Memformat angka
Dalam JavaScript, metode toLocaleString () memungkinkan Anda untuk memformat keluaran angka sesuai dengan pengaturan bahasa regional (sistem operasi).
Misalnya, mari format nomor sesuai dengan standar regional yang diinstal pada sistem secara default:
Nomor var \u003d 345.46; console.log (number.toLocaleString ()); // "345.46"
Misalnya, mari format nomor sesuai dengan standar regional Rusia (ru):
Console.log ((108.1) .toLocaleString ("ru-RU")); // "108,1"
Metode ini juga dapat digunakan untuk memformat angka sebagai mata uang:
Console.log ((2540.125) .toLocaleString ("ru-RU", (style: "currency", currency: "RUB"))); // "2 540.13 ₽" console.log ((89.3) .toLocaleString ("ru-RU", (style: "currency", currency: "USD"))); // "89.30 $" console.log ((2301,99) .toLocaleString ("ru-RU", (style: "currency", currency: "EUR"))); // "€ 2.301,99"
Representasi angka sebagai persentase:
Console.log ((0.45) .toLocaleString ("ru-RU", (style: "percent"))); // "45%"
Pisahkan nomor menjadi beberapa digit (properti useGrouping):
Console.log ((125452.32) .toLocaleString ("ru-RU", (useGrouping: true))); // "125 452,32"
Cetak angka dengan sejumlah digit (2) setelah koma:
Console.log ((1240.4564) .toLocaleString ("ru-RU", (minimumFractionDigits: 2, maximumFractionDigits: 2))); // "1240,46"
Membandingkan angka
JavaScript menggunakan operator berikut untuk membandingkan angka: \u003d\u003d (sama) ,! \u003d (Tidak sama),\u003e (lebih besar dari),< (меньше), >\u003d (lebih dari atau sama),<= (меньше или равно).
Misalnya, mari bandingkan dua angka:
Console.log (2\u003e 3); // false console.log (5\u003e \u003d 3); // benar
Saat membandingkan angka dengan bagian pecahan, perlu untuk memperhitungkan kesalahan yang mungkin timbul selama penghitungan ini.
Misalnya, dalam JavaScript, jumlah angka (0,2 + 0,4) bukan 0,6:
Console.log ((0,2 + 0,4) \u003d\u003d 0,6); // Salah
Kesalahan terjadi karena semua perhitungan dilakukan oleh komputer atau perangkat elektronik lainnya dalam sistem bilangan ke-2. Itu. sebelum melakukan tindakan apa pun, komputer harus terlebih dahulu mengubah angka yang direpresentasikan dalam ekspresi menjadi sistem 2 angka. Namun, tidak ada bilangan desimal pecahan yang dapat direpresentasikan persis dalam 2 sistem bilangan.
Misalnya, angka 0,25 10 diubah persis ke sistem biner.
0,125 × 2 \u003d 0,25 | 0 0,25 × 2 \u003d 0,5 | 0 0,5 × 2 \u003d 1 | 1 0,125 10 \u003d 0,001 2
Misalnya, angka 0,2 10 dapat diubah menjadi 2 sistem hanya dengan ketelitian tertentu:
0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 ... 0,2 10 \u003d 0,001100110011 ... 2
Akibatnya kesalahan tersebut akan mempengaruhi penghitungan jumlah dua angka dan hasil perbandingan. Itu. ternyata JavaScript akan melihat entri ini sebagai berikut:
0.6000000000000001==0.6
Saat menghitung atau menampilkan angka dengan bagian pecahan, Anda harus selalu menunjukkan ketepatan yang harus dilakukan.
Misalnya, bandingkan angka hingga 2 tempat desimal menggunakan metode toFixed () dan toPrecision ():
// metode toFixed () console.log ((0.2 + 0.4) .toFixed (2) \u003d\u003d (0.6) .toFixed (2)); // benar // metode toPrecision () console.log ((0.2 + 0.4) .toPrecision (2) \u003d\u003d (0.6) .toPrecision (2)); // benar
Operasi matematika dasar
Operator matematika berikut ada di JavaScript: + (penambahan), - (pengurangan), * (perkalian), / (pembagian),% (modulo), ++ (tambah nilai 1), - (turunkan nilai 1).
6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, yaitu 6: 3 \u003d 2 \u003d\u003e 6-3 * 2 \u003d\u003e istirahat (0) 5% 2 // 1, yaitu 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e istirahat (1) 7.3% 2 //1.3, yaitu 7.3: 2 \u003d 3 (.65) \u003d\u003e 7.3-2 * 3 \u003d\u003e istirahat (1.3) // tanda hasil operasi% sama dengan tanda nilai pertama -9% 2.5 //-1.5 , yaitu 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e istirahat (1.5) -9% -2.5 //-1.5, yaitu 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e istirahat (1.5) -2% 5 // - 2, yaitu 2: 5 \u003d 0 (.4) \u003d\u003e 2-5 * 0 \u003d\u003e istirahat (2) x \u003d 3; console.log (x ++); // mencetak 3, y menyetel 4 nanti console.log (x); // 4 x \u003d 3; console.log (++ x); // set 4 dan cetak x \u003d 5; console.log (x--); // mencetak 5, y menyetel 4 nanti console.log (x); // 4 x \u003d 5; console.log (- x); // set 4 dan output Selain itu, JavaScript memiliki operator gabungan: x + \u003d y (x \u003d x + y), x- \u003d y (x \u003d xy), x * \u003d y (x \u003d x * y), x / \u003d y (x \u003d x / y), x% \u003d y (x \u003d x% y). x \u003d 3; y \u003d 6; x + \u003d y; console.log (x); // 9 x \u003d 3; y \u003d 6; x- \u003d y; console.log (x); // - 3 x \u003d 3; y \u003d 6; x * \u003d y; console.log (x); // 18 x \u003d 3; y \u003d 6; x / \u003d y; console.log (x); //0.5 x \u003d 3; y \u003d 6; x% \u003d y; console.log (x); // 3
Seringkali, perhitungan dalam JavaScript tidak memberikan hasil yang kita inginkan. Tentu saja, kita dapat melakukan apa saja dengan angka - membulatkan ke atas atau ke bawah, mengatur rentang, memotong angka yang tidak perlu ke sejumlah tempat desimal, semuanya tergantung pada apa yang ingin Anda lakukan dengan angka ini di masa mendatang.Mengapa pembulatan diperlukan?
Salah satu aspek menarik dari JavaScript adalah JavaScript tidak benar-benar menyimpan bilangan bulat, kami segera bekerja dengan angka floating point. Ini, dikombinasikan dengan fakta bahwa banyak nilai pecahan tidak dapat diekspresikan dalam jumlah terbatas tempat desimal, dalam JavaScript kita bisa mendapatkan hasil seperti ini:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
Untuk tujuan praktis, ketidakakuratan ini tidak menjadi masalah sama sekali, dalam kasus kami, kami berbicara tentang kesalahan di triliun bagian, namun, ini mungkin mengecewakan seseorang. Kita bisa mendapatkan hasil yang sedikit aneh saat bekerja dengan angka yang mewakili nilai mata uang, persentase, atau ukuran file. Untuk mengoreksi ketidakakuratan ini, kita hanya perlu dapat membulatkan hasil, sementara itu cukup untuk mengatur ketepatan desimal.
Pembulatan bilangan memiliki aplikasi praktis, kita dapat memanipulasi bilangan dalam kisaran tertentu, misalnya kita ingin membulatkan nilai ke bilangan bulat terdekat, dan tidak hanya bekerja dengan bagian desimal.
Membulatkan angka desimal
Untuk menghapus angka desimal, gunakan toFixed atau metode toPrecision. Keduanya mengambil satu argumen, yang menentukan, masing-masing, berapa banyak digit signifikan (yaitu jumlah total digit yang digunakan dalam bilangan tersebut) atau tempat desimal (bilangan setelah titik desimal) hasilnya harus mencakup:- Jika argumen tidak ditentukan untuk toFixed (), maka akan default ke nol, yang berarti 0 tempat desimal, argumen memiliki nilai maksimum 20.
- Jika tidak ada argumen yang diberikan untuk toPrecision, angka tersebut dibiarkan tidak tersentuh
Baik toFixed () dan toPrecision () mengembalikan representasi string dari hasil, bukan angka. Ini berarti bahwa ketika nilai yang dibulatkan dijumlahkan dengan randNum, itu akan menjadi rangkaian string, bukan jumlah angka:
Misalkan randNum \u003d 6.25; biarkan rounded \u003d randNum.toFixed (); // "6" console.log (randNum + rounded); \u003e "6.256"
Jika Anda ingin hasilnya memiliki tipe data numerik, maka Anda perlu menggunakan parseFloat:
Misalkan randNum \u003d 6.25; biarkan bulat \u003d parseFloat (randNum.toFixed (1)); console.log (bulat); \u003e 6.3
Perhatikan bahwa 5 nilai dibulatkan kecuali dalam kasus yang jarang terjadi.
Metode toFixed () dan toPrecision () berguna karena tidak hanya dapat menghapus bagian pecahan, tetapi juga melengkapi tempat desimal, yang nyaman saat bekerja dengan mata uang:
Biarkan wholeNum \u003d 1 biarkan dollarCents \u003d wholeNum.toFixed (2); console.log (dollarCents); \u003e "1,00"
Harap dicatat bahwa toPrecision akan memberikan hasil dalam notasi eksponensial jika bilangan bulat lebih besar dari presisi itu sendiri:
Misalkan num \u003d 123,435 num.toPrecision (2); \u003e "1.2e + 2"
Bagaimana menghindari kesalahan pembulatan dengan angka desimal
Dalam beberapa kasus, toFixed dan toPrecision membulatkan 5 ke bawah dan ke atas:Misalkan numTest \u003d 1,005; numTest.toFixed (2); \u003e "1,00"
Hasil perhitungan di atas seharusnya 1,01, bukan 1. Jika Anda ingin menghindari kesalahan ini, kita dapat menggunakan solusi yang disarankan oleh Jack L Moore, yang menggunakan bilangan eksponensial untuk menghitung:
Fungsi putaran (nilai, desimal) (bilangan kembali (Math.round (nilai + "e" + desimal) + "e -" + desimal);)
Sekarang:
Putaran (1.005.2); \u003e 1,01
Jika Anda menginginkan solusi yang lebih kuat daripada yang ditunjukkan di atas, Anda dapat menuju ke MDN.
Mesin epsilon pembulatan
Metode alternatif untuk membulatkan angka desimal diperkenalkan di ES6. Mesin epsilon pembulatan memberikan margin kesalahan yang wajar saat membandingkan dua angka floating point. Tanpa pembulatan, perbandingan dapat menghasilkan hasil yang serupa dengan berikut ini:0,1 + 0,2 \u003d\u003d\u003d 0,3\u003e salah
Kami menggunakan Math.EPSILON dalam fungsi kami untuk mendapatkan perbandingan yang benar:
Fungsi epsEqu (x, y) (mengembalikan Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Fungsi tersebut memerlukan dua argumen: yang pertama adalah kalkulasi saat ini, yang kedua adalah hasil yang diharapkan. Ini mengembalikan perbandingan keduanya:
EpsEqu (0.1 + 0.2, 0.3)\u003e benar
Semua browser modern sudah mendukung fungsi matematika ES6, tetapi jika Anda ingin mendukung browser seperti IE 11 gunakan polyfill.
Pemotongan pecahan
Semua metode yang disajikan di atas tahu cara membulatkan ke angka desimal. Untuk memotong angka menjadi dua tempat desimal, Anda harus mengalikannya dengan 100 terlebih dahulu, lalu membagi hasilnya dengan 100:Fungsi terpotong (num) (mengembalikan Math.trunc (num * 100) / 100;) terpotong (3,1416)\u003e 3,14
Jika Anda ingin mengakomodasi sejumlah tempat desimal, Anda dapat menggunakan negasi bitwise ganda:
Fungsi terpotong (num, decimalPlaces) (let numPowerConverter \u003d Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Sekarang:
Misalkan randInt \u003d 35.874993; terpotong (randInt, 3); \u003e 35,874
Dibulatkan ke angka terdekat
Untuk membulatkan desimal ke atas atau ke bawah ke angka terdekat, mana pun yang terdekat dengan kita, gunakan Math.round ():Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 5
Perhatikan bahwa "setengah nilai", 0,5 dibulatkan sesuai dengan aturan matematika.
Bulatkan ke bawah ke bilangan bulat terdekat
Jika Anda ingin selalu membulatkan ke bawah, gunakan Math.floor:Math.floor (42.23); \u003e 42 Math.floor (36,93); \u003e 36
Perhatikan bahwa pembulatan ke bawah berlaku untuk semua angka, termasuk angka negatif. Bayangkan gedung pencakar langit dengan jumlah lantai yang tak terbatas, termasuk lantai yang lebih rendah (mewakili angka negatif). Jika Anda berada di elevator di lantai bawah antara 2 dan 3 (yang mewakili nilai -2.5), Math.floor akan membawa Anda ke -3:
Math.floor (-2.5); \u003e -3
Tetapi jika Anda ingin menghindari situasi ini, gunakan Math.trunc, yang didukung di semua browser modern (kecuali IE / Edge):
Math.trunc (-41.43); \u003e -41
Di MDN Anda akan menemukan polyfill yang akan memberikan dukungan untuk Math.trunc di browser dan IE / Edge.
Bulatkan ke bilangan bulat terdekat
Di sisi lain, jika Anda selalu perlu membulatkan, gunakan Math.ceil. Sekali lagi, mengingat lift tanpa batas: Math.ceil akan selalu naik, terlepas dari apakah angkanya negatif atau tidak:Math.ceil (42.23); \u003e 43 Math.ceil (36,93); \u003e 37 Math.ceil (-36,93); \u003e -36
Pembulatan ke atas / bawah sesuai kebutuhan
Jika kita ingin membulatkan ke kelipatan 5 terdekat, cara termudah adalah dengan membuat fungsi yang membagi angka dengan 5, membulatkannya, lalu mengalikannya dengan jumlah yang sama:Fungsi roundTo5 (num) (mengembalikan Math.round (num / 5) * 5;)
Sekarang:
RoundTo5 (11); \u003e 10
Jika Anda ingin membulatkan ke kelipatan nilai Anda, kami menggunakan fungsi yang lebih umum, dengan memasukkan nilai awal dan kelipatan:
Fungsi roundToMultiple (num, multiple) (return Math.round (num / multiple) * multiple;)
Sekarang:
Misalkan initialNumber \u003d 11; biarkan kelipatan \u003d 10; roundToMultiple (initialNumber, multiple); \u003e 10;
Memperbaiki angka dalam suatu rentang
Ada banyak kasus di mana kita ingin mendapatkan nilai x yang berada dalam suatu rentang. Misalnya, kita mungkin menginginkan nilai antara 1 dan 100, tetapi kita mendapat nilai 123. Untuk memperbaikinya, kita dapat menggunakan min (mengembalikan yang terkecil dari satu set angka) dan max (mengembalikan yang terbesar dari kumpulan angka manapun ). Dalam contoh kami, kisarannya dari 1 hingga 100:Biarkan lowBound \u003d 1; biarkan highBound \u003d 100; biarkan numInput \u003d 123; biarkan dijepit \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (dijepit); \u003e 100;
Sekali lagi, kita dapat menggunakan kembali operasi dan menggabungkan semuanya menjadi sebuah fungsi, mari gunakan solusi yang disarankan oleh Daniel X. Moore:
Number.prototype.clamp \u003d function (min, max) (return Math.min (Math.max (this, min), max););
Sekarang:
NumInput.clamp (lowBound, highBound); \u003e 100;
Pembulatan Gaussian
Pembulatan gaussian, juga dikenal sebagai pembulatan bank, adalah tempat pembulatan terjadi ke genap terdekat. Metode pembulatan ini bekerja tanpa kesalahan statistik. Solusi terbaik disarankan oleh Tim Down:Fungsi gaussRound (num, decimalPlaces) (misalkan d \u003d decimalPlaces || 0, m \u003d Math.pow (10, d), n \u003d + (d? Num * m: num) .toFixed (8), i \u003d Math.floor (n), f \u003d n - i, e \u003d 1e-8, r \u003d (f\u003e 0,5 - e && f< 0.5 + e) ?
((i % 2 == 0) ? i: i + 1) : Math.round(n);
return d ? r / m: r;
}
Sekarang:
GaussRound (2.5)\u003e 2 gaussRound (3.5)\u003e 4 gaussRound (2.57,1)\u003e 2.6
Titik desimal di CSS:
Karena JavaScript sering digunakan untuk menghasilkan transformasi posisi pada elemen HTML, Anda mungkin bertanya-tanya apa yang terjadi jika kita menghasilkan nilai desimal untuk elemen kita:
#box (lebar: 63.667731993px;)
Kabar baiknya adalah browser modern akan mempertimbangkan nilai desimal dalam model kotak, termasuk dalam persentase atau unit piksel.
Penyortiran
Sangat sering kami harus mengurutkan beberapa elemen, misalnya, kami memiliki serangkaian catatan permainan, dan mereka harus diatur dalam urutan menurun dari pangkat para pemain. Sayangnya, metode sortir standar () memiliki beberapa batasan yang mengejutkan: metode ini berfungsi baik dengan kata-kata bahasa Inggris yang umum digunakan, tetapi langsung rusak saat dihadapkan dengan angka, karakter unik, atau kata huruf besar.Sortir menurut abjad
Tampaknya mengurutkan array menurut abjad harus menjadi tugas yang paling sederhana:Biarkan buah \u003d ["butternut squash", "apricot", "cantaloupe"]; fruit.sort (); \u003e "aprikot", "butternut squash", "cantaloupe"]
Namun, kami mengalami masalah segera setelah salah satu elemennya adalah huruf besar:
Biarkan buah \u003d ["butternut squash", "apricot", "Cantalope"]; fruit.sort (); \u003e "Cantaloupe", "apricot", "butternut squash"]
Ini karena, secara default, penyortir membandingkan karakter pertama yang direpresentasikan dalam Unicode. Unicode adalah kode unik untuk karakter apa pun, apa pun platformnya, apa pun programnya, apa pun bahasanya. Misalnya, jika Anda melihat tabel kode, karakter "a" memiliki nilai U + 0061 (dalam sistem heksadesimal 0x61), sedangkan karakter "C" memiliki kode U + 0043 (0x43), yang muncul lebih awal di Tabel unicode dari karakter "A".
Untuk mengurutkan larik yang bisa berisi campuran huruf besar dan huruf pertama, kita perlu mengonversi semua elemen sementara menjadi huruf kecil, atau menentukan urutan kita sendiri menggunakan metode localeCompare () dengan beberapa argumen. Sebagai aturan, untuk kasus seperti itu, lebih baik segera membuat fungsi untuk penggunaan berulang:
Fungsi alphaSort (arr) (arr.sort (function (a, b) (return a.localeCompare (b, "en", ("sensitivitas": "base"));));) biarkan buah \u003d ["butternut squash "," aprikot "," Cantaloupe "]; alphaSort (buah)\u003e
Jika Anda ingin mendapatkan array yang diurutkan dalam urutan alfabet terbalik, cukup tukar posisi a dan b dalam fungsi:
Fungsi alphaSort (arr) (arr.sort (function (a, b) (return b.localeCompare (a, "en", ("sensitivitas": "base"));));) biarkan buah \u003d ["butternut squash "," aprikot "," Cantaloupe "]; alphaSort (buah)\u003e ["Cantaloupe", "butternut squash", "apricot"]
Di sini perlu dicatat bahwa localeCompare digunakan dengan argumen, Anda juga perlu ingat bahwa ini didukung oleh IE11 +, untuk versi IE yang lebih lama, kita dapat menggunakannya tanpa argumen, dan dalam huruf kecil:
Fungsi caseSort (arr) (arr.sort (function (a, b) (return a.toLowerCase (). LocaleCompare (b.toLowerCase ());));) biarkan buah \u003d ["butternut squash", "apricot", "Blewah"]; caseSort (buah)\u003e ["apricot", "butternut squash", "Cantaloupe"]
Urutan numerik
Semua ini tidak berlaku untuk contoh yang kita bicarakan di atas tentang array record game. Dengan beberapa larik numerik, pengurutan berfungsi dengan baik, tetapi pada titik tertentu hasilnya tidak dapat diprediksi:Biarkan highScores \u003d; highScores.sort (); \u003e
Faktanya adalah bahwa metode sort () melakukan perbandingan leksikografik: yang berarti bahwa angka akan diubah menjadi string dan perbandingan akan dilakukan lagi dengan mencocokkan karakter pertama dari string ini dalam urutan karakter tabel Unicode. Oleh karena itu, kami sekali lagi perlu menentukan urutan sortir kami:
Biarkan highScores \u003d; highScores.sort (function (a, b) (return a - b;)); \u003e
Sekali lagi, untuk mengurutkan angka dalam urutan terbalik, tukar posisi a dan b dalam fungsi.
Mengurutkan struktur seperti JSON
Terakhir, jika kita memiliki struktur data seperti JSON yang direpresentasikan sebagai larik rekaman game:Biarkan skor \u003d [("nama": "Daniel", "skor": 21768), ("nama": "Michael", "skor": 33579), ("nama": "Alison", "skor": 38395 )];
Di ES6 +, Anda dapat menggunakan fungsi panah:
Scores.sort ((a, b) \u003d\u003e b.score - a.score));
Untuk browser lama yang tidak memiliki dukungan ini:
Scores.sort (function (a, b) (return a.score - b.score));
Seperti yang Anda lihat, mengurutkan dalam JavaScript bukanlah hal yang jelas, saya harap contoh ini membuat hidup lebih mudah.
Bekerja dengan fungsi daya
Eksponensial adalah operasi, awalnya didefinisikan sebagai hasil perkalian bilangan asli dengan dirinya sendiri, akar kuadrat dari a adalah bilangan yang memberikan a ketika kuadrat. Kita dapat menggunakan fungsi ini sepanjang waktu dalam kehidupan sehari-hari dalam pelajaran matematika, termasuk saat menghitung luas, volume, atau bahkan dalam pemodelan fisik.Dalam JavaScript, fungsi eksponensial direpresentasikan sebagai Math.pow (), dalam standar ES7 yang baru, operator eksponensial baru diperkenalkan - "* *".
Eksponensial
Untuk menaikkan angka ke pangkat n, gunakan fungsi Math.pow (), di mana argumen pertama adalah angka yang akan dipangkatkan, argumen kedua adalah eksponen:Kekuatan matematika (3,2)\u003e 9
Bentuk notasi ini berarti 3 kuadrat, atau 3 × 3, yang mengarah ke hasil 9. Anda dapat memberikan contoh lain, tentu saja:
Math.pow (5.3); \u003e 125
Artinya, 5 kubik, atau 5 × 5 × 5, sama dengan 125.
ECMAScript 7 adalah versi JavaScript berikutnya, pada prinsipnya, kita dapat menggunakan operator eksponen baru yang diusulkan - * *, notasi ini dapat lebih deskriptif:
3 ** 2
> 9
Saat ini dukungan untuk operator ini agak terbatas, sehingga tidak disarankan untuk digunakan.
Fungsi daya dapat berguna dalam berbagai situasi. Contoh sederhana, menghitung jumlah detik dalam satu jam: Math.pow (60,2).
Akar kuadrat dan kubus
Math.sqrt () dan Math.cbrt () adalah kebalikan dari fungsi Math.pow (). Ingatlah bahwa akar kuadrat dari a adalah bilangan yang menghasilkan a jika dikuadratkan.Math.sqrt (9)\u003e 3
Pada saat yang sama, akar pangkat tiga dari bilangan a adalah bilangan yang memberikan a saat dipangkatkan ke sebuah kubus.
Math.cbrt (125)\u003e 5
Math.cbrt () diperkenalkan ke spesifikasi JavaScript baru-baru ini dan oleh karena itu hanya didukung di browser modern: Chrome 38+, Firefox dan Opera 25+, dan Safari 7.1+. Anda akan melihat bahwa Internet Explorer tidak ada dalam daftar ini, namun Anda akan menemukan polyfill di MDN.
Contoh dari
Tentu saja, kita juga dapat menggunakan nilai non-integer di salah satu fungsi berikut:Math.pow (1,25, 2); \u003e 1.5625 Math.cbrt (56.57)\u003e 3.8387991760286138
Perhatikan bahwa ini juga berfungsi dengan baik untuk nilai argumen negatif:
Math.pow (-5,2)\u003e 25 Math.pow (10, -2)\u003e 0,01
Namun, untuk akar kuadrat, ini tidak akan berhasil:
Math.sqrt (-9)\u003e NaN
Kita tahu dari analisis matematis bahwa bilangan imajiner dipahami sebagai akar kuadrat dari bilangan negatif. Dan ini mungkin membawa kita ke teknik lain untuk bekerja dengan bilangan kompleks, tapi itu cerita lain.
Anda dapat menggunakan nilai pecahan di Math.pow () untuk mencari akar kuadrat dan kubik. Akar kuadrat menggunakan eksponen 0,5:
Math.pow (5, 0,5); // \u003d Math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
Namun, karena keanehan titik mengambang, Anda tidak dapat menebak hasil yang benar secara akurat:
Math.pow (2.23606797749979.2)\u003e 5.000000000000001
Dalam situasi seperti itu, Anda harus menggunakan pemotongan tanda dari angka atau pembulatan ke beberapa nilai.
Beberapa, karena alasan yang tidak diketahui di JavaScript, membingungkan fungsi Math.pow () dengan Math.exp (), yang merupakan fungsi eksponensial untuk angka secara umum. Catatan: dalam bahasa Inggris, "eksponen" diterjemahkan sebagai "eksponen", jadi ini lebih cenderung merujuk ke penutur bahasa Inggris, meskipun ada nama alternatif untuk eksponen, seperti indeks, pangkat.
Konstanta matematika
Bekerja dengan matematika dalam JavaScript menjadi lebih mudah dengan sejumlah konstanta bawaan. Konstanta ini adalah properti dari objek Matematika. Perhatikan bahwa konstanta ditulis dalam huruf besar, bukan notasi CamelCase.Math.abs, parseInt, parseFloat
Bekerja dengan angka dalam JavaScript bisa jauh lebih rumit daripada kedengarannya. Nilai yang diperoleh tidak selalu berada dalam kisaran yang diharapkan, terkadang hasilnya mungkin tidak seperti yang kita harapkan.Math.abs ()
Metode Math.abs () mengembalikan nilai absolut dari sebuah angka, yang mengingatkan kita pada fungsi matematika analog untuk modulus sebuah angka.Misalkan newVal \u003d -57.64; Math.abs (newVal); \u003e 57.64
Math.abs (0) selalu mengembalikan nol, tetapi jika kita meletakkan tanda minus di depan fungsi -Math.abs (NUM), kita akan selalu negatif.
Math.abs (0); \u003e -0
parseInt ()
Kami tahu bahwa JavaScript memahami bahwa "15" adalah string, bukan angka, dan, misalnya, saat mengurai properti CSS menggunakan JavaScript, atau mendapatkan beberapa nilai dari larik yang tidak disiapkan, hasil kami tidak dapat diprediksi. Kita bisa mendapatkan string yang direpresentasikan sebagai "17px" sebagai input, dan ini tidak biasa bagi kami. Pertanyaannya adalah bagaimana mengubah string ini menjadi nilai aktual dan menggunakannya dalam perhitungan lebih lanjut.Sintaks: parseInt (string, radix);
Fungsi parseInt mengonversi argumen pertama yang diteruskan ke string, menafsirkannya, dan mengembalikan nilai integer atau NaN. Hasilnya (jika bukan NaN) adalah bilangan bulat dan merupakan argumen pertama (string), diperlakukan sebagai angka dalam sistem bilangan yang ditentukan (radix). Misalnya, basis 10 menunjukkan konversi dari desimal, 8 ke oktal, 16 ke heksadesimal, dan seterusnya. Jika alasnya lebih besar dari 10, maka huruf digunakan untuk menunjukkan angka yang lebih besar dari 9. Misalnya, bilangan heksadesimal (basis 16) menggunakan huruf A sampai F.
Mari kita pertimbangkan contoh bekerja dengan properti CSS, di mana, secara relatif, kita bisa mendapatkan nilai seperti itu:
Misalkan elem \u003d document.body; biarkan centerPoint \u003d window.getComputedStyle (elem) .transformOrigin; \u003e "454px 2087.19px"
Kita dapat membagi nilai dengan spasi:
Biarkan pusat \u003d centerPoint.split (""); \u003e ["454px", "2087.19px"]
Namun, setiap elemen masih berupa string, kita bisa menghilangkannya dengan menerapkan fungsi kita:
Misalkan centerX \u003d parseInt (pusat, 10); \u003e 454 biarkan centerY \u003d parseInt (pusat, 10); \u003e 2087
Seperti yang Anda lihat, sebagai argumen kedua, kami menunjukkan sistem bilangan yang akan dikonversi bilangan, parameter ini opsional, tetapi disarankan untuk menggunakannya jika Anda tidak tahu string mana yang akan masuk ke input.
parseFloat ()
Dari contoh di atas, Anda mungkin telah memperhatikan bahwa parseInt membuang bagian pecahan. Dalam kasus kami, parseFloat dapat bekerja dengan bilangan floating point. Sekali lagi, ini bisa berguna saat mengurai CSS dan tugas lainnya, terutama saat menangani persentase floating point.Sintaks: parseFloat (string)
Misalkan FP \u003d "33.33333%"; console.log (parseFloat (FP)); \u003e 33.33333
Perhatikan bahwa tidak ada argumen kedua dalam sintaks parseFloat.
Kami memahami bahwa parseInt () dan parseFloat () adalah fungsi yang sangat berguna, penting untuk diingat bahwa ini bukan tanpa kesalahan, oleh karena itu perlu untuk memeriksa kisaran nilai yang diharapkan dan pada akhirnya menganalisis hasilnya untuk memastikan bahwa nilai yang diperoleh benar.
Kirim secara anonim
Penghitungan sering kali memberikan hasil yang berada di luar kisaran yang diinginkan. Akibatnya, Anda perlu menerapkannya Pembulatan JavaScript ke nilai tertentu.
Mengapa membulatkan angka?
JavaScript tidak menyimpan bilangan bulat karena nilainya direpresentasikan sebagai bilangan floating point. Banyak pecahan tidak dapat diwakili oleh sejumlah tempat desimal yang terbatas, sehingga JavaScript dapat memberikan hasil seperti di bawah ini:
0.1 * 0.2; > 0.020000000000000004
Dalam praktiknya, ini tidak akan membuat perbedaan apa pun, karena kita berbicara tentang kesalahan sebesar 2 triliun. Namun, ini bisa memengaruhi hasil saat bekerja dengan angka yang mewakili nilai mata uang, persentase, atau ukuran file. Oleh karena itu, Anda perlu melakukan atau ke tempat desimal tertentu.
Membulatkan angka desimal
Untuk "memangkas" angka desimal, gunakan metode toFixed () atau toPrecision (). Keduanya mengambil satu argumen, yang menentukan jumlah tempat signifikan dan desimal untuk dimasukkan ke dalam hasil:
- jika tidak ada argumen yang ditentukan untuk toFixed (), defaultnya adalah 0, yaitu, tidak ada tempat desimal; nilai maksimum argumen adalah 20;
- jika tidak ada argumen yang ditentukan untuk toPrecision (), jumlahnya tidak berubah.
var randNum \u003d 6.25; randNum.toFixed (); \u003e "6" Math.PI.toPrecision (1); \u003e "3" var randNum \u003d 87.335; randNum.toFixed (2); \u003e "87.33" var randNum \u003d 87.337; randNum.toPrecision (3); \u003e "87,3"
Catatan
Baik toFixed () dan toPrecision mengembalikan representasi string bulat dari hasil, bukan angka. Ini berarti bahwa menambahkan rounded ke randNum akan menghasilkan rangkaian string, bukan satu angka:
console.log (randNum + rounded); \u003e "6.256"
Jika Anda ingin JavaScript membulatkan ke seperseratus terdekat, gunakan parseFloat ():
var randNum \u003d 6.25; var rounded \u003d parseFloat (randNum.toFixed (1)); console.log (bulat); \u003e 6.3
toFixed () dan toPrecision () juga merupakan metode yang berguna untuk memotong banyak tempat desimal. Ini berguna saat bekerja dengan angka yang mewakili unit mata uang:
var wholeNum \u003d 1 var dollarCents \u003d wholeNum.toFixed (2); console.log (dollarCents); \u003e "1,00"
Perhatikan bahwa jika ada lebih banyak digit dalam bilangan daripada yang ditentukan oleh parameter presisi, toPrecision akan mengembalikan hasilnya dalam format ilmiah:
var num \u003d 123,435 num.toPrecision (2); \u003e "1.2e + 2"
Bagaimana menghindari kesalahan saat membulatkan desimal
Dalam beberapa kasus, toFixed dan toPrecision menerapkan Pembulatan JavaScript 5 ke bawah, dan tidak lebih:
var numTest \u003d 1,005; numTest.toFixed (2); \u003e 1;
Contoh di atas harus menghasilkan 1,01, bukan 1. Jika Anda ingin menghindari kesalahan ini, saya sarankan menggunakan bilangan eksponensial:
function round (nilai, desimal) (return Number (Math.round (nilai + "e" + desimal) + "e -" + desimal);)
Aplikasi:
bulat (1.005.2); \u003e 1,01
Jika Anda membutuhkan solusi yang lebih andal daripada pembulatan, tersedia di MDN.
Pembulatan epsilon
Metode alternatif Pembulatan JavaScript ke persepuluhan diperkenalkan di ES6 ( juga dikenal sebagai JavaScript 2015). « Mesin epsilon»Memberikan margin kesalahan yang wajar saat membandingkan dua angka floating point. Tanpa pembulatan, perbandingan dapat menghasilkan hasil yang serupa dengan berikut ini:
0,1 + 0,2 \u003d\u003d\u003d 0,3\u003e salah
Matematika.EPSILON dapat digunakan dalam suatu fungsi untuk mendapatkan perbandingan yang benar:
function epsEqu (x, y) (return Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Fungsi tersebut membutuhkan dua argumen: satu berisi perhitungan, yang kedua adalah hasil yang diharapkan (dibulatkan). Ini mengembalikan perbandingan dari dua parameter ini:
epsEqu (0.1 + 0.2, 0.3)\u003e true
Semua browser modern mendukung fungsi matematika ES6. Tetapi jika Anda perlu memberikan dukungan di browser lama, maka Anda perlu menggunakan polyfills.
Memotong angka desimal
Semua metode yang disajikan sebelumnya berfungsi Pembulatan JavaScript ke persepuluhan... Untuk memotong bilangan positif menjadi dua tempat desimal, mengalikannya dengan 100, memotongnya lagi, lalu membagi hasilnya dengan 100, Anda memerlukan:
function truncated (num) (return Math.trunc (num * 100) / 100;) truncated (3,1416)\u003e 3,14
Jika Anda membutuhkan sesuatu yang lebih fleksibel, Anda dapat menggunakan operator bitwise:
function terpotong (num, decimalPlaces) (var numPowerConverter \u003d Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Menggunakan:
var randInt \u003d 35.874993; terpotong (randInt, 3); \u003e 35,874
Membulatkan ke angka terdekat
Untuk melaksanakan Pembulatan JavaScript ke integer, digunakan oleh Math.round ():
Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 5
Perhatikan bahwa " setengah nilai“Seperti 0,5 dibulatkan.
Bulatkan ke bawah ke bilangan bulat terdekat
Jika Anda ingin membulatkan ke bawah, gunakan metode Math.floor ():
Math.floor (42.23); \u003e 42 Math.floor (36,93); \u003e 36
Pembulatan ke bawah memiliki satu arah untuk semua angka, termasuk angka negatif. Ini dapat dibayangkan sebagai gedung pencakar langit dengan jumlah lantai yang tak terbatas, termasuk di bawah tingkat pondasi ( mewakili angka negatif). Jika Anda berada di lift antara lantai basement 2 dan 3 ( yang sesuai dengan nilai -2,5), Math.floor akan membawa Anda ke lantai -3:
Math.floor (-2.5); \u003e -3
Jika Anda perlu menghindari ini, gunakan JavaScript Math rounding dengan Math.trunc (), yang didukung di semua browser modern (kecuali IE / Edge):
Math.trunc (-41.43); \u003e -41
MDN juga menyediakan polyfill 3 baris untuk memberikan dukungan Math.trunc di browser lama dan IE / Edge.
Bulatkan ke bilangan bulat terdekat
Jika Anda ingin mengumpulkan angka desimal, gunakan Math.ceil. Metode ini juga dapat dianggap sebagai lift tanpa akhir: Math.ceil selalu membuat Anda naik, terlepas dari apakah angkanya negatif atau positif:
Math.ceil (42.23); \u003e 43 Math.ceil (36,93); \u003e 37 Math.ceil (-36,93); -36
Bulatkan ke kelipatan terdekat
Jika Anda perlu membulatkan nilai ke kelipatan 5 terdekat, buat fungsi yang membagi angka dengan 5, membulatkannya, lalu mengalikan hasilnya dengan nilai yang sama:
function roundTo5 (num) (return Math.round (num / 5) * 5;)
Menggunakan:
roundTo5 (11); \u003e 10
Jika Anda membutuhkan JavaScript untuk membulatkan menjadi dua digit, Anda dapat meneruskan seed dan multiplisitas ke fungsi:
function roundToMultiple (num, multiple) (return Math.round (num / multiple) * multiple;)
Untuk menggunakan fungsi ini, sertakan angka yang akan dibulatkan dan multiplisitas dalam panggilannya:
var initialNumber \u003d 11; var kelipatan \u003d 10; roundToMultiple (initialNumber, multiple); \u003e 10;
Untuk membulatkan nilai hanya ke atas atau ke bawah, ganti round dengan langit-langit atau lantai dalam fungsinya.
Rentang Snap
Terkadang Anda perlu mendapatkan nilai x, yang harus berada dalam kisaran tertentu. Misalnya, kita membutuhkan nilai antara 1 dan 100, tetapi kita mendapatkan nilai 123. Untuk mengatasinya bisa menggunakan min () ( mengembalikan angka terkecil) dan maks ( mengembalikan jumlah maksimum yang diperbolehkan).
Menggunakan:
var lowBound \u003d 1; var highBound \u003d 100; var numInput \u003d 123; var dijepit \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (dijepit); \u003e 100;
Anda dapat membuat fungsi atau ekstensi dari kelas Angka.
Itu Math.round () fungsi mengembalikan nilai angka yang dibulatkan ke bilangan bulat terdekat.
Sumber untuk contoh interaktif ini disimpan di repositori GitHub. Jika Anda ingin berkontribusi pada proyek contoh interaktif, harap klon https://github.com/mdn/interactive-examples dan kirimkan permintaan tarik kepada kami.
Sintaksis
Math.round (x)Parameter
x Angka.Nilai kembali
Nilai bilangan yang diberikan dibulatkan ke bilangan bulat terdekat.
Deskripsi
Jika bagian pecahan dari argumen lebih besar dari 0,5, argumen dibulatkan ke bilangan bulat dengan nilai absolut berikutnya yang lebih tinggi. Jika kurang dari 0,5, argumen dibulatkan ke bilangan bulat dengan nilai absolut yang lebih rendah. Jika bagian pecahan tepat 0,5, argumen dibulatkan ke bilangan bulat berikutnya ke arah + ∞. Perhatikan bahwa ini berbeda dari banyak bahasa "round () fungsi, yang sering membulatkan kasus ini ke integer berikutnya jauh dari nol , alih-alih memberikan hasil yang berbeda dalam kasus bilangan negatif dengan bagian pecahan tepat 0,5.
Karena round () adalah metode statis Matematika, Anda selalu menggunakannya sebagai Math.round (), bukan sebagai metode objek Matematika yang Anda buat (Matematika tidak memiliki konstruktor).
Contoh
Math.round (20,49); // 20 Math.round (20.5); // 21 Math.round (42); // 42 Math.round (-20.5); // -20 Math.round (-20.51); // -21Implementasi Demonstratif
Di bawah ini adalah potongan kode yang secara fungsional setara dengan math.round kecuali potongan kode di bawah ini lebih lambat dari Math.round. Tujuan dari potongan kode di bawah ini adalah untuk mendemonstrasikan cara kerja Math.round.
Fungsi vanilla_round (x) (var y \u003d Math.abs (x) + 0.5; // sehingga kurang dari 1/2 pembulatan ke bawah; pembulatan yang lebih besar ke atas mengembalikan Math.floor (x + 0.5))
Operator modulus di atas mendapatkan bagian desimal dari x. Selanjutnya, potongan kode di atas dapat dimodifikasi untuk membulatkan ke presisi tertentu pada angka:
Fungsi round_to_precision (x, precision) (var y \u003d + x + (precision \u003d\u003d\u003d undefined? 0,5: precision / 2); return y - (y% (precision \u003d\u003d\u003d undefined? 1: + precision));)
Round_to_precision (11, 2); // keluaran 12 round_to_precision (11, 3); // mengeluarkan 12 round_to_precision (11, 4); // mengeluarkan 12 round_to_precision (11, 5); // keluaran 10 round_to_precision (11, 6); // keluaran 12 round_to_precision (11, 7); // mengeluarkan 14 round_to_precision (11, 8); // keluaran 8 round_to_precision (3.7, 0.5); // keluaran 3.5 round_to_precision (3.75, 0.5); // keluaran 4 round_to_precision (3.8, 0.5); // keluaran 4
Spesifikasi
| Spesifikasi | Status | Komentar |
|---|---|---|
| ECMAScript Edisi Pertama (ECMA-262) | Standar | Definisi awal. Diimplementasikan di JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) |
Standar | |
| ECMAScript 2015 (Edisi 6, ECMA-262) Definisi "Math.round" dalam spesifikasi itu. |
Standar | |
| ECMAScript Draft Terbaru (ECMA-262) Definisi "Math.round" dalam spesifikasi itu. |
Minuman |
Kompatibilitas browser
Tabel kompatibilitas di halaman ini dihasilkan dari data terstruktur. Jika Anda ingin berkontribusi pada data, silakan lihat https://github.com/mdn/browser-compat-data dan kirimkan permintaan pull kepada kami.
Perbarui data kompatibilitas di GitHub
| Desktop | Seluler | Server | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Chrome | Tepi | Firefox | Internet Explorer | Opera | Safari | Tampilan web Android | Chrome untuk Android | Firefox untuk Android | Opera untuk Android | Safari di iOS | Samsung Internet | Node.js | |
| bulat | Dukungan Penuh Chrome 1 | Edge Dukungan penuh 12 | Dukungan penuh Firefox 1 | Dukungan penuh IE 3 | Dukungan penuh Opera Ya | Safari Dukungan penuh Ya | Dukungan penuh Android WebView 1 | Dukungan Penuh Chrome Android 18 | Dukungan penuh Firefox Android 4 | Dukungan penuh Opera Android Ya | Safari iOS Dukungan penuh Ya | Dukungan penuh Samsung Internet Android 1.0 | nodejs Dukungan penuh Ya |
Sekarang mari kita lihat metode lantai (diterjemahkan sebagai gender)yang bekerja kebalikan dari metode ceil, yaitu Apakah dia membulatkan ke bawah angka pecahan.
Seperti yang Anda lihat, metode lantai dibulatkan 35,97 ke bawah menjadi 35, yang mengarah ke bawah. Meskipun 0,97 lebih besar dari 0,5 (cm.).
Pelajaran ini mencakup metode objek Matematika, memungkinkan bilangan desimal pecahan untuk dibulatkan.
Sekarang Anda perlu mengerjakan pekerjaan rumah Anda.
Tugas Anda adalah menulis fungsi yang membutuhkan dua parameter.
1. Sebuah array yang terdiri dari angka-angka dengan pecahan.
2. Metode pembulatan "bulat", "plafon" atau "lantai".
Pada keluaran, fungsi harus mengeluarkan larik yang sama, tetapi semua elemen larik harus dibulatkan menggunakan objek Matematika yang ditentukan di parameter kedua dari metode ini.
Array sumber:
var numberArray \u003d;
Pada awalnya, solusi untuk masalah ini mungkin tampak hampir sama dengan solusi untuk masalah rumah tangga dalam tiga pelajaran pertama topik ini. Tapi tidak semuanya sesederhana itu ...
Solusi # 1 - Perhatian
Berdasarkan kondisi masalahnya fungsi tersebut harus mengambil dua parameter - array asli dan salah satu metode: "round", "ceil" atau "floor". Berdasarkan ini, saya mencoba melakukannya...
Dalam solusi ini, kami membuat fungsi dengan dua parameter, dan ketika kami memanggilnya, kami mencoba untuk menentukan array asli dan NAMA salah satu metode sebagai parameter fungsi:
desimal (numberArray, round) - dalam hal ini round.
Tapi kami tidak akan mendapatkan hasilnya, karena JANGAN menentukan metode NAME sebagai parameter fungsi.
Perhatikan: bukan kebetulan bahwa nama metode "round", "ceil" dan "floor" dalam pernyataan masalah diapit tanda kutip.
desimal (numberArray, "round") - tetapi ini juga tidak akan benar !!!
Solusi # 2 - Perbaiki solusi sebelumnya
Anda dapat menyelesaikan masalah dengan menentukan satu parameter untuk fungsi tersebut.
35 - Elemen bulat
13 - Elemen bulat
17 - Elemen bulat
79 - Elemen bulat
Di sini kami berhasil mencapai hasil yang diinginkan: metode putaran membulatkan semua angka. Tapi kondisi tidak terpenuhikarena fungsinya hanya membutuhkan satu parameter.
Solusi # 3 - Fungsi dengan dua parameter
Di sini masalahnya diselesaikan dengan benar. Untuk melakukan ini, Anda harus mengingat topik kondisi di javascript dan menerapkan beberapa ketentuan pada saat yang bersamaan.
34,82 - elemen asli dari array
35 - pembulatan
12.9 - elemen asli dari larik
13 - pembulatan
17.01 - elemen asli dari array
18 - pembulatan
78.51 - elemen asli dari larik
79 - pembulatan
saya t keputusan yang tepat Pekerjaan rumah. Di sini, untuk fungsinya, dua parameter ditentukan sesuai dengan kondisinya.
Coba baris terakhir dari solusi ini:
desimal (numberArray, "ceil") sebagai parameter kedua dari fungsi tersebut, tentukan nama metode lain "round" dan "floor" dari objek Math.
Solusi # 4 - Fungsi dengan dua parameter + metode prompt
Saya memutuskan untuk sedikit mengoptimalkan solusi sebelumnya dan menambahkan metode prompt yang memanggil jendela modal yang berisi bidang untuk memasukkan informasi.
Sekarang, berkat ini, dimungkinkan untuk memasukkan nama salah satu metode putaran, lantai atau langit-langit di bidang input dan mendapatkan hasil yang sesuai.
Beginilah cara kerja metode bulat, lantai, atau langit-langit benda Matematika, yang membulatkan bilangan pecahan.
