JavaScript'teki `Number` Sınıfı

Bu makale, JavaScript'teki Number sınıfını açıklar.

Number'ın özelliklerini, yaygın tuzaklarını, faydalı API'leri ve pratik örnekleri adım adım dikkatlice açıklayacağız.

YouTube Video

JavaScript'teki Number Sınıfı

Number, JavaScript'teki temel sayısal türdür ve IEEE-754 çift hassasiyetli kayan noktalı sayı (64-bit) olarak temsil edilir.

Temeller: Sayı Temsili ve Tür Kontrolü

JavaScript'te tüm sayılar, ilkel number türü olarak temsil edilir.

 1// Primitive numbers and Number object
 2const a = 42;                 // primitive number
 3const b = 3.14;               // primitive float
 4const c = Number(10);         // primitive via constructor call (function form)
 5const d = new Number(10);     // Number object (wrapper)
 6
 7console.log(typeof a);        // "number"
 8console.log(typeof d);        // "object"
 9console.log(c == d);          // true  (value coerces)
10console.log(c === d);         // false (different types)

• Bu kod, ilkel bir number ile Number sarmalayıcı nesnesi arasındaki farkı gösterir. Genellikle, sarmalayıcılar yerine ilkel türler kullanılır.

Özel Değerler: NaN, Infinity ve Sabitler

Number, özel değerler (NaN, Infinity) ve sabitler sağlar.

 1// Special numeric values and constants
 2console.log(Number.NaN);                 // NaN
 3console.log(Number.POSITIVE_INFINITY);   // Infinity
 4console.log(Number.NEGATIVE_INFINITY);   // -Infinity
 5
 6console.log(Number.MAX_VALUE);           // largest positive representable
 7console.log(Number.MIN_VALUE);           // smallest positive representable (closest to 0)
 8console.log(Number.MAX_SAFE_INTEGER);    // 9007199254740991
 9console.log(Number.MIN_SAFE_INTEGER);    // -9007199254740991
10console.log(Number.EPSILON);             // smallest difference ~2.220446049250313e-16

• MAX_SAFE_INTEGER'dan büyük veya eşit tam sayılar doğru şekilde temsil edilmeyebilir. Doğruluk gerekiyorsa BigInt kullanmayı düşünün. EPSILON, kayan noktalı karşılaştırmalar için kullanılır.

Sayı Dönüşümü: Number(), parseInt, parseFloat ve + Operatörü

Bir dizgiyi sayıya dönüştürmenin birkaç yolu vardır ve her birinin farklı davranışları vardır.

 1// Converting strings to numbers
 2console.log(Number("42"));        // 42
 3console.log(Number("  3.14 "));   // 3.14
 4console.log(+ "7");               // 7 (unary +)
 5
 6console.log(parseInt("42px"));    // 42
 7console.log(parseFloat("3.14abc"));// 3.14
 8
 9// Careful with parseInt and radix
10console.log(parseInt("08"));      // 8
11console.log(parseInt("08", 10));  // 8 (explicit radix is safer)

• Dizginin tamamı kesin olarak sayısal biçimde değilse Number() değeri NaN olarak döndürür; oysa parseInt ve parseFloat dizginin başından okunabilen sayısal kısmı ayrıştırır. parseInt kullanırken tabanı (radix) açıkça belirtmek her zaman daha güvenlidir.

NaN'in Kullanımı ve Kontrolü: isNaN ve Number.isNaN

NaN (Not-A-Number), kendisiyle eşit olmaması (NaN !== NaN) açısından özeldir. Kontrol şekillerinde farklılıklar vardır; global isNaN tür dönüşümü yapar ve yanlış pozitiflere yol açabilir, bu nedenle Number.isNaN önerilir.

1// NaN detection differences
2console.log(NaN === NaN);             // false
3
4console.log(isNaN("foo"));            // true  -> because "foo" coerces to NaN
5console.log(Number.isNaN("foo"));     // false -> "foo" is not the numeric NaN
6
7console.log(Number.isNaN(NaN));       // true

• Gereksiz tür dönüşümünden kaçınmak için sayıları kontrol ederken ve hesaplama sonuçlarını doğrularken Number.isNaN kullanın.

Kayan Noktalı Hatalar ve Number.EPSILON ile Karşılaştırmalar

IEEE-754 standardı nedeniyle, 0.1 + 0.2 !== 0.3 gibi hatalar meydana gelir. Kesin karşılaştırmalar için, farkı ve Number.EPSILON'ı kullanmak yaygındır.

1// Floating point precision example and EPSILON comparison
2const sum = 0.1 + 0.2;
3console.log(sum === 0.3);             // false
4
5function nearlyEqual(a, b, epsilon = Number.EPSILON) {
6  return Math.abs(a - b) <= epsilon * Math.max(1, Math.abs(a), Math.abs(b));
7}
8
9console.log(nearlyEqual(sum, 0.3));   // true

• Karşılaştırmada hata payı bırakılması gerekiyorsa, yalnızca mutlak farkı değil ölçeklemeyi de yapan nearlyEqual gibi sağlam bir uygulama önerilir.

Tam Sayılar ve Güvenli Tam Sayıların Kontrolü (isInteger, isSafeInteger)

Bir değerinin tam sayı olup olmadığını ve güvenli tam sayı aralığında bulunup bulunmadığını kontrol etmek için API'ler mevcuttur.

1// Integer and safe integer checks
2console.log(Number.isInteger(3));                 // true
3console.log(Number.isInteger(3.0));               // true
4console.log(Number.isInteger(3.1));               // false
5
6console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER)); // true
7console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)); // false

• Büyük tam sayılarda doğruluk gerektiğinde Number.isSafeInteger ile kontrol edin ve bu aralığı aşan sayılar için BigInt kullanmayı düşünün.

Görüntüleme ve Biçimlendirme: toFixed, toPrecision, toString

Sayıların görüntülenmesini kontrol etmek için kullanılabilecek yöntemler vardır. toFixed, belirtilen kadar ondalık haneye sahip bir dize döndürür, ancak yuvarlamaya dikkat edilmelidir.

1// Formatting numbers for display
2const x = 1.23456;
3console.log(x.toFixed(2));         // "1.23"   (string)
4console.log(x.toPrecision(3));     // "1.23"   (string with total significant digits)
5console.log((255).toString(16));   // "ff"     (hexadecimal string)

• toFixed bir dize döndürdüğünden, hesaplamalarda bunları tekrar sayıya dönüştürdükten sonraki değerlerine dikkat edin.

Dize Birleştirme ve + Operatörüyle İlgili Uyarılar

+ operatörü hem sayısal toplama hem de dize birleştirme için kullanıldığından, kullanılan veri türlerine bağlı olarak istenmeyen sonuçlar ortaya çıkabilir.

1// Pitfall with + operator and type coercion
2console.log(1 + 2 + "px");    // "3px"
3console.log("px" + 1 + 2);    // "px12"
4console.log(1 + "2" - 0);     // 3  (string coerced to number for subtraction)

• Dizeler ve sayılar karıştırıldığında, gizli tür dönüşümünü önlemek için String(), Number() veya şablon dizeleri açıkça kullanmak daha güvenlidir.

İleri Düzey Kullanımlar: Number.parseInt / Number.parseFloat, valueOf

Number.parseInt ve Number.parseFloat, global fonksiyonların takma adlarıdır. valueOf, bir Number nesnesinden ilkel değeri almak için kullanılır, ancak pratikte nadiren gereklidir.

1// Number.parseInt/parseFloat aliases and valueOf example
2console.log(Number.parseInt("100", 10));   // 100
3console.log(Number.parseFloat("3.14"));    // 3.14
4
5const nObj = new Number(5);
6console.log(nObj.valueOf());               // 5
7console.log(nObj + 1);                     // 6  (object coerced to primitive)

• Number.parseInt ve Number.parseFloat kullanırken tabana ve girdinin kırpılmasına dikkat edin. Sarmalayıcı nesneler genellikle kullanılmaz.

Referans: Küçük Yardımcı Örnek - Sayı Doğrulama Fonksiyonları

Burada, yaygın olarak kullanılan kontrolleri bir araya getiren küçük yardımcı fonksiyonlar yer alıyor. Bu, girdi doğrulama gibi işleri kolaylaştırır.

 1// Small number utility functions
 2function toNumberStrict(value) {
 3  // Return a Number or throw for invalid numeric strings
 4  const n = Number(value);
 5  if (typeof value === "string" && value.trim() === "") {
 6    throw new Error("Empty string is not a valid number");
 7  }
 8  if (Number.isNaN(n)) {
 9    throw new Error(`Invalid number: ${value}`);
10  }
11  return n;
12}
13
14function almostEqual(a, b, eps = Number.EPSILON) {
15  // Robust relative comparison
16  return Math.abs(a - b) <= eps * Math.max(1, Math.abs(a), Math.abs(b));
17}

• Bunlar, girdi işleme ve karşılaştırmalarda tekrar tekrar kullanılabilen çok yönlü fonksiyonlardır. Hata fırlatan uygulamalar doğrulama amacıyla faydalıdır.

Performans ve En İyi Uygulamaların Özeti

Number kullanırken aşağıdaki pratik noktalara dikkat edilmelidir.

• Temelde, ilkel number türünü kullanın ve new Number()'dan kaçının.
• Dizgiden sayıya dönüşümde, kullanım durumunuza göre Number() (kesin) veya parseInt/parseFloat (kısmi ayrıştırma) arasında seçim yapın.
• Güvenli kontrol için Number.isNaN ve Number.isFinite kullanın.
• Kayan noktalı karşılaştırmalar için Number.EPSILON veya özel bir karşılaştırma fonksiyonu kullanın.
• Tam sayı doğruluğu gerektiğinde Number.isSafeInteger kullanın, aralığı aşıyorsa BigInt kullanın.
• Görüntüde yuvarlama için toFixed veya toPrecision kullanabilirsiniz, ancak dönen değerin bir dize olduğunu unutmayın.

Özet

Number, JavaScript'teki tüm sayılar (tam sayılar, ondalıklar ve özel değerler (NaN ve Infinity)) için temel türdür. Tür dönüşümü ve kayan noktalı hataların farkında olmak ve Number.isNaN ile Number.EPSILON gibi yöntemleri doğru kullanmak önemlidir. Güvenli tam sayı aralığı aşılırsa BigInt kullanın, yuvarlama ve görüntüleme için toFixed veya toPrecision kullanı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