Objek `Math`

Artikel ini menjelaskan tentang objek Math.

Penjelasan dilakukan secara bertahap, mulai dari penggunaan dasar hingga pola praktis umum, serta kesalahan yang sering terjadi dan cara mengatasinya.

YouTube Video

Objek Math

Objek Math di JavaScript menyediakan sekumpulan utilitas bawaan untuk perhitungan numerik.

Konstanta

Konstanta yang didefinisikan dalam Math berguna ketika menangani nilai dengan presisi tinggi.

Kode berikut menunjukkan beberapa konstanta yang umum digunakan.

1// Show common Math constants
2console.log("Math.PI:", Math.PI);         // 3.141592653589793
3console.log("Math.E:", Math.E);           // Euler's number
4console.log("Math.LN2:", Math.LN2);       // Natural log of 2
5console.log("Math.SQRT2:", Math.SQRT2);   // Square root of 2

• Konstanta-konstanta ini dapat langsung digunakan untuk fungsi trigonometri, konversi logaritma, normalisasi, dan lain-lain. Contohnya, Math.PI diperlukan untuk mengonversi sudut ke radian.

Pembulatan dasar dan nilai absolut (abs, floor, ceil, round, trunc)

Pembulatan dan penanganan tanda sering digunakan, sehingga penting untuk memahami perbedaan antara Math.floor, Math.ceil, dan Math.round dengan benar. Terutama saat menangani angka negatif, hasilnya bisa berbeda dengan intuisi, jadi kita harus hati-hati memahami cara kerja setiap aturan pembulatan dan menggunakannya dengan tepat.

Contoh berikut menggambarkan perbedaan antara fungsi pembulatan.

 1// Examples of rounding and absolute value functions
 2const pos = 3.7;
 3const neg = -3.7;
 4
 5// --- floor ---
 6console.log("Math.floor(3.7):", Math.floor(pos));  // 3
 7console.log("Math.floor(-3.7):", Math.floor(neg)); // -4
 8// (rounds toward smaller value)
 9
10// --- ceil ---
11console.log("Math.ceil(3.7):", Math.ceil(pos));  // 4
12console.log("Math.ceil(-3.7):", Math.ceil(neg)); // -3
13// (rounds toward larger value)
14
15// --- round ---
16console.log("Math.round(3.5):", Math.round(3.5));   // 4
17// (.5 goes up for positive numbers)
18console.log("Math.round(-3.5):", Math.round(-3.5)); // -3
19// (.5 moves toward zero for negative numbers)
20
21// --- trunc ---
22console.log("Math.trunc(3.7):", Math.trunc(pos));  // 3
23console.log("Math.trunc(-3.7):", Math.trunc(neg)); // -3
24// (fraction removed toward zero)
25
26// --- abs ---
27console.log("Math.abs(-3.7):", Math.abs(neg)); // 3.7

• Math.floor membulat ke arah yang lebih kecil untuk angka negatif, jadi -3.7 menjadi -4.
• Math.ceil membulat ke arah yang lebih besar untuk angka negatif, jadi -3.7 menjadi -3.
• Math.round membulatkan angka 0.5 ke atas untuk angka positif, dan untuk angka negatif, membulatkan mendekati nol.
• Angka negatif dapat menghasilkan hasil yang berbeda dari intuisi, sehingga penting untuk memahami dengan jelas ke arah mana angka akan dibulatkan.
• Fungsi pembulatan harus dipilih sesuai dengan kasus penggunaan. Misalnya, gunakan Math.floor untuk perhitungan indeks, Math.ceil untuk batas atas, dan Math.trunc saat Anda hanya ingin menghilangkan bagian desimal.

Perkalian, perpangkatan, dan akar (pow, **, sqrt, cbrt, hypot)

Perpangkatan dan akar kuadrat dapat dilakukan dengan Math.pow atau dengan operator **. Math.hypot menghitung akar kuadrat dari jumlah kuadrat (jarak) dengan aman.

Berikut adalah contoh perpangkatan dan penggunaan hypot. Math.hypot dapat mengurangi dampak overflow dan underflow.

1// Power, root and hypot examples
2console.log("2 ** 10:", 2 ** 10);                // 1024
3console.log("Math.pow(2, 10):", Math.pow(2, 10));// 1024
4console.log("Math.sqrt(16):", Math.sqrt(16));    // 4
5console.log("Math.cbrt(27):", Math.cbrt(27));    // 3
6console.log("Math.hypot(3, 4):", Math.hypot(3, 4));// 5 (3-4-5 triangle)

• Math.hypot berguna saat menangani sisi segitiga atau panjang vektor multi dimensi.

Fungsi eksponensial dan logaritma (exp, log, log10, log2)

Eksponensial dan logaritma sering digunakan dalam probabilitas, peluruhan eksponensial, dan penskalaan.

Berikut adalah contoh dasar dari exp dan logaritma. Pastikan untuk menggunakan fungsi yang sesuai, tergantung pada basis logaritma.

1// Exponential and logarithm examples
2console.log("Math.exp(1):", Math.exp(1));     // e^1
3console.log("Math.log(Math.E):", Math.log(Math.E)); // natural log, 1
4console.log("Math.log10(100):", Math.log10(100));   // 2
5console.log("Math.log2(8):", Math.log2(8));         // 3

• Logaritma natural (Math.log) adalah standar dalam statistik dan persamaan diferensial. Logaritma biasa dan logaritma basis 2 juga dipilih sesuai kebutuhan aplikasi.

Fungsi trigonometri (sin, cos, tan, asin, acos, atan2)

Fungsi trigonometri sangat penting untuk perhitungan sudut, rotasi, dan transformasi koordinat. Math.atan2(y, x) berguna untuk menghitung sudut dengan mempertimbangkan kuadran dengan benar.

Berikut adalah contoh dasar dan cara penggunaan atan2. Sudut harus ditangani dalam satuan radian.

 1// Trigonometry examples (angles in radians)
 2const degToRad = deg => deg * (Math.PI / 180);
 3const radToDeg = rad => rad * (180 / Math.PI);
 4
 5console.log("Math.sin(PI/2):", Math.sin(Math.PI / 2));          // 1
 6console.log("Math.cos(0):", Math.cos(0));                      // 1
 7console.log("Math.tan(Math.PI / 4):", Math.tan(Math.PI / 4));  // ~1
 8
 9// Using atan2 to compute angle of vector (x, y)
10const x = -1, y = 1;
11const angle = Math.atan2(y, x); // returns angle in radians taking quadrant into account
12console.log("atan2(1, -1) in degrees:", radToDeg(angle));      // 135

• atan2 dapat menentukan sudut vektor dengan aman, sehingga cocok untuk perhitungan rotasi dan arah.

Pembangkit angka acak (Math.random dan pola praktisnya)

Math.random() mengembalikan angka acak yang terdistribusi secara uniform dalam rentang [0, 1). Anda dapat mengonversi atau memperluasnya sesuai kebutuhan untuk rentang integer atau distribusi normal, misalnya.

Berikut adalah contoh fungsi utilitas angka acak. Jika Anda membutuhkan angka acak yang aman secara kriptografi, gunakan crypto.getRandomValues.

 1// Random utilities using Math.random
 2
 3// Get integer in [min, max] inclusive
 4function randomInt(min, max) {
 5  // Returns integer between min and max (inclusive)
 6  return Math.floor(Math.random() * (max - min + 1)) + min;
 7}
 8console.log("randomInt(1, 6):", randomInt(1, 6)); // dice roll example
 9
10// Get float in [min, max)
11function randomFloat(min, max) {
12  return Math.random() * (max - min) + min;
13}
14console.log("randomFloat(0, 5):", randomFloat(0, 5));
15
16// Fisher-Yates shuffle
17function shuffle(array) {
18  for (let i = array.length - 1; i > 0; i--) {
19    const j = Math.floor(Math.random() * (i + 1));
20    // swap array[i] and array[j]
21    [array[i], array[j]] = [array[j], array[i]];
22  }
23  return array;
24}
25console.log("shuffle([1,2,3,4,5]):", shuffle([1,2,3,4,5]));

• Math.random nyaman untuk penggunaan umum, tetapi untuk rekam ulang game atau kriptografi, diperlukan tindakan untuk reprodusibilitas atau keamanan.

Fungsi pembantu praktis (clamp, lerp, mapRange, normalisasi sudut)

Sangat membantu jika Anda menulis fungsi utilitas kecil sendiri untuk tugas matematika yang sering digunakan.

Berikut adalah contoh implementasi utilitas yang umum digunakan.

 1// Utility functions: clamp, lerp, mapRange, normalizeAngle
 2
 3// Clamp value between min and max
 4function clamp(v, min, max) {
 5  return Math.max(min, Math.min(max, v));
 6}
 7console.log("clamp(10, 0, 5):", clamp(10, 0, 5)); // 5
 8
 9// Linear interpolation: t in [0,1]
10function lerp(a, b, t) {
11  return a + (b - a) * t;
12}
13console.log("lerp(0, 10, 0.25):", lerp(0, 10, 0.25)); // 2.5
14
15// Map value from one range to another
16function mapRange(v, inMin, inMax, outMin, outMax) {
17  const t = (v - inMin) / (inMax - inMin);
18  return lerp(outMin, outMax, t);
19}
20console.log("mapRange(5, 0, 10, 0, 100):", mapRange(5, 0, 10, 0, 100));
21// -> 50
22
23// Normalize angle to [-PI, PI)
24function normalizeAngle(rad) {
25  return Math.atan2(Math.sin(rad), Math.cos(rad));
26}
27console.log("normalizeAngle(3*PI):", normalizeAngle(3 * Math.PI));

• Kode ini mengumpulkan fungsi utilitas kecil yang umum digunakan untuk operasi numerik seperti membatasi nilai, interpolasi, pemetaan rentang, dan normalisasi sudut. clamp membatasi suatu nilai pada rentang tertentu, sedangkan lerp dan mapRange melakukan interpolasi halus atau konversi ke rentang lain. Selain itu, normalizeAngle selalu menormalkan sudut ke rentang [-π, π) untuk menstabilkan perhitungan rotasi.
• Fungsi pembantu ini sering digunakan dalam pemrograman grafis, game, dan interaksi. normalizeAngle penting untuk membandingkan perbedaan sudut dan juga untuk interpolasi.

Peringatan pada floating-point dan pembulatan (presisi dan perbandingan)

Angka di JavaScript adalah floating-point presisi ganda IEEE-754 (64-bit), jadi diperlukan kehati-hatian saat membandingkan atau membulatkan angka. Sebagai contoh, 0.1 + 0.2 !== 0.3.

Berikut adalah contoh penanganan kesalahan pembulatan. Penting untuk menggunakan perbandingan yang toleran terhadap kesalahan kecil, atau menggunakan fungsi pembulatan yang sesuai.

1// Floating point precision example and safe equality
2console.log("0.1 + 0.2 === 0.3 :", 0.1 + 0.2 === 0.3); // false
3
4function nearlyEqual(a, b, eps = 1e-12) {
5  return Math.abs(a - b) <= eps;
6}
7console.log("nearlyEqual(0.1+0.2, 0.3):", nearlyEqual(0.1 + 0.2, 0.3));
8// -> true

• Untuk pemeriksaan kesetaraan numerik yang andal, gunakan kesalahan absolut (eps) atau kesalahan relatif.

Tips performa

Fungsi-fungsi dalam Math telah dioptimalkan secara native dan biasanya lebih cepat daripada logika yang ditulis sendiri. Jika perhitungan yang sama (misalnya, Math.PI / 180) diulang dalam sebuah loop, menetapkannya ke variabel terlebih dahulu dapat mengurangi overhead yang tidak perlu.

Berikut adalah contoh mengonversi derajat ke radian dengan membuat konstanta di luar loop.

1// Cache conversion factor for performance
2const DEG_TO_RAD = Math.PI / 180;
3const RAD_TO_DEG = 180 / Math.PI;
4
5for (let deg = 0; deg < 360; deg += 10) {
6  // Use cached constant instead of computing each time
7  const rad = deg * DEG_TO_RAD;
8  // ... do work with rad
9}

• Sebaiknya periksa bagian yang paling membebani (hotspot) dengan profiler sebelum melakukan optimasi.
• Meng-cache konstanta yang sering digunakan adalah hal yang efisien.

Kompatibilitas dan polyfill

Math sendiri telah ada sejak lama, namun beberapa fungsi seperti Math.cbrt, Math.log10, Math.log2, dan Math.hypot mungkin tidak didukung di lingkungan lama. Siapkan polyfill sederhana jika diperlukan.

Berikut adalah contoh polyfill sederhana untuk Math.log2.

1// Polyfill for Math.log2 if needed
2if (!Math.log2) {
3  Math.log2 = function(x) {
4    return Math.log(x) / Math.LN2;
5  };
6}
7console.log("Math.log2(8):", Math.log2(8));

Banyak lingkungan yang sudah mendukung fungsi ini, tapi tetap cek kompatibilitas jika dibutuhkan.

Periksa dukungan browser sesuai dengan target lingkungan proyek Anda.

Contoh praktis: Pembaruan berbasis waktu pada simulasi fisika sederhana

Akhirnya, berikut adalah contoh praktis yang menggabungkan beberapa fungsi Math. Ini adalah contoh sederhana untuk memperbarui posisi, kecepatan, dan kontrol sudut.

Ini adalah model yang sangat sederhana dari mesin fisika.

 1// Clamp value between min and max
 2function clamp(v, min, max) {
 3  return Math.max(min, Math.min(max, v));
 4}
 5
 6// Normalize angle to [-PI, PI)
 7function normalizeAngle(rad) {
 8  return Math.atan2(Math.sin(rad), Math.cos(rad));
 9}
10
11// Simple physics step example using Math utilities
12function step(state, dt) {
13  // state: { x, y, vx, vy, angle, angularVelocity }
14  // dt: time delta in seconds
15  // Integrate linear motion
16  state.x += state.vx * dt;
17  state.y += state.vy * dt;
18
19  // Integrate angular motion and normalize angle
20  state.angle = normalizeAngle(state.angle + state.angularVelocity * dt);
21
22  // Keep position within bounds [0, width] x [0, height]
23  state.x = clamp(state.x, 0, state.width);
24  state.y = clamp(state.y, 0, state.height);
25  return state;
26}
27
28const state = { x: 10, y: 10, vx: 2, vy: 0.5, angle: 0, angularVelocity: 0.1, width: 100, height: 100 };
29console.log("before:", state);
30step(state, 0.016); // simulate ~1 frame at 60fps
31console.log("after:", state);

• Dengan menggabungkan fungsi pembantu Math seperti ini, logika simulasi dan animasi bisa dibuat lebih ringkas.

Ringkasan

• Math mencakup semuanya dari konstanta dan fungsi dasar hingga yang lanjutan, sebagai fondasi untuk pemrosesan numerik.
• Pilih fungsi sesuai dengan tujuannya, seperti angka acak, fungsi trigonometri, eksponensial/logaritma, atau pembulatan; serta buat utilitas kecil seperti clamp dan lerp untuk penggunaan praktis.
• Perhatikan presisi floating-point dan status dukungan di lingkungan target Anda, serta siapkan toleransi kesalahan atau polyfill jika diperlukan.

Anda dapat mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Silakan periksa juga saluran YouTube kami.

YouTube Video