`Math` nesnesi

Bu makale Math nesnesini açıklar.

Temel kullanımdan yaygın pratik modellere, tuzaklara ve önlemlere kadar adım adım açıklar.

YouTube Video

Math nesnesi

JavaScript'in Math nesnesi, sayısal hesaplamalar için yerleşik araçlar sunar.

Sabitler

Math içinde tanımlanan sabitler, yüksek hassasiyetli değerlerle çalışırken faydalıdır.

Aşağıdaki kod bazı tipik sabitleri gösterir.

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

• Bu sabitler; trigonometrik fonksiyonlar, logaritmik dönüşümler, normalleştirme ve daha fazlası için olduğu gibi kullanılabilir. Örneğin, açıları radyana çevirmek için Math.PI gerekir.

Temel yuvarlama ve mutlak değerler (abs, floor, ceil, round, trunc)

Yuvarlama ve işaret işlemleri sıkça kullanıldığından, Math.floor, Math.ceil ve Math.round arasındaki farkları doğru anlamak önemlidir. Özellikle negatif sayılarla çalışırken, sonuçlar sezgisel olmayabilir; bu nedenle her bir yuvarlama kuralının nasıl çalıştığına dikkat etmek ve uygun şekilde kullanmak gerekir.

Aşağıdaki örnekler yuvarlama fonksiyonları arasındaki farkları gösterir.

 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, negatif sayılar için daha küçük olana yuvarlar; bu yüzden -3.7, -4 olur.
• Math.ceil, negatif sayılar için daha büyük olana yuvarlar; bu yüzden -3.7, -3 olur.
• Math.round pozitif sayılar için .5 ve üzerini yukarı yuvarlar, negatif sayılarda ise sıfıra doğru yuvarlar.
• Negatif sayılar sezgisel olmayan sonuçlara yol açabilir, bu yüzden sayıların hangi yöne yuvarlandığını net olarak anlamak önemlidir.
• Yuvarlama fonksiyonları, kullanım amacına göre seçilmelidir. Örneğin, indeks hesaplamaları için Math.floor, üst sınırlar için Math.ceil, sadece ondalık kısmı atmak için ise Math.trunc kullanılır.

Çarpma, üstel alma ve kökler (pow, **, sqrt, cbrt, hypot)

Üs alma ve karekök işlemleri Math.pow veya ** operatörüyle yapılabilir. Math.hypot, karelerin toplamının karekökünü (mesafe) güvenli şekilde hesaplar.

Aşağıda üstel alma ve hypot örnekleri bulunmaktadır. Math.hypot, taşma ve eksilme etkilerini azaltır.

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, üçgen kenarları veya çok boyutlu vektör uzunluklarıyla uğraşırken faydalıdır.

Üstel ve logaritmik fonksiyonlar (exp, log, log10, log2)

Üstel ve logaritmalar genellikle olasılık, üstel azalma ve ölçeklemede kullanılır.

Sırada exp ve logaritmaların temel örnekleri var. Logaritmanın tabanına bağlı olarak uygun fonksiyonu kullandığınızdan emin olun.

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

• Doğal logaritmalar (Math.log), istatistik ve diferansiyel denklemlerde standarttır. Onluk logaritmalar ve taban-2 logaritmalar da uygulamaya göre seçilir.

Trigonometrik fonksiyonlar (sin, cos, tan, asin, acos, atan2)

Trigonometrik fonksiyonlar, açı hesaplamaları, dönüşler ve koordinat dönüşümleri için gereklidir. Math.atan2(y, x), açıları doğru çeyreklerde hesaplamak için faydalıdır.

Aşağıda atan2'nin temel örnekleri ve kullanımları verilmiştir. Açılar radyan cinsinden ele alınmalıdır.

 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, bir vektörün açısını güvenle belirler ve dönüş açısı hesaplamalarında tercih edilir.

Rastgele sayı üretimi (Math.random ve pratik kullanımlar)

Math.random(), [0, 1) aralığında eşit dağılımlı bir rastgele sayı döndürür. Gerekirse bunu tamsayı aralıklarına veya normal dağılıma çevirebilir veya genişletebilirsiniz.

Aşağıda rastgele sayı yardımcı fonksiyonlarına örnekler verilmiştir. Kriptografik olarak güvenli rastgele sayılara ihtiyacınız varsa, crypto.getRandomValues kullanın.

 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 genel kullanım için uygundur, ancak oyun tekrarları veya kriptografi için yeniden üretilebilirlik veya güvenlik önlemleri gereklidir.

Pratik yardımcılar (clamp, lerp, mapRange, açı normalizasyonu)

Sık kullanılan matematiksel işlemler için küçük yardımcı fonksiyonlar yazmak faydalı olur.

Burada yaygın olarak kullanılan yardımcıların uygulama örnekleri vardır.

 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));

• Bu kod, değeri bir aralıkta sınırlama, enterpolasyon, aralık dönüştürme ve açı normalizasyonu gibi sayısal işlemler için sıkça kullanılan küçük yardımcı fonksiyonları toplar. clamp bir değeri belirli bir aralığa sınırlar, lerp ve mapRange ise yumuşak geçiş veya başka bir aralığa dönüştürme işlemleri yapar. Ek olarak, normalizeAngle açıları daima [-π, π) aralığına normalleştirir ve böylece dönüş hesaplamalarını kararlı hale getirir.
• Bu yardımcı fonksiyonlar, grafik, oyun ve etkileşim programlamasında sıklıkla kullanılır. normalizeAngle açı farklarını karşılaştırma ve enterpolasyon için önemlidir.

Ondalıklı sayılar ve yuvarlama uyarıları (hassasiyet ve karşılaştırma)

JavaScript sayıları, IEEE-754 çift hassasiyetli ondalık (64 bit) olup, karşılaştırma veya yuvarlama yaparken dikkatli olunmalıdır. Örneğin, 0.1 + 0.2 !== 0.3.

Yuvarlama hatalarının nasıl ele alınacağına dair bir örnek burada. Küçük hataları tolere eden karşılaştırmalar veya uygun yuvarlama fonksiyonları kullanmak önemlidir.

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

• Dayanıklı sayısal eşitlik kontrolleri için mutlak hata (eps) veya göreli hata kullanın.

Performans ipuçları

Math fonksiyonları yerel olarak optimize edilmiştir ve genellikle el ile yazılmış eşdeğer mantıktan daha hızlıdır. Aynı hesaplama (ör. Math.PI / 180) bir döngü içinde tekrar ediliyorsa, bunu önceden bir değişkene atamak gereksiz yükü azaltır.

Aşağıda, bir sabiti döngü dışında oluşturarak dereceyi radyana çevirme örneği yer almaktadır.

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}

• Optimizasyon yapmadan önce gerçek yoğun noktaları bir profilleyici ile doğrulamak en iyisidir.
• Sık kullanılan sabitleri önbelleğe almak verimlidir.

Uyumluluk ve polyfill'ler

Math uzun zamandır mevcut, ancak Math.cbrt, Math.log10, Math.log2 ve Math.hypot gibi bazı fonksiyonlar eski ortamlarda desteklenmeyebilir. Gerekirse basit bir polyfill hazırlayın.

Aşağıda, Math.log2 için basit bir polyfill örneği bulunmaktadır.

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));

Birçok ortam zaten bunları destekler, ancak gerekirse uyumluluğu kontrol edin.

Projenizin hedef ortamına göre tarayıcı desteğini kontrol edin.

Pratik örnek: Basit bir fizik simülasyonunda zaman adımlı güncellemeler

Son olarak, birkaç Math fonksiyonunu birleştiren pratik bir örnek işte burada. Bu, konum, hız ve açı kontrolünü güncellemek için çok basit bir örnektir.

Bu, bir fizik motorunun oldukça basitleştirilmiş bir modelidir.

 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);

• Bu şekilde Math yardımcılarını birleştirerek simülasyon ve animasyon mantığı daha öz hale getirilebilir.

Özet

• Math sabitlerden temel fonksiyonlara ve ileri seviye işlemlere kadar her şeyi kapsar ve sayısal işlemlerin temelini oluşturur.
• Rastgele sayılar, trigonometrik fonksiyonlar, üstel/logaritmik işlemler veya yuvarlama gibi amaçlarına göre fonksiyonları seçin; pratik kullanım için clamp ve lerp gibi küçük yardımcılar oluşturun.
• Ondalık hassasiyete ve hedef ortamınızın destek durumuna dikkat edin; gerekirse hata toleransı veya polyfill hazırlayın.

Yukarıdaki makaleyi, YouTube kanalımızda Visual Studio Code'u kullanarak takip edebilirsiniz. Lütfen YouTube kanalını da kontrol edin.

YouTube Video