Objek `Math`

Artikel ini menerangkan tentang objek Math.

Ia menerangkan langkah demi langkah, dari penggunaan asas hingga corak praktikal biasa, serta perangkap dan langkah pencegahan.

YouTube Video

Objek Math

Objek Math JavaScript menyediakan satu set utiliti terbina untuk pengiraan nombor.

Konstanta

Konstanta yang ditakrifkan dalam Math berguna apabila berurusan dengan nilai berketepatan tinggi.

Kod berikut menunjukkan beberapa konstanta biasa.

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 boleh digunakan secara langsung untuk fungsi trigonometri, penukaran logaritma, normalisasi dan lain-lain. Sebagai contoh, Math.PI diperlukan untuk menukar sudut ke radian.

Pembundaran asas dan nilai mutlak (abs, floor, ceil, round, trunc)

Pembundaran dan pengendalian tanda sering digunakan, jadi penting untuk memahami perbezaan antara Math.floor, Math.ceil, dan Math.round. Terutamanya apabila berurusan dengan nombor negatif, hasilnya mungkin berbeza daripada jangkaan, jadi perlu berhati-hati tentang cara setiap kaedah pembundaran berfungsi dan gunakan secara sesuai.

Contoh berikut menggambarkan perbezaan antara fungsi pembundaran.

 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 membundarkan ke arah yang lebih kecil untuk nombor negatif, jadi -3.7 menjadi -4.
• Math.ceil membundarkan ke arah yang lebih besar untuk nombor negatif, jadi -3.7 menjadi -3.
• Math.round membundar .5 ke atas untuk nombor positif, dan untuk nombor negatif, ia membundar ke arah sifar.
• Nombor negatif boleh menghasilkan keputusan yang berbeza daripada jangkaan, jadi penting untuk jelas memahami ke arah mana nombor dibundarkan.
• Fungsi pembundaran harus dipilih mengikut kes penggunaan. Sebagai contoh, gunakan Math.floor untuk pengiraan indeks, Math.ceil untuk had atas, dan Math.trunc apabila anda hanya mahu membuang bahagian perpuluhan.

Pendaraban, pentakrifan, dan akar (pow, **, sqrt, cbrt, hypot)

Pangkat dan punca kuasa dua boleh dilakukan dengan Math.pow atau dengan operator **. Math.hypot mengira akar kuasa dua jumlah kuasa dua (jarak) dengan selamat.

Berikut adalah contoh bagi pentakrifan dan hypot. Math.hypot mengurangkan kesan lebihan atau kekurangan data.

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 semasa mengira sisi segitiga atau panjang vektor pelbagai dimensi.

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

Eksponen dan logaritma sering digunakan dalam kebarangkalian, susutan eksponen, dan penskalaan.

Berikut adalah contoh asas bagi exp dan logaritma. Pastikan menggunakan fungsi yang sesuai, bergantung pada asas 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 semulajadi (Math.log) adalah standard dalam statistik dan persamaan pembezaan. Logaritma asas biasa dan asas-2 juga dipilih bergantung pada aplikasi.

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

Fungsi trigonometri penting untuk pengiraan sudut, putaran, dan transformasi koordinat. Math.atan2(y, x) berguna untuk mengira sudut sambil mengambil kira sukuan dengan betul.

Di bawah ini adalah contoh dan penggunaan asas bagi atan2. Sudut mesti diuruskan dalam 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 boleh menentukan sudut vektor dengan selamat, menjadikannya pilihan tepat untuk pengiraan putaran dan arah.

Penjanaan nombor rawak (Math.random dan corak praktikal)

Math.random() menghasilkan nombor rawak taburan seragam antara julat [0, 1). Anda boleh menukar atau meluaskan mengikut keperluan untuk julat integer atau taburan normal, sebagai contoh.

Berikut adalah contoh fungsi utiliti nombor rawak. Jika anda memerlukan nombor rawak yang selamat 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 mudah untuk kegunaan am, tetapi untuk siaran semula permainan atau kriptografi, langkah keselamatan untuk kebolehulangan atau keselamatan diperlukan.

Pembantu praktikal (clamp, lerp, mapRange, normalisasi sudut)

Adalah berguna untuk menulis sendiri fungsi utiliti ringkas bagi tugasan matematik yang sering digunakan.

Berikut adalah contoh pelaksanaan utiliti yang biasa 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));

• Kod ini menghimpunkan fungsi utiliti kecil yang biasa digunakan untuk operasi nombor seperti mengehadkan nilai, interpolasi, pemetaan julat, dan normalisasi sudut. clamp mengehadkan nilai dalam julat tertentu, manakala lerp dan mapRange melakukan interpolasi lancar atau penukaran kepada julat lain. Selain itu, normalizeAngle sentiasa menormalkan sudut ke julat [-π, π) untuk menstabilkan pengiraan putaran.
• Pembantu ini sering digunakan dalam grafik, permainan, dan pengaturcaraan interaksi. normalizeAngle penting untuk membandingkan perbezaan sudut dan untuk interpolasi.

Amaran tentang nombor perpuluhan dan pembundaran (ketepatan dan perbandingan)

Nombor JavaScript adalah nombor perpuluhan ketepatan berganda IEEE-754 (64-bit), jadi perhatian diperlukan semasa membanding atau membundarkan nombor. Sebagai contoh, 0.1 + 0.2 !== 0.3.

Berikut adalah contoh mengendalikan ralat pembundaran. Penting untuk menggunakan perbandingan yang bertoleransi dengan ralat kecil, atau fungsi pembundaran 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 semakan kesaksamaan nombor yang kukuh, gunakan ralat mutlak (eps) atau ralat relatif.

Petua prestasi

Fungsi Math dioptimumkan secara asli dan selalunya lebih pantas daripada logik setara yang ditulis sendiri. Jika pengiraan yang sama (contohnya, Math.PI / 180) diulang dalam gelung, menetapkannya ke pemboleh ubah terlebih dahulu mengurangkan beban yang tidak perlu.

Berikut adalah contoh menukar darjah ke radian dengan mewujudkan konstanta di luar gelung.

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 semak titik panas sebenar dengan profiler sebelum melakukan pengoptimuman.
• Adalah cekap untuk cache konstanta yang sering digunakan.

Keserasian dan polyfill

Math telah wujud sejak sekian lama, tetapi sesetengah fungsi seperti Math.cbrt, Math.log10, Math.log2, dan Math.hypot mungkin tidak disokong dalam persekitaran lama. Sediakan polyfill ringkas jika perlu.

Berikut adalah contoh polyfill ringkas 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 persekitaran sudah menyokongnya, tetapi semak keserasian jika perlu.

Semak sokongan pelayar mengikut persekitaran sasaran projek anda.

Contoh praktikal: Kemas kini ikut masa dalam simulasi fizik ringkas

Akhir sekali, berikut adalah contoh praktikal yang menggabungkan beberapa fungsi Math. Ini adalah contoh yang sangat ringkas untuk mengemaskini kedudukan, halaju, dan kawalan sudut.

Ia adalah model enjin fizik yang sangat dipermudahkan.

 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 pembantu Math seperti ini, logik simulasi dan animasi boleh menjadi lebih ringkas.

Ringkasan

• Math merangkumi segalanya dari konstanta dan fungsi asas hingga fungsi lanjutan, berfungsi sebagai asas pemprosesan nombor.
• Pilih fungsi mengikut tujuan, seperti nombor rawak, fungsi trigonometri, eksponen/logaritma, atau pembundaran; serta cipta utiliti kecil seperti clamp dan lerp untuk kegunaan praktikal.
• Berikan perhatian pada ketepatan nombor perpuluhan dan status sokongan dalam persekitaran sasaran anda, serta sediakan toleransi ralat atau polyfill jika perlu.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video