translated core

Author: oozcitak

doc/tr/core/eval.md

@@ -0,0 +1,48 @@
+## Neden `eval` kullanılmamalı
+
+`eval` fonksiyonu bir JavaScript kodunu lokal kapsamda yürütür.
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        eval('foo = 3');
+        return foo;
+    }
+    test(); // 3
+    foo; // 1
+
+Fakat `eval` sadece **direkt olarak** çağrıldığında *ve* çağrılan fonksiyonun
+adı `eval` ise lokal kapsamda çalışır.
+
+    var foo = 1;
+    function test() {
+        var foo = 2;
+        var bar = eval;
+        bar('foo = 3');
+        return foo;
+    }
+    test(); // 2
+    foo; // 3
+
+`eval` fonksiyonu **asla** kullanılmamalıdır. Kullanıldığı durumların %99.9'unda
+`eval` **kullanılmadan** da istenen sonuç elde edilebilir.
+    
+### Gizli `eval`
+
+[Zamanlama fonksiyonları](#other.timeouts) `setTimeout` ve `setInterval`'ın her
+ikisinin de ilk argümanları bir karakter katarıdır. Bu durumda `eval` dolaylı
+olarak çağrıldığı için bu argüman **her zaman** genel kapsamda yürütülecektir.
+
+### Güvenlik sorunları
+
+`eval` kendisine verilen **her** kodu işlettiği için aynı zamanda bir güvenlik
+sorunudur ve **asla** kaynağı bilinmeyen yada güvenilir olmayan karakter
+katarları ile kullanılmamalıdır.
+
+### Sonuç
+
+`eval` asla kullanılmamalıdır, kullanan programlar ise doğruluk, performans ve
+güvenlik açılarından sorgulanmalıdır. `eval` kullanımı gerekli görülmüşse, 
+programın tasarımı sorgulanmalı ve **kullanılmamalı**, bunun yerine `eval`
+gerektirmeyen *daha iyi bir tasarım* kullanılmalıdır.
+

doc/tr/core/semicolon.md

@@ -0,0 +1,118 @@
+## Otomatik noktalı virgül ilavesi
+
+JavaScript sentaksı C'ye benzese de, noktalı virgül kullanılması
+zurunlu **değildir**.
+
+Fakat JavaScript noktalı virgül kullanmayan bir dil değildir, hatta
+programı anlayabilmek için noktalı virgüllere ihtiyaç duyar. Bu yüzden
+JavaScript gramer çözümleyicisi eksik bir noktalı virgül yüzünden bir
+hata ile karşılaştığında **otomatik olarak** eksik noktalı virgülleri
+ekler.
+
+    var foo = function() {
+    } // hata, noktalı virgül gerekiyor
+    test()
+
+Eklemeden sonra çözümleme tekrarlanır.
+
+    var foo = function() {
+    }; // hata ortadan kalktı, çözümleme devam edebilir
+    test()
+
+Noktalı virgüllerin bu şekilde otomatik olarak eklenmesi JavaScript'in
+**en büyük** tasarım hatalarından biri olarak kabul edilir, çünkü programın
+davranışını değiştirmesi *mümkündür*.
+
+### Ekleme nasıl olur
+
+Aşağıdaki örnekte hiç noktalı virgül yok, bu yüzden nereye noktalı virgül
+eklenmesi gerektiğini gramer çözümleyicinin karar vermesi gerekiyor.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+
+            (options.list || []).forEach(function(i) {
+
+            })
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+
+    })(window)
+
+    (function(window) {
+        window.someLibrary = {}
+
+    })(window)
+
+Çözümleyicinin "tahmin" oyununun sonucu aşağıdadır.
+
+    (function(window, undefined) {
+        function test(options) {
+
+            // Eklenmedi, satırlar birleştirildi
+            log('testing!')(options.list || []).forEach(function(i) {
+
+            }); // <- eklendi
+
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- eklendi
+
+            return; // <- eklendi, return ifadesi bozuldu
+            { // bir blok olarak değerlendirildi
+
+                // bir yer etiketi ve bir ifade
+                foo: function() {} 
+            }; // <- eklendi
+        }
+        window.test = test; // <- eklendi
+
+    // Burada da satırlar birleştirildi
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- eklendi
+
+    })(window); //<- eklendi
+
+> **Not:** JavaScript çözümleyicisi `return` ifadesinden heme sonra satır sonu
+> gelmesi durumunu "doğru" değerlendirmez. Bu durum otomatik noktalı virgül
+> eklenmesinin istenmeyen bir yan etkisidir.
+
+Çözümleyici yukarıdaki program parçasının davranışını büyük ölçüde değiştirdi,
+belirli durumlarda da grameri değerlendirirken **yanlış** kararlar verdi.
+
+### Satır başındaki parantezler
+
+Bir satırın parantez ile başlaması durumunda, çözümleyici noktalı virgül
+**eklemez**.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Yukarıdaki program parçası aşağıdaki tek satıra dönüşür.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+**Büyük** ihtimalle yukarıdaki `log` bir fonksiyon **döndürmüyordur**;
+bu nedenle, yukarıdaki satır `undefined is not a function` hata mesajı ile bir
+`TypeError` oluştumasına neden olacaktır.
+
+### Sonuç
+
+Noktalı virgüllerin **hiç bir zaman** ihmal edilmemesi tavsiye olunur, ayrıca
+ayraçların kendilerinden önceki ifade ile aynı satırda tutulması ve tek satırlık
+`if` ve `else` ifadelerinde bile ayraçların ihmal edilmemesi önerilir. Her iki
+önlem de hem programın tutarlılığını artıracak, hem de JavaScript
+çözümleyicisinin programın davranışını değiştirmesini engelleyecektir.
+

doc/tr/core/undefined.md

@@ -0,0 +1,71 @@
+## `undefined` ve `null`
+
+JavaScript'te `tanımsız` anlamına gelen iki değer vardır, ve bunlardan
+`undefined` daha kullanışlıdır.
+
+### `undefined` değeri
+
+`undefined` bir değişken türüdür ve tek bir değere sahip olabilir: `undefined`.
+
+JavaScript'te ayrıca değeri `undefined` olan bir de genel kapsam değişkeni
+tanımlanmıştır ve bu değişkenin adı da `undefined`'dır. Fakat bu değişken
+bir sabit yada dilin anahtar kelimelerinden biri **değildir**. Yani bu
+değişkenin *değeri* kolayca değiştirilebilir.
+
+> **ES5 Notu:** ECMAScript 5'e göre mutlak modda `undefined`'ın değeri
+> *değiştirilemez*, fakat mesela adı `undefined` olan bir fonksiyon ile 
+> `undefined` değişkeni gizlenebilir.
+
+`undefined` değerinin verildiği durumlara bazı örnekler:
+
+ - Genel kapsamlı `undefined` değişkeninin (değiştirilmedi ise) değeri
+ - `return` ifadesi içermeyen fonksiyonların verdiği değer
+ - Bir değer döndürmeyen `return` ifadeleri
+ - Mevcut olmayan nesne özellikleri
+ - Değer atanmamış fonksiyon parametreleri
+ - Değeri `undefined` olarak atanmış değişkenler
+
+### `undefined` değerinin değiştirilmesi durumu
+
+Genel kapsamdaki `undefined` değişkeni asıl `undefined` *değerinin* kopyasını
+tuttuğu için, bu değeri değiştirmek `undefined` *değişken türünün* değerini
+**değiştirmez**.
+
+Fakat, bir şeyi `undefined` ile karşılaştırmak için önce `undefined`'ın değerini
+geri almak gerekir.
+
+Programı `undefined` değişkeninin değiştirilmesi olasılığına karşı korumak için
+uygulanan yaygın bir yöntem [isimsiz bir fonksiyona](#function.scopes) 
+kullanılmayan bir parametre eklemektir.
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // lokal kapsamda undefined değişkeni
+        // yine undefined değerine sahip
+
+    })('Hello World', 42);
+
+Benzer bir yöntem yine isimsiz fonksiyonun içinde değer atanmamış bir değişken
+deklare etmektir.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+Buradaki tek fark program sıkıştırılırsa ortaya çıkacaktır, eğer fonksiyonun 
+başka bir yerinde `var` ifadesi kullanılmıyorsa fazladan 4 bayt kullanılmış
+olacaktır.
+
+### `null` kullanımı
+
+JavaScript dilinde `undefined` geleneksel *null* yerine kullanılmaktadır, asıl
+`null` (hem `null` değişmezi hem de değişken türü) ise kabaca başka bir
+veri türüdür.
+
+`null` JavaScript içindeki kapalı olarak kullanılır (mesela prototip zincirinin
+sonuna gelindiği `Foo.prototype = null` ile belirtilir), fakat hemen her durumda
+bunun yerine `undefined` kullanılabilir.
+