Pada artikel ini, kita akan melihat lebih dekat angka, operator matematika, cara mengubah angka menjadi string dan sebaliknya, serta banyak poin penting lainnya.

fungsi isFinite

Fungsi isFinite memungkinkan Anda untuk memeriksa apakah suatu argumen adalah angka yang terbatas.

Sebagai jawaban fungsi yang diberikan mengembalikan false jika argumennya adalah Infinity , -Infinity , NaN , atau akan dilemparkan ke salah satu nilai numerik khusus ini. Jika tidak, fungsi ini akan mengembalikan true .

IsFinite(73); // benar isFinite(-1/0); // false isFinite(Tak terhingga); // false isFinite(NaN); // false isFinite("Teks"); // PALSU

Selain fungsi global isFinite, JavaScript juga memiliki metode Number.isFinite. Itu, tidak seperti isFinite, tidak memaksa argumen untuk dikonversi menjadi angka.

IsFinite("73"); // bilangan asli.isFinite("73"); // PALSU

fungsi isNaN

Fungsi isNaN adalah untuk menentukan apakah suatu argumen adalah angka atau dapat dikonversi menjadi satu. Jika demikian, maka fungsi isNaN mengembalikan false. Kalau tidak, itu mengembalikan benar.

IsNaN(NaN); //true isNaN("25px"); //benar, karena 20px bukan angka isNaN(25.5); //salah isNaN("25.5"); //salah isNaN(" "); //salah, karena spasi atau banyak spasi dikonversi menjadi 0 isNaN(null); //salah, karena nilai null diubah menjadi 0 isNaN(true); //salah, karena true diubah menjadi 1 isNaN(false); //salah, karena nilai salah diubah menjadi 0

Jika tindakan ini perlu dilakukan tanpa pemeran tipe, maka gunakan metode Number.isNaN. Metode ini telah diperkenalkan ke dalam bahasa sejak ECMAScript 6.

Bagaimana cara mengonversi string menjadi angka secara eksplisit?

Anda dapat secara eksplisit mentransmisikan string ke nomor menggunakan metode berikut:

1. Gunakan operator unary + The untuk ditempatkan sebelum nilai.

+"7.35"; // 7.35 +"teks"; // NaN

Metode ini mengabaikan spasi di awal dan akhir baris, serta \n (umpan baris).

+"7.35"; //7.35 +"7.35\n"; //7.35

Menggunakan cara ini perhatikan bahwa string kosong atau string yang terdiri dari spasi dan \n diubah menjadi angka 0. Selain itu, ini juga mengubah tipe data null dan boolean menjadi angka.

Batal; //0 +benar; //1 +salah; //0 +" "; //0

2. Fungsi parseInt . Fungsi ini dirancang untuk mengkonversi argumen ke bilangan bulat. Berbeda dengan menggunakan operator unary +, metode ini memungkinkan Anda mengubah string menjadi angka, di mana tidak semua karakter adalah numerik. Itu mulai mengubah string, mulai dari karakter pertama. Dan segera setelah menemukan karakter yang bukan karakter numerik, fungsi ini berhenti bekerja dan mengembalikan angka yang dihasilkan.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Fungsi ini dapat bekerja dengan sistem yang berbeda penomoran (biner, oktal, desimal, heksadesimal). Indikasi basis sistem bilangan dilakukan dengan 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 ke JavaScript dengan spesifikasi ECMASCRIPT 2015(6).

3. Fungsi parseFloat . Fungsi parseFloat mirip dengan parseInt , kecuali fungsi ini memungkinkan Anda mengonversi argumen menjadi bilangan pecahan.

ParseFloat("33,3%"); //33.3

Selain itu, fungsi parseFloat, tidak seperti parseInt, tidak memiliki 2 argumen, dan karena itu selalu mencoba memperlakukan 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 ke JavaScript dengan spesifikasi ECMASCRIPT 2015(6).

Mengkonversi angka ke string

Anda dapat mengubah angka menjadi string menggunakan metode toString.

(12.8).toString(); //"12,8"

Metode toString juga memungkinkan Anda untuk menentukan basis sistem angka, dengan mempertimbangkan bahwa Anda harus secara eksplisit memasukkan angka ke string:

(255).toString(16); //"ff"

Cara memeriksa apakah suatu variabel adalah angka

Anda dapat menentukan apakah nilai suatu 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 dilemparkan ke sana );

Sebagai fungsi:

// fungsi function isNumeric(nilai) ( ​​return !isNaN(parseFloat(nilai)) && isFinite(parseFloat(nilai)); ) // penggunaan var myVar = "12px"; console.log(isNumeric(myVar)); //BENAR

Metode ini memungkinkan Anda untuk menentukan apakah nilai yang ditentukan adalah angka atau dapat dikonversi menjadi angka. Varian ini tidak menghitung string kosong, string spasi, null , Infinity , -Infinity , true dan false sebagai angka.

2. Menggunakan jenis operator dan fungsi isFinite, isNaN:

// fungsi yang memeriksa apakah nilainya adalah angka function isNumber(value) ( ​​​​return typeof value === "angka" && 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 bertipe Number, dan juga apakah itu milik salah satu dari nilai-nilai khusus Infinity, -Infinity dan NaN. Jika demikian, maka fungsi ini mengembalikan nilai true.

3. Menggunakan metode ECMAScript 6 Number.isInteger(value). Metode ini memungkinkan Anda untuk menentukan apakah nilai yang ditentukan adalah bilangan bulat.

Bilangan.isInteger("20"); //salah, karena metode ini tidak menerjemahkan string menjadi angka Number.isInteger(20); //benar, karena nilai yang diberikan adalah nomor

Angka genap dan ganjil

Anda dapat memeriksa apakah suatu angka genap atau ganjil fungsi berikut:

// Fungsi untuk memeriksa apakah suatu bilangan genap function isEven(n) ( return n % 2 == 0; ) // Fungsi untuk memeriksa apakah suatu bilangan ganjil function isOdd(n) ( return Math.abs(n % 2) == 1; )

Tetapi sebelum melakukan pemeriksaan seperti itu, disarankan untuk memastikan bahwa nilai yang ditentukan adalah angka:

nilai=20; if (Bilangan.isInteger(nilai)) ( if (isEven(nilai)) ( console.log("Nomor " + nilai.toString() + " - genap"); ) )

Bilangan Prima dalam Javascript

Pertimbangkan contoh di mana kami menampilkan bilangan prima dari 2 hingga 100 menggunakan Javascript.

// Fungsi yang memeriksa apakah suatu bilangan prima function 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 bilangan bulat dalam JavaScript.

1. Menggunakan metode Math.floor , Math.ceil dan Math.round yang dirancang khusus untuk ini. Metode Math.floor membulatkan bilangan pecahan ke bilangan bulat terdekat, yaitu hanya membuang bagian pecahan. Math.ceil membulatkan bilangan pecahan ke bilangan bulat terdekat. Math.round membulatkan angka ke atas atau ke bawah tergantung pada nilai bagian pecahan. Jika bagian pecahan lebih besar dari atau sama dengan 0,5, maka ke atas, jika tidak, gulir 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 dari angka ke presisi yang ditentukan. Hasil pembulatan dikembalikan sebagai string.

Console.log(7.987.toFixed(2)); //"7.99"

Jika tidak ada tempat desimal yang cukup untuk membentuk keakuratan angka yang ditentukan, maka angka tersebut diisi dengan nol.

Console.log(7.987.toFixed(5)); //"7.98700"

3. Melalui metode toPrecision(presisi). Metode ini mewakili angka dengan presisi yang ditentukan. Pada saat yang sama, dia tidak hanya dapat membulatkan pecahan, tetapi juga seluruh bagian dari angka tersebut. Angka yang dihasilkan dapat direpresentasikan dengan metode ini bergantung pada hasil dalam 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 NOT atau OR yang logis.

//melalui negasi logis ganda console.log(~~7.9); //7 // dengan menggunakan logika ATAU dengan nol: console.log(7.9^0); //7

Bagian bilangan bulat dan pecahan dari suatu bilangan

Anda bisa mendapatkan bagian integer 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 angka menggunakan operator persentase (%). Operator ini mengembalikan sisa yang diperoleh dari membagi angka pertama dengan angka kedua. Dalam hal ini, 1 harus digunakan sebagai angka ke-2.

Konsol.log(7,21%1); // 0,209999999999999996 // akurat hingga 2 angka desimal console.log((7,21%1).toFixed(2)); // "0,21"

Selain itu, bagian pecahan juga dapat diperoleh dengan menggunakan perhitungan:

var nomor = 7.21; var pecahanBilangan = bilangan - Math.floor(Math.abs(angka)); console.log(fractionNumber); // 0,20999999999999996

Apakah bilangan tersebut habis dibagi

Anda dapat menentukan apakah suatu angka habis dibagi menggunakan operator persentase:

varnumber = 9; // jika sisa pembagian angka dengan 3 adalah 0, maka ya, sebaliknya tidak if (angka%3==0) ( console.log ("Angka " + angka + " habis dibagi 3"); ) else ( console.log("Bilangan " + angka + " tidak habis dibagi 3"); )

Pemformatan Angka

Dalam JavaScript, metode toLocaleString() memungkinkan Anda memformat keluaran angka menurut lokal (pengaturan bahasa sistem operasi).

Misalnya, mari memformat angka sesuai dengan standar regional yang dipasang di sistem secara default:

jumlah var = 345,46; console.log(angka.toLocaleString()); //"345,46"

Misalnya, format angka 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",(gaya:"mata uang", mata uang:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(gaya:"mata uang", mata uang:"USD"))); //"$89.30" console.log((2301.99).toLocaleString("ru-RU",(gaya:"mata uang", mata uang:"EUR"))); //"€2.301,99"

Mewakili angka sebagai persentase:

Console.log((0.45).toLocaleString("ru-RU",(gaya:"persen"))); //"45%"

Pisahkan angka menjadi digit (gunakan properti Grouping):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125 452,32"

Cetak angka dengan jumlah digit tertentu (2) setelah titik desimal:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1240.46"

Perbandingan Angka

Operator berikut digunakan untuk membandingkan angka dalam JavaScript: == (sama dengan), != (tidak sama dengan), > (lebih besar dari),< (меньше), >= (lebih besar dari atau sama dengan),<= (меньше или равно).

Misalnya, mari kita bandingkan dua angka:

Konsol.log(2>3); //false console.log(5>=3); //BENAR

Saat membandingkan angka dengan bagian pecahan, perlu memperhitungkan kesalahan yang mungkin terjadi selama perhitungan ini.

Misalnya, dalam JavaScript, jumlah angka (0,2 + 0,4) tidak sama dengan 0,6:

Konsol.log((0,2+0,4)==0,6); //PALSU

Kesalahan terjadi karena semua perhitungan adalah komputer atau lainnya peralatan elektronik menghasilkan sistem 2 bilangan. Itu. sebelum melakukan tindakan apa pun, komputer harus terlebih dahulu mengubah angka yang disajikan dalam ekspresi menjadi sistem 2 angka. Namun, tidak ada bilangan desimal pecahan yang dapat direpresentasikan secara tepat dalam sistem bilangan ke-2.

Misalnya, angka 0,25 10 diubah menjadi biner dengan tepat.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Misalnya, angka 0,2 10 dapat diubah menjadi sistem 2 hanya dengan akurasi tertentu:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2

Akibatnya, kesalahan tersebut akan mempengaruhi perhitungan penjumlahan dua bilangan dan hasil perbandingannya. Itu. ternyata sebenarnya JavaScript akan melihat entri ini sebagai berikut:

0.6000000000000001==0.6

Saat menghitung atau menampilkan angka dengan bagian pecahan, Anda harus selalu menentukan ketepatan yang harus dilakukan.

Misalnya, bandingkan angka hingga 2 angka desimal menggunakan metode toFixed() dan toPrecision() :

//metode toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //benar //toPrecision() metode console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //BENAR

Operasi matematika dasar

JavaScript memiliki operator matematika berikut: + (penjumlahan), - (pengurangan), * (perkalian), / (pembagian), % (sisa pembagian), ++ (nilai bertambah 1), -- (nilai dikurangi 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, mis. 6:3=2 => 6-3*2 => sisa(0) 5%2 //1, mis. 5:2=2(.5) => 5-2*2 => sisa(1) 7,3%2 //1,3, mis. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //tanda hasil operasi % sama dengan tanda nilai pertama -9%2.5 //-1.5, mis. 9:2.5=3(.6) => 9-2.5*3 => istirahat(1.5) -9%-2.5 //-1.5, mis. 9:2.5=3(.6) => 9-2.5*3 => sisa(1.5) -2%5 //-2, mis. 2:5=0(.4) => 2-5*0 => sisa(2) x = 3; log konsol (x++); //menampilkan 3, lalu menyetel y ke 4 console.log(x); //4 x = 3; log konsol(++x); //set 4 dan keluaran x = 5; log konsol (x--); //keluaran 5, y kemudian menyetel 4 console.log(x); //4 x = 5; log konsol(--x); //set ke 4 dan keluaran Selain itu, ada operator gabungan dalam JavaScript: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x=3; y=6; x+=y; log konsol (x); //9 x = 3; y=6; x-=y; log konsol (x); //-3 x = 3; y=6; x*=y; log konsol (x); //18 x = 3; y=6; x/=y; log konsol (x); //0,5 x = 3; y=6; x%=y; log konsol (x); //3

Halo. Hari ini di kolom tentang Javascript kita akan melihat bagaimana mengatur jumlah tempat desimal dalam angka floating point di javascript. Misalnya, Anda harus meninggalkan 3 tempat desimal saat mengeluarkan, atau hanya dua.

Tugas: jumlah tempat desimal javascript

Nah, kita dihadapkan pada tugas: ada hasil perhitungan yang di dalamnya terdapat angka sebelum koma desimal dan setelah koma desimal. Desimal. Katakanlah hasilnya seperti ini 1538.9891200153. Tetapi ketika Anda keluar, Anda harus mendapatkan angka yang mencerminkan jumlah, di mana sebelum titik desimal adalah jumlah uang kertas, dan setelah - kopeck.

Ada beberapa cara untuk mengatasi masalah ini.

Solusi 1: jumlah tempat desimal javascript dengan metode toFixed

toFixed adalah metode bawaan javascript yang diterapkan ke angka apa pun, dibutuhkan presisi pembulatan (yaitu, jumlah tempat desimal) sebagai parameter.

Varnum=1538.9891200153; num_str=num.toFixed(); //num_str=1538; num_str=num.toFixed(2); //num_str=1538.98; num_str=num.toFixed(5); //num_str=1538.98912;

Parameter presisi dalam fungsi ini minimal harus 0 (tidak mengambil nilai negatif), dan maksimal 20.

Anda juga dapat melakukannya tanpa variabel, seperti ini:

Num_str=(1538.9891200153).toFixed(2); //num_str=1538.98;

Solusi 2: jumlah tempat desimal javascript dengan metode toPrecision

Solusi ini didasarkan pada built-in yang sama metode javascript. Ciri khas dari metode ini adalah bahwa parameter yang diambil sebagai input tidak menunjukkan keakuratan (jumlah tempat desimal), tetapi jumlah total karakter (baik sebelum dan sesudah titik desimal).

Varnum=1538.9891200153; num_str=num.toPrecision(5); //num_str=1538.9; num_str=num.toPrecision(7); //num_str=1538.989;

Solusi tanpa tempat desimal: jumlah tempat desimal javascript

Jika tempat desimal harus dibuang seluruhnya, yaitu Anda perlu membulatkan bilangan pecahan menjadi bilangan bulat, maka Anda dapat menggunakan fungsi kelas Matematika: bulat, langit-langit, dan lantai.
Putaran - putaran ke atas atau ke bawah (tergantung nomornya). Jika nilai setelah titik desimal lebih dari setengah, maka akan dibulatkan ke atas, jika lebih kecil akan dibulatkan ke bawah. Artinya, jika 0,51 - akan menjadi 1, jika 0,49 - 0.

Ceil - dari bahasa Inggris. langit-langit selalu membulat.

Lantai - dari bahasa Inggris. Jenis kelamin selalu dibulatkan ke bawah.

Varnum = 1538.9891200153; num_str=math.round(bil); //num_str=1539; num_str=Math.floor(bil); //num_str=1538; num_str=Matematika.ceil(bil); //num_str=1539;

Itu saja. Saya harap catatan ini membantu Anda memecahkan masalah Anda. Jika ada yang tidak berhasil, ajukan pertanyaan menggunakan tombol hijau "Ajukan pertanyaan ke spesialis", atau di komentar.

Sangat sering, 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 angka desimal tertentu, semuanya tergantung pada apa yang ingin Anda lakukan dengan angka ini di masa mendatang.

Mengapa pembulatan diperlukan?

Salah satu aspek menarik dari JavaScript adalah ia tidak benar-benar menyimpan bilangan bulat, kami langsung bekerja dengan angka floating point. Ini, dikombinasikan dengan fakta bahwa banyak nilai pecahan tidak dapat dinyatakan dengan jumlah desimal yang terbatas, 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, dalam kasus kami, kami berbicara tentang kesalahan dalam triliun saham, namun, ini mungkin mengecewakan seseorang. Kami juga bisa mendapatkan hasil yang aneh saat bekerja dengan angka yang mewakili mata uang, persentase, atau ukuran file. Untuk memperbaiki ketidakakuratan ini, kita hanya perlu membulatkan hasil, dan cukup mengatur presisi desimal.

Pembulatan angka memiliki kegunaan praktis, kita dapat memanipulasi angka dalam beberapa rentang, misalnya ingin membulatkan nilai ke bilangan bulat terdekat daripada hanya bekerja dengan bagian desimal.

Pembulatan desimal

Untuk memangkas angka desimal, gunakan metode toFixed atau toPrecision. Keduanya mengambil satu argumen, yang menentukan, masing-masing, berapa banyak digit signifikan (yaitu jumlah digit yang digunakan dalam angka) atau tempat desimal (angka setelah titik desimal) hasilnya harus mencakup:

1. Jika argumen tidak ditentukan untuk toFixed(), maka defaultnya adalah nol, yang berarti 0 tempat desimal, argumen memiliki nilai maksimum 20.
2. Jika tidak ada argumen yang diberikan kepada toPrecision, nomor tersebut dibiarkan tidak tersentuh

biarkan randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87,335; randNum.toFixed(2); > "87,33" randNum = 87,337; randNum.toPrecision(3); > "87.3"
Baik metode toFixed() dan toPrecision() mengembalikan representasi string dari hasil, bukan angka. Ini berarti bahwa saat menjumlahkan nilai yang dibulatkan dengan randNum , string akan digabungkan, bukan angka yang ditambahkan:

Biarkan randNum = 6,25; biarkan dibulatkan = randNum.toFixed(); // "6" console.log(randNum + dibulatkan); > "6.256"
Jika Anda ingin hasilnya berupa tipe data numerik, maka Anda harus menggunakan parseFloat:

Biarkan randNum = 6,25; biarkan dibulatkan = parseFloat(randNum.toFixed(1)); log konsol (dibulatkan); > 6.3
Perhatikan bahwa 5 nilai dibulatkan kecuali dalam kasus yang jarang terjadi.

Metode toFixed() dan toPrecision() berguna, karena tidak hanya dapat memotong bagian pecahan, tetapi juga mengisi tempat desimal, yang berguna saat bekerja dengan mata uang:

Biarkan wholeNum = 1 biarkan dolarCents = wholeNum.toFixed(2); console.log(dolarCents); > "1,00"
Perhatikan bahwa toPrecision akan mengembalikan hasil dalam notasi eksponensial jika jumlah bilangan bulat lebih besar dari presisi itu sendiri:

Misalkan num = 123.435 num.toPrecision(2); > "1.2e+2"

Cara Menghindari Kesalahan Pembulatan dengan Desimal

Dalam beberapa kasus, toFixed dan toPrecision akan membulatkan nilai 5 ke bawah dan ke atas:

Biarkan numTest = 1,005; numTest.toFixed(2); > "1,00"
Hasil perhitungan di atas seharusnya 1,01, bukan 1. Jika Anda ingin menghindari kesalahan semacam ini, kita dapat menggunakan solusi yang disarankan oleh Jack L Moore, yang menggunakan bilangan eksponensial untuk perhitungannya:

Putaran fungsi(nilai, desimal) ( kembali Angka(Matematika.bulat(nilai+"e"+desimal)+"e-"+desimal); )
Sekarang:

Bulat(1.005,2); > 1,01
Jika Anda menginginkan solusi yang lebih kuat daripada yang ditunjukkan di atas, Anda dapat membuka MDN.

Pembulatan epsilon mesin

Metode alternatif untuk membulatkan angka desimal diperkenalkan di ES6. Pembulatan epsilon mesin 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 === 0,3 > salah
Kami menggunakan Math.EPSILON dalam fungsi kami untuk mendapatkan perbandingan yang benar:

Fungsi epsEqu(x, y) ( kembali Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Fungsi mengambil dua argumen: yang pertama adalah perhitungan saat ini, yang kedua adalah hasil yang diharapkan. Ini mengembalikan perbandingan keduanya:

EpsEqu(0,1 + 0,2, 0,3) > benar
Semua browser modern sudah mendukung fungsi matematika ES6, tetapi jika Anda menginginkan dukungan di browser seperti IE 11 gunakan polyfills .

Kliping pecahan

Semua metode yang disajikan di atas dapat dibulatkan ke angka desimal. Untuk memotong angka menjadi dua tempat desimal, pertama-tama Anda harus mengalikannya dengan 100, lalu membagi hasilnya dengan 100:

Fungsi terpotong(num) ( return Math.trunc(num * 100) / 100; ) terpotong(3.1416) > 3.14
Jika Anda ingin mengadaptasi metode ini ke sejumlah tempat desimal, Anda dapat menggunakan negasi ganda bitwise:

Fungsi terpotong(num, decimalPlaces) ( biarkan numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Sekarang:

Misalkan randInt = 35.874993; terpotong(randInt,3); > 35.874

Pembulatan ke bilangan terdekat

Untuk membulatkan angka desimal ke atas atau ke bawah ke angka terdekat, tergantung angka terdekat kita, gunakan Math.round():

Matematika.bulat(4.3) > 4 Matematika.bulat(4.5) > 5
Perhatikan bahwa "setengah nilainya", 0,5 dibulatkan oleh aturan matematika.

Pembulatan ke bawah ke bilangan bulat terdekat

Jika Anda ingin selalu membulatkan ke bawah, gunakan Math.floor:

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Perhatikan bahwa pembulatan ke bawah berfungsi untuk semua angka, termasuk angka negatif. Bayangkan sebuah gedung pencakar langit dengan jumlah lantai yang tak terbatas, termasuk lantai yang lebih rendah (mewakili angka negatif). Jika Anda berada di lift di tingkat paling bawah antara 2 dan 3 (yang bernilai -2,5), Math.floor akan membawa Anda ke -3:

Math.floor(-2.5); > -3
Tetapi jika Anda ingin menghindari situasi seperti ini, gunakan Math.trunc , yang didukung di semua browser modern (kecuali IE/Edge):

Math.trunc(-41.43); > -41
Di MDN Anda akan menemukan polyfill yang akan memberikan dukungan untuk Math.trunc di browser dan IE/Edge.

Pembulatan ke bilangan bulat terdekat

Di sisi lain, jika Anda harus selalu membulatkan, gunakan Math.ceil. Sekali lagi, mengingat lift tak terbatas: Math.ceil akan selalu "naik", apakah angkanya negatif atau tidak:

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); > -36

Bulatkan ke atas/bawah sesuai kebutuhan

Jika kita ingin membulatkan ke kelipatan 5 terdekat, cara termudah adalah membuat fungsi yang membagi angka dengan 5, membulatkannya, lalu mengalikannya dengan jumlah yang sama:

Fungsi roundTo5(num) ( return Math.round(num/5)*5; )
Sekarang:

RoundTo5(11); > 10
Jika Anda ingin membulatkan ke kelipatan nilai Anda, kami menggunakan fungsi yang lebih umum, meneruskan nilai awal dan kelipatan:

Fungsi roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Sekarang:

Misalkan bilangan awal = 11; biarkan kelipatan = 10; roundToMultiple(initialNumber, multiple); > 10;

Memperbaiki angka dalam rentang

Ada banyak kasus dimana kita ingin mendapatkan nilai x yang berada dalam range. Misalnya, kita mungkin menginginkan nilai dari 1 sampai 100, tetapi kita berakhir dengan nilai 123. Untuk memperbaikinya, kita dapat menggunakan min (mengembalikan yang terkecil dari kumpulan angka) dan max (mengembalikan yang terbesar dari kumpulan apa pun). dari angka). Dalam contoh kami, rentangnya adalah dari 1 hingga 100:

Biarkan lowBound = 1; biarkan highBound = 100; biarkan numInput = 123; biarkan dijepit = Math.max(lowBound, Math.min(numInput, highBound)); log konsol (dijepit); > 100;
Sekali lagi, kita dapat menggunakan kembali operasi dan membungkusnya dalam sebuah fungsi, menggunakan solusi yang disarankan oleh Daniel X. Moore :

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Sekarang:

NumInput.clamp(Batas Rendah, Batas Tinggi); > 100;

Pembulatan Gauss

Pembulatan Gaussian, juga dikenal sebagai pembulatan bankir, adalah pembulatan untuk kasus ini ke bilangan genap terdekat. Metode pembulatan ini bekerja tanpa kesalahan statistik. Keputusan terbaik itu disarankan oleh Tim Down:

Fungsi gaussRound(bil, Tempat desimal) ( misalkan d = Tempat desimal || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 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) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Titik desimal dalam CSS:

Karena JavaScript sering digunakan untuk membuat transformasi posisi untuk elemen HTML, Anda mungkin bertanya-tanya apa yang terjadi jika kami menghasilkan nilai desimal untuk elemen kami:

#kotak ( lebar: 63.667731993px; )
Kabar baiknya adalah browser modern akan menghargai nilai desimal dalam model kotak, termasuk satuan persentase atau piksel.

Penyortiran

Sangat sering kita perlu mengurutkan beberapa elemen, misalnya, kita memiliki array catatan permainan, sedangkan mereka harus diatur dalam urutan peringkat pemain. Sayangnya, metode sort() standar memiliki beberapa keterbatasan yang mengejutkan: metode ini bekerja dengan baik dengan kata-kata bahasa Inggris yang umum, tetapi langsung rusak saat bertemu dengan angka, karakter unik, atau kata-kata berhuruf besar.

Urutkan berdasarkan abjad

Tampaknya mengurutkan array menurut abjad seharusnya menjadi tugas yang paling sederhana:

Biarkan buah = ["butternut squash", "apricot", "melon"]; jenis buah(); > "aprikot", "butternut squash", "melon"]
Namun, kami mengalami masalah segera setelah salah satu elemen menggunakan huruf besar:

Biarkan buah = ["butternut squash", "apricot", "Cantalope"]; jenis buah(); > "Blewah", "aprikot", "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, saat melihat tabel kode, karakter "a" memiliki nilai U+0061 (heksadesimal 0x61), sedangkan karakter "C" memiliki kode U+0043 (0x43), yang muncul sebelum karakter di Unicode table. "a".

Untuk mengurutkan array yang mungkin berisi campuran huruf pertama, kita perlu mengonversi semua elemen untuk sementara menjadi huruf kecil, atau menentukan urutan pengurutan kita sendiri menggunakan metode localeCompare() dengan beberapa argumen. Sebagai aturan, untuk kasus seperti itu, lebih baik segera membuat fungsi untuk banyak penggunaan:

Fungsi alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) biarkan buah = ["butternut squash ", "aprikot", "melon"]; alphaSort(buah) >
Jika Anda ingin mendapatkan array yang diurutkan dalam urutan abjad terbalik, cukup tukar posisi a dan b dalam fungsi:

Fungsi alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) biarkan buah = ["butternut squash ", "aprikot", "melon"]; alphaSort(buah) > ["Cantaloupe", "butternut squash", "apricot"]
Di sini perlu dicatat bahwa localeCompare digunakan dengan argumen, kita juga perlu mengingat 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 = ["butternut squash", "apricot", "Blewah"]; caseSort(buah) > ["apricot", "butternut squash", "Cantaloupe"]

Pengurutan numerik

Semua ini tidak berlaku untuk contoh yang kita bicarakan di atas tentang susunan catatan permainan. Dengan beberapa larik numerik, pengurutan berfungsi dengan baik, tetapi pada titik tertentu hasilnya tidak dapat diprediksi:

Biarkan skor tinggi = ; menyortir(); >
Faktanya adalah bahwa metode sort() melakukan perbandingan leksikografis: 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, sekali lagi kami perlu menentukan urutan pengurutan kami:

Biarkan skor tinggi = ; highScores.sort(fungsi(a,b) ( return a - b; )); >
Sekali lagi, untuk mengurutkan angka urutan terbalik, tukar posisi a dan b dalam fungsi.

Menyortir struktur mirip JSON

Dan terakhir, jika kita memiliki struktur data mirip JSON yang direpresentasikan sebagai larik rekaman game:

Biarkan skor = [ ( "nama": "Daniel", "skor": 21768 ), ( "nama": "Michael", "skor": 33579 ), ( "nama": "Alison", "skor": 38395 )]);
Di ES6+, Anda dapat menggunakan fungsi panah:

Scores.sort((a, b) => b.score - a.score));
Untuk browser lama yang tidak memiliki dukungan ini:

Scores.sort(function(a, b) ( mengembalikan a.score - b.score ));
Seperti yang Anda lihat, menyortir dalam JavaScript adalah hal yang agak tidak jelas, saya harap contoh-contoh ini membuat hidup lebih mudah.

Bekerja dengan Fungsi Daya

Perpangkatan adalah operasi yang awalnya didefinisikan sebagai hasil perkalian bilangan asli dengan dirinya sendiri, akar kuadrat dari a adalah bilangan yang menghasilkan a ketika dikuadratkan. Fungsi-fungsi tersebut dapat kita gunakan secara terus-menerus dalam kehidupan sehari-hari dalam pelajaran matematika, termasuk dalam menghitung luas, volume, atau bahkan dalam pemodelan fisik.

Dalam JavaScript, fungsi daya direpresentasikan sebagai Math.pow(), dalam standar ES7 baru diperkenalkan operator baru eksponen - " * * ".

Eksponensial

Untuk menaikkan angka ke pangkat n, gunakan fungsi Math.pow() , di mana argumen pertama adalah angka yang akan dipangkatkan, dan argumen kedua adalah eksponen:

Math.pow(3,2) > 9
Notasi ini berarti 3 kuadrat, atau 3 × 3, menghasilkan hasil 9. Contoh lain tentu saja dapat diberikan:

Math.pow(5,3); > 125
Artinya, 5 pangkat tiga, atau 5 × 5 × 5, sama dengan 125.

ECMAScript 7 adalah versi berikutnya dari JavaScript, pada prinsipnya, kita dapat menggunakan operator eksponensial baru yang diusulkan - * *, bentuk penulisan ini bisa lebih deskriptif:

3 ** 2 > 9
Pada saat ini dukungan untuk operator ini agak terbatas, sehingga penggunaannya tidak disarankan.

Fungsi daya dapat berguna dalam berbagai situasi. Contoh sederhana, menghitung jumlah detik dalam satu jam: Math.pow(60,2).

Akar kuadrat dan pangkat tiga

Math.sqrt() dan Math.cbrt() adalah kebalikan dari Math.pow(). Seperti yang kita ingat, akar kuadrat dari a adalah bilangan yang menghasilkan a jika dikuadratkan.

Math.sqrt(9) > 3
Pada saat yang sama, akar pangkat tiga dari a adalah bilangan yang menghasilkan a ketika pangkat tiga.

Matematika.cbrt(125) > 5
Math.cbrt() diperkenalkan ke dalam spesifikasi JavaScript baru-baru ini dan karena itu hanya didukung di browser modern: Chrome 38+, Firefox dan Opera 25+ dan Safari 7.1+. Anda akan melihat itu Internet Explorer tidak ada dalam daftar ini, namun Anda dapat menemukan polyfill di MDN.

Contoh

Tentu saja, kita juga bisa menggunakan nilai bukan bilangan bulat di salah satu fungsi berikut:

Math.pow(1.25, 2); > 1,5625 Matematika.cbrt(56,57) > 3,8387991760286138
Perhatikan bahwa ini berfungsi dengan baik saat menggunakan nilai argumen negatif:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Namun, untuk akar kuadrat ini tidak akan berfungsi:

Math.sqrt(-9) > NaN
Dari analisis matematis, kita mengetahui bahwa bilangan imajiner dipahami sebagai akar kuadrat dari bilangan negatif. Dan itu mungkin membawa kita ke teknik bilangan kompleks lainnya, tapi itu cerita lain.

Anda dapat menggunakan nilai pecahan di Math.pow() untuk menemukan akar kuadrat dan pangkat tiga dari angka. Akar kuadrat menggunakan eksponen 0,5:

Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Namun, karena keanehan floating point, Anda tidak bisa menebak dengan tepat hasil yang benar:

Math.pow(2.23606797749979.2) > 5,000000000000001
Dalam situasi seperti itu, Anda harus memotong tanda dari angka atau membulatkan ke nilai tertentu.

Beberapa, entah kenapa di JavaScript, mengacaukan fungsi Math.pow() dengan Math.exp() , yang merupakan fungsi eksponensial untuk angka pada umumnya. Catatan: dalam bahasa Inggris, "eksponen" diterjemahkan sebagai "eksponen", jadi ini lebih relevan untuk 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 Math. Perlu dicatat bahwa konstanta ditulis dalam huruf besar, bukan notasi CamelCase.

Math.abs, parseInt, parseFloat

Bekerja dengan angka dalam JavaScript bisa jauh lebih rumit dari yang Anda kira. Nilai yang diperoleh tidak selalu berada dalam kisaran yang diharapkan, terkadang hasilnya mungkin tidak seperti yang kita harapkan sama sekali.

Matematika.abs()

Metode Math.abs() mengembalikan nilai absolut dari sebuah angka, yang mengingatkan kita pada fungsi modulo matematika analog.

Biarkan newVal = -57.64; Math.abs(newVal); > 57,64
Math.abs(0) selalu mengembalikan nol, tetapi jika kita meletakkan tanda minus di depan fungsi -Math.abs(NUM), kita akan selalu mendapatkan nilai negatif.

Math.abs(0); > -0

parseInt()

Kita tahu bahwa JavaScript memahami bahwa "15" adalah string, bukan angka, dan, misalnya, saat mem-parsing properti CSS menggunakan JavaScript, atau mendapatkan beberapa nilai dari larik yang tidak disiapkan, hasil kita bisa menjadi tidak dapat diprediksi. Kami bisa mendapatkan string yang direpresentasikan sebagai "17px" sebagai input, dan ini tidak biasa bagi kami. Pertanyaannya adalah bagaimana mengonversi string ini ke nilai sebenarnya dan menggunakannya dalam perhitungan lebih lanjut.

Sintaks: parseInt(string, radix);

Fungsi parseInt mengonversi argumen pertama yang diteruskan ke tipe string, menafsirkannya, dan mengembalikan nilai integer atau NaN. Hasilnya (jika bukan NaN) adalah bilangan bulat dan merupakan argumen pertama (string) yang diperlakukan sebagai angka dalam sistem angka yang ditentukan (radix). Misalnya, basis 10 menunjukkan konversi dari desimal, 8 dari oktal, 16 dari heksadesimal, dan seterusnya. Jika basisnya 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.

Pertimbangkan contoh bekerja dengan properti CSS, di mana, secara relatif, kita bisa mendapatkan nilai berikut:

Biarkan elem = document.body; biarkan centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Kami dapat memisahkan nilai dengan spasi:

Biarkan pusat = centerPoint.split(" "); > ["454 piksel", "2087,19 piksel"]
Namun, setiap elemen masih berupa string, kita dapat membuangnya dengan menggunakan fungsi kita:

Misalkan centerX = parseInt(centers, 10); > 454 biarkan centerY = parseInt(centers, 10); > 2087
Seperti yang Anda lihat, sebagai argumen kedua kami menentukan sistem angka yang akan dikonversi angkanya, parameter ini opsional, tetapi disarankan untuk menggunakannya jika Anda tidak tahu string mana yang akan dimasukkan.

parseFloat()

Dari contoh di atas, Anda mungkin memperhatikan bahwa parseInt membuang bagian pecahan. Dalam kasus kami, parseFloat dapat bekerja dengan angka floating point. Sekali lagi, ini bisa berguna dalam penguraian CSS dan tugas lainnya, terutama ketika berhadapan dengan persentase floating point.

Sintaks: parseFloat(string)

LetFP = "33.33333%"; console.log(parseFloat(FP)); > 33.33333
Perhatikan bahwa tidak ada argumen kedua dalam sintaks parseFloat.

Kami memahami bahwa parseInt() dan parseFloat() sangat fitur yang berguna, penting untuk diingat bahwa kesalahan pasti ada, jadi Anda perlu memeriksa rentang nilai yang diharapkan dan akhirnya menganalisis hasilnya untuk memastikan bahwa nilai yang Anda dapatkan benar.
Kirim secara anonim

Pembulatan matematika JavaScript ke dua tempat desimal (9)

Saya memiliki sintaks JavaScript berikut:

Vardiscount = Math.round(100 - (harga / daftarharga) * 100);

Ini membulatkan ke bilangan bulat. Bagaimana saya bisa mengembalikan hasil dengan dua tempat desimal?

Ini adalah contoh yang berfungsi

varvalue=200.2365455; result=Math.round(nilai*100)/100 //hasilnya 200,24

Untuk menangani pembulatan ke angka desimal berapa pun, fungsi dengan 2 baris kode sudah cukup untuk sebagian besar kebutuhan. Berikut adalah contoh kode untuk permainan.

var angkaujian = 134.9567654; var decPL = 2; var testRes = roundDec(testNum,decPl); alert (testNum + " dibulatkan menjadi " + decPl + " tempat desimal adalah " + testRes); function roundDec(nbr,dec_places)( var mult = Math.pow(10,dec_places); return Math.round(nbr * mult) / mult; )

Solusi terbaik dan termudah yang saya temukan adalah

Putaran fungsi(nilai, desimal) ( kembali Angka(Matematika.bulat(nilai+"e"+desimal)+"e-"+desimal); ) bulat(1,005, 2); // 1.01

Sedikit variasi pada jawaban yang diterima. toFixed(2) mengembalikan string dan Anda akan selalu mendapatkan dua tempat desimal. Itu bisa nol. Jika Anda ingin menekan trailing null(s), lakukan saja ini:

Var discount = + ((price / listprice).toFixed(2));

Diedit: Saya baru saja menemukan apa yang tampaknya menjadi bug di Firefox 35.0.1, artinya di atas mungkin memberi beberapa nilai pada NaN.
Saya mengubah kode saya menjadi

Vardiscount = Math.round(harga / daftarharga * 100) / 100;

Ini memberikan angka dengan akurasi dua tempat desimal. Jika Anda membutuhkan tiga, Anda akan mengalikan dan membaginya dengan 1000, dan seterusnya.
OP selalu menginginkan dua tempat desimal, tetapi jika toFixed() rusak di Firefox, seseorang harus memperbaikinya terlebih dahulu.
Lihat https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Untuk mendapatkan hasil dengan 2 tempat desimal, Anda dapat melakukan hal berikut:

Vardiscount = Math.round((100 - (harga / daftarharga) * 100) * 100) / 100;

Nilai yang akan dibulatkan dikalikan dengan 100 untuk menjaga dua digit pertama, lalu kita bagi dengan 100 untuk mendapatkan hasil yang sebenarnya.

Saya pikir itu Jalan terbaik Yang saya lihat adalah mengalikan dengan 10 dengan jumlah digit, lalu melakukan Math.round, dan terakhir membaginya dengan 10 dengan jumlah digit. Di Sini fungsi sederhana, yang saya gunakan dalam TypeScript:

Fungsi roundToXDigits(nilai: angka, digit: angka) ( nilai = nilai * Math.pow(10, digit); nilai = Math.round(nilai); nilai = nilai / Math.pow(10, digit); mengembalikan nilai; )

Atau javascript sederhana:

Fungsi roundToXDigits(nilai, digit) ( if(!digits)( digit = 2; ) nilai = nilai * Math.pow(10, digit); nilai = Math.round(nilai); nilai = nilai / Math.pow(10 , digit); mengembalikan nilai; )

CATATAN. - Lihat Edit 4 jika presisi 3 digit penting.

Vardiskon = (harga / daftarharga).toFixed(2);

toFixed membulatkan ke atas atau ke bawah untuk Anda tergantung pada nilai yang lebih besar dari 2 angka desimal.

Mengubah. Seperti yang disebutkan oleh orang lain, ini akan mengonversi hasilnya menjadi string. Untuk menghindari ini:

Vardiscount = +((harga / daftarharga).toFixed(2));

Sunting 2- Seperti disebutkan dalam komentar, fungsi ini tidak dijalankan dengan presisi, misalnya dalam kasus 1,005 akan mengembalikan 1,00, bukan 1,01. Jika keakuratan itu penting, saya menemukan jawaban ini: https://.com/a/32605063/1726511 Yang tampaknya bekerja dengan baik dengan semua tes yang saya coba.

Diperlukan satu modifikasi kecil, tetapi fungsi dalam jawaban di atas mengembalikan bilangan bulat saat dibulatkan menjadi satu, jadi misalnya 99,004 akan mengembalikan 99 alih-alih 99,00, yang tidak ideal untuk menampilkan harga.

Sunting 3- Tampaknya untuk Memperbaiki pengembalian STILL yang sebenarnya mengacaukan beberapa angka, pengeditan terakhir ini tampaknya berhasil. Ya ampun, begitu banyak reparasi!

Vardiscount = roundTo((harga / daftarharga), 2); fungsi roundTo(n, digits) ( if (digits === undefined) ( digits = 0; ) var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); var test =(Math.round(n) / perkalian); return +(test.toFixed(digit)); )

Sunting 4- Kalian membunuhku. Edit 3 gagal pada angka negatif tanpa menggali mengapa lebih mudah membuat angka negatif menjadi positif sebelum melakukan pembulatan dan kemudian membuangnya kembali sebelum mengembalikan hasilnya.

Fungsi roundTo(n, digit) ( var negative = false; if (digit === undefined) ( digit = 0; ) if(n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

Cara tercepat- lebih cepat dari toFixed():

DUA DECALYLS

x = .123456 hasil = Matematika.bulat(x * 100) / 100 // hasil .12

TIGA DECIMAL

x = .123456 hasil = Matematika.bulat(x * 1000) / 1000 // hasil .123

Fungsi round(num,dec) ( num = Math.round(num+"e"+dec) return Number(num+"e-"+dec) ) //Bulatkan ke desimal yang Anda pilih: round(1.3453,2)

Halo pecinta JavaScript. Anda telah memperhatikan bahwa bahasa ini sangat luar biasa dan menonjol di setiap bagian dengan karakteristiknya sendiri dan tidak biasa solusi teknis. Oleh karena itu, publikasi hari ini didedikasikan untuk topik: "Pembulatan JavaScript".

Setelah membaca artikel ini, Anda akan mengetahui mengapa perlu membulatkan angka, metode dan properti apa di js yang menjalankan fungsi ini, dan apa yang membedakan pembagian dengan 0. Tanpa mengubah prinsip saya, saya akan melampirkan contoh ke poin-poin utama dari materi dan menjelaskan setiap tindakan secara rinci. Sekarang mari kita mulai belajar!

Catatan penting tentang angka

Pertama, ingat bahwa di js semua jenis angka (pecahan dan bilangan bulat) bertipe nomor. Selain itu, semuanya 64-bit, karena disimpan dalam format "presisi ganda", yang juga dikenal sebagai standar IEEE-754.

Variabel numerik dibuat dengan cara biasa:

var mati rasa = 35; // bilangan asli

vardrob = 0,93; // representasi desimal

var mati rasa16 = 0xFF; // sistem bilangan heksadesimal

Mendukung representasi numerik lainnya juga. Jadi, Anda masih dapat membuat angka floating point (terkadang disebut "angka dalam format ilmiah").

Menambahkan dukungan untuk metode yang sangat menarik keLocaleString(), yang memformat semua parameter numerik menurut spesifikasi yang ditentukan dalam ECMA 402. Oleh karena itu, sejumlah besar, nomor telepon, mata uang dan bahkan persentase ditampilkan dengan baik di kotak dialog.

varnum = 714000.80;

alert(num.toLocaleString());

Untuk bekerja dengan elemen tipe Angka, seluruh objek global disediakan dengan banyak variasi fungsi matematika, nama siapa Matematika.

Selain itu, ada metode lain yang membulatkan nilai numerik ke bilangan bulat, ke persepuluhan, perseratus, dan seterusnya. Mari pertimbangkan semuanya secara lebih rinci.

Matematika yang hebat dan perkasa

Objek Matematika global mencakup beragam fungsi matematika dan trigonometri. Ini adalah objek yang sangat diperlukan dan sering membantu pengembang saat bekerja dengan data digital.

Di platform lain, ada analogi dengan Matematika. Misalnya, dalam bahasa populer seperti Java dan C#, Math adalah kelas yang mendukung semua fungsi standar yang sama. Jadi seperti yang Anda lihat, alat ini sangat hebat dan kuat.

Sekarang saya ingin melalui metode pembulatan spesifik dan membicarakannya secara detail.

Math.floor()

Saya akan mulai dengan Matematika.lantai. Perhatikan nama metodenya. Logikanya, menjadi jelas bahwa kita sedang berbicara tentang pembulatan, dan terjemahan literal dari kata "lantai" berarti "lantai", maka alat ini akan membulatkan nilai yang diproses ke bawah.

Mungkin juga nomor yang diproses menggunakan fungsi ini tetap sama. Ini karena pembulatan dilakukan menurut pertidaksamaan tidak ketat (<=). Таким образом, при отработке этой строчки кода:

alert(Math.floor(4.5));

jawabannya adalah nomor 4.

Math.ceil()

Sekali lagi, lihat judulnya (dengan cara ini, materi lebih cepat diserap). Jika ada yang tidak tahu, maka "ceil" berarti "plafon". Artinya, data numerik akan dibulatkan menggunakan pertidaksamaan tidak tegas (>=).

alert(Math.ceil(4.5));

Seperti yang mungkin sudah Anda duga, jawabannya adalah nomor 5.

putaran matematika()

Metode ini membulatkan bilangan pecahan ke bilangan bulat terdekat. Jadi, jika bagian pecahan berada dalam kisaran dari 0 hingga 0,5 inklusif, maka terjadi pembulatan ke nilai yang lebih kecil. Dan jika bagian pecahan berada dalam kisaran dari 0,5 inklusif ke bilangan bulat berikutnya, maka dibulatkan ke bilangan bulat yang lebih besar.

alert(Math.round(4.5));

Saya harap semua orang berpikir atau mengatakan jawaban yang benar adalah 5.

Beberapa metode lagi

JavaScript juga memiliki 2 metode lain yang berhubungan dengan pembulatan representasi numerik. Namun, mereka agak berbeda.

Kita berbicara tentang alat-alat seperti toFixed() Dan toPrecision(). Mereka bertanggung jawab tidak hanya untuk pembulatan, tetapi juga untuk keakuratannya pada tanda-tanda tertentu. Mari gali lebih dalam.

toFixed()

Dengan menggunakan mekanisme ini, Anda dapat menentukan berapa angka desimal yang harus dibulatkan ke nilai tersebut. Metode mengembalikan hasilnya sebagai string. Di bawah ini saya lampirkan varian dengan tiga pilihan yang berbeda. Menganalisis tanggapan yang diterima.

varnum = 5656.9393;

document.writeln(num.toFixed()); // 5657

document.writeln(num.toFixed(2)); // 5656.94

document.writeln(num.toFixed(7)); // 5656.9393000

Seperti yang Anda lihat, jika Anda tidak menentukan argumen, maka toFixed ()) akan membulatkan nilai pecahan untuk keseluruhan angka. Baris ketiga dibulatkan hingga 2 karakter, dan yang keempat, tiga 0 lagi ditambahkan karena parameter "7".

toPrecision()

Metode ini bekerja sedikit berbeda. Sebagai pengganti argumen, Anda dapat meninggalkan ruang kosong dan mengatur parameter. Namun, yang terakhir akan membulatkan angka ke jumlah digit yang ditentukan, terlepas dari komanya. Berikut adalah hasil program yang ditulis ulang dari contoh sebelumnya:

varnum = 5656.9393;

document.writeln(num.toPrecision()); // 5656.9393

document.writeln(num.toPrecision(2)); // 5.7e+3

document.writeln(num.toPrecision(7)); // 5656.939

Fitur pembagian dengan 0 di js

Seperti yang Anda ketahui dari pelajaran matematika, Anda tidak dapat membagi dengan nol. Aturan ini diambil sebagai dasar oleh sebagian besar pencipta bahasa pemrograman. Oleh karena itu, saat membagi dengan nol, semua program menghasilkan kesalahan.

Namun, JavaScript juga unggul di sini. Jadi, selama pelaksanaan operasi seperti itu, tidak ada laporan bug yang muncul ... karena operasi seperti itu kembali "Ketakterbatasan"!

Kenapa begitu? Seperti diketahui dari ilmu matematika yang sama, semakin kecil pembaginya, hasilnya lagi. Itulah sebabnya pembuat bahasa berbasis prototipe ini memutuskan untuk meninggalkan templat dan menempuh jalannya sendiri.

Bagi yang baru mengenal arti Infinity, saya telah menjelaskan ciri-cirinya di bawah ini.

Infinity - Berarti tak terhingga dan sepenuhnya sesuai dengan tanda matematika ∞.

Mungkin negatif. Semua aturan standar untuk bekerja dengan operator aritmatika juga dipertahankan.

waspada (12/0); // Ketakterbatasan

waspada (12.34/0); // Ketakterbatasan

waspada (-3/0); // -Ketakterbatasan

Tentang ini, mungkin, saya akan mengakhiri. Jika Anda menyukai posting ini, pastikan untuk berlangganan blog saya. Jangan ragu untuk menautkan ke artikel menarik dan membaginya dengan teman-teman Anda. Sampai jumpa!