{} + [] = 0: JavaScript'te Sıfır Toplamının Gizemi

JavaScript, kendi içinde bazı tuhaf ve beklenmedik davranışlar sergileyebilir. Bu, özellikle tür dönüşümleri (type coercion) konusunda çok fazla soruşturma gerektiren bir dil. Pek çok geliştirici, JavaScript’in mantığını anladığını zannediyor ama bazı durumlarda bu güven kendini sorgulatıyor. Örneğin şu ifadeyi hiç düşündün mü?

{} + []

Evet, bu ifadeyi çalıştırdığınızda 0 sonucunu alırsınız. Ne kadar garip görünürse görsün, bu davranış bir hata değil. JavaScript’in garip ama mantıklı bir dünyası var. Bugün bu tuhaf durumun nedenini, nasıl çalıştığını ve neden böyle olduğunu detaylıca açıklayalım.

---

JavaScript’te {} Ne Demek?

JavaScript’te {} ifadesi bir nesne literal’ı olarak algılanabilir. Ancak dikkat! Bu ifade, ne zaman ve nasıl kullanıldığına göre tamamen farklı anlamlara sahip olabilir.

Bu özellikle ifadenin bir ifadenin başında (başlangıçta) kullanıldığı durumlarda ortaya çıkar. Örneğin:

{} + []

Bu ifadeyi yazdığınızda, JavaScript ilk olarak {} ifadesini bir boş blok olarak algılar. Yani bir işlevin içinde değilse, bir if, for veya function gibi bir yapı içinde değilse, {} bir blok olarak yorumlanır. Ve bu blok, hiçbir şey yapmaz. Sadece boş bir kod bloğudur.

Ama + [] kısmı, tekli artı operatörü (unary plus) ile birlikte değerlendirilir. Bu, JavaScript’in en iyi tür dönüşüm numaralarından biridir.

---

Unary Plus Operatörü ve Type Coercion

JavaScript, türleri zayıf bir şekilde (weakly typed) yönetir. Yani, bir değişkenin türünü otomatik olarak değiştirebilir. Bu, bazı durumlarda harika olabilir ama bazen kafa karıştırıcı olabilir.

+ [] ifadesi, JavaScript’in tür dönüşümü (type coercion) kurallarının mükemmel bir örneğidir. Unary plus operatörü, operandını sayıya çevirmeye çalışır. Yani:

+ []

ifadesi, JavaScript’in şu şekilde değerlendirmesini gerektirir:

1. [] bir dizidir.
2. Diziler birer nesnedir ve JavaScript, bir nesnenin sayısala dönüştürülmesi için önce bir temel değeri (primitive value) elde etmelidir.
3. Bu süreçte, JavaScript toString() metodunu çağırır.
4. [] dizisinin toString() sonucu: "" (boş string).
5. Sonra Number("") çalışır.
6. Number("") ise: 0.

Yani:

+ [] // 0

---

Peki, {} + [] Neden 0 Oluyor?

Artık bir şeyi anlıyoruz: {} bir boş bloktur ve hiçbir şey yapmaz. + [] ise 0 değerini verir. Yani:

{} + [] // 0

Bu ifade, JavaScript tarafından şu şekilde yorumlanır:

{} // Boş bir blok – herhangi bir şey yapmaz
+ [] // Unary plus, []'yi 0'a çevirir

Yani sonuçta sadece 0 döner.

Ama dikkat! Bu davranış yalnızca başlangıçta yazıldığında geçerlidir. Eğer bu ifade bir fonksiyon içinde, parantez içinde veya başka bir kontekste kullanılırsa, {} bir nesne literal’ı olarak yorumlanır. Örneğin:

({} + []) // "[object Object]"

Burada parantezler, {}'ın bir nesne literal’ı olarak yorumlanmasını sağlar. Bu durumda, {} + [] ifadesi [object Object] ile birleştirilir ve sonuç [object Object] olur.

---

Peki, [] + [] Ne olur?

Şimdi bir adım daha ileri gidelim. [] + [] ifadesini düşünün. Bu durumda, JavaScript iki boş diziyi birbirine ekliyor. Bu, binary + operatörüdür. Yani birleştirme (concatenation) işlemi yapılır.

[] dizileri önce stringe dönüştürülür:

[] + [] // "" + "" = ""

Yani sonuç: "" (boş string).

Yani:

[] + [] // ""

---

Peki, [] + {} Ne Olur?

Şimdi en ilginç kısmı görelim. [] + {} ifadesi ne olur?

Bu sefer, ilk önce [ ] boş string olur. Sonra {} nesnesi toString() metodunu çağırır. Her JavaScript nesnesinin toString() metodu var ve varsayılan olarak [object Object] döner.

Yani:

[] + {} // "" + "[object Object]" = "[object Object]"

Böylece sonuç: "[object Object]"

---

Komutatiflik Değil: Toplama İşlemi Değişiyor

Burada dikkat edilmesi gereken şey: {} + [] 0 dönerken, [] + {} [object Object] döner. Yani toplama işlemi komutatif değil!

Yani:

{} + [] // 0
[] + {} // "[object Object]"

Bu, matematikteki temel bir kuralın bile geçerli olmadığını gösterir. JavaScript’teki bu davranış, ifadeye göre tür dönüşümünün nasıl işlediğini gösterir.

---

JavaScript’in Zayıf Tip Sistemi

JavaScript’in bu tür davranışları, tür dönüşümünün zayıf tip sistemi nedeniyledir. JavaScript, bazı durumlarda kendi kendine türleri değiştirir. Bu, geliştiricilerin çok sık hata yapmasına neden olabilir. Ancak aynı zamanda, bazı durumlarda çok da etkileyici olabilir.

Örneğin:

"5" + 2 // "52"
5 + "2" // "52"
5 + 2   // 7

İki sayı toplanır. Ama biri stringse, birleştirme işlemi yapılır. Bu, JavaScript’in tip sistemini anlamak için çok önemli bir başlangıç noktasıdır.

---

Sonuç: JavaScript Kırık mı?

Hayır. JavaScript kırık değil. Sadece çok fazla eski kodu desteklemek zorunda. Bu yüzden bazı tuhaf davranışlar var. Ancak bunlar bir hata değil, sadece tür dönüşümünün bir sonucudur.

JavaScript, 1995’te sadece 10 gün içinde geliştirilmiş bir dildir. Ve o zamandan bu yana, hem web hem de geliştirme dünyasında devrim yaratmıştır. Bu nedenle, bazı tuhaf davranışları da kabul etmek zorundayız.

---

Özetle

• {} + [] ifadesi, JavaScript’te 0 döner çünkü {} bir boş blok, + [] ise 0’a dönüştürülür.
• [] + {} ifadesi ise [object Object] döner çünkü dizi boş bir stringe, nesne de [object Object] stringine dönüşür.
• JavaScript’in tür dönüşümü kuralları, bazen garip ama mantıklı olabilir.
• Bu durumlar, JavaScript’te ne zaman ve nasıl bir ifade yazıldığının çok önemli olduğunu gösterir.

JavaScript, sadece bir dildir. Ama aynı zamanda bir dönüşüm sanatıdır. Ve bazen bu sanat, bizi şaşırtıyor. Ama aynı zamanda, haklı olabiliyor.

---

İpucu: Eğer bu tür durumlardan kaçınmak istiyorsan, parantezlerle kodunuzu açıkça belirtin. Böylece JavaScript’in hangi şekilde yorumladığını kontrol edebilirsiniz.

({} + []) // "[object Object]"
[] + {}     // "[object Object]"
{} + []     // 0 (sadece başlangıçta)

JavaScript’i sev, ya da kınala. Ama asla kurtulma. Çünkü, web bu dilin sayesinde var.