Merge branch 'oozcitak-tr'

Author: BonsaiDen

doc/tr/array/constructor.md

@@ -0,0 +1,35 @@
+## `Array` Oluşturucusu
+
+`Array` oluşturucusunun parametrelerini nasıl değerlendirdiği belirsiz olduğu
+için, yeni diziler oluşturulurken her zaman dizi sabitlerinin (`[]` 
+notasyonu) kullanılması tavsiye olunur.
+
+    [1, 2, 3]; // Sonuç: [1, 2, 3]
+    new Array(1, 2, 3); // Sonuç: [1, 2, 3]
+
+    [3]; // Sonuç: [3]
+    new Array(3); // Sonuç: []
+    new Array('3') // Sonuç: ['3']
+
+`Array` oluşturucusuna tek bir argüman verildiğinde, ve bu argümanın türü
+`Number` ise, oluşacak *boş* dizinin `length` özelliği argümanın
+değerine eşit olacaktır. Bu şekilde oluşturulan bir dizinin **sadece**
+`length` özelliği belirlenmiş olup dizi indisleri tanımsız olacaktır.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // false, indisler atanmadı
+
+Dizinin uzunluğunu bu şekilde önceden belirlemek sadece bir iki durumda 
+kullanışlıdır. Bunlardan birisi bir döngüye gerek olmadan bir karakter
+katarını tekrarlamaktır.
+
+    new Array(count + 1).join(stringToRepeat);
+
+### Sonuç
+
+`Array` oluşturucusunun kullanılmasından mümkün olduğu kadar kaçınılmalıdır.
+Bunun yerine her zaman dizi sabitleri tercih edilmelidir. Hem daha kısadırlar
+hem de daha anlaşılır bir sentaksa sahiptirler; bu nedenle programın
+okunabilirliğini de artırırlar.
+

doc/tr/array/general.md

@@ -0,0 +1,58 @@
+## Dizi İterasyonu ve Özellikleri
+
+Diziler JavaScript nesneleri olmalarına rağmen, iterasyon yapmak için
+[`for in`](#object.forinloop) döngüsü kullanmak için bir neden yoktur.
+Aslında dizilerde  `for in` kullanılmasına **karşı** bazı iyi nedenler
+vardır.
+
+> **Not:** JavaScript dizileri *associative* **değildir**. JavaScript ile sadece
+> [nesneler](#object.general) ile anahtar-değer ilişkilendirmesi mümkündür.
+> Ve *associative* diziler eleman sıralamasını **korurlar** ama, nesneler
+> **korumazlar**.
+
+`for in` döngüsü prototip zincirindeki tüm özellikleri dolaştığı için ve bunu
+engellemenin tek yolu [`hasOwnProperty`](#object.hasownproperty) kullanmak
+olduğu için `for in` döngüsü sıradan bir `for` döngüsünden **yirmi kata kadar**
+daha yavaştır.
+
+### İterasyon
+
+Dizilerde iterasyon yaparken en iyi performansı elde etmenin en iyi yolu klasik
+`for` döngüsünü kullanmaktır.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+Yukarıdaki örnekte bir optimizasyon var, o da dizinin uzunluğun iterasyonun
+başında `l = list.length` ile saklanmış olması.
+
+`length` özelliği dizinin kendisinde tariflenmiş olmasına rağmen, her adımda
+bu özelliği okumanın yine de bir maliyeti vardır. Modern JavaScript motorları
+bu tür durumlar için **muhtemelen** optimizasyon yapıyor olsa bile, programın 
+her zaman modern bir motorda çalışacağından emin olmak mümkün değildir.
+
+Aslında, yukarıdaki örnekteki optimizasyonu uygulamamak döngünün 
+**iki kat daha** yavaş çalışmasına neden olabilir.
+
+### `length` özelliği
+
+`length` özelliğine değer atanarak diziyi **kısaltmak** için kullanılabilir.
+
+    var foo = [1, 2, 3, 4, 5, 6];
+    foo.length = 3;
+    foo; // [1, 2, 3]
+
+    foo.length = 6;
+    foo; // [1, 2, 3]
+
+Daha küçük bir uzunluk atanması diziyi kısaltır, fakat daha büyük bir uzunluk
+atanmasının dizi üzerinde bir etkisi yoktur.
+
+### Sonuç
+
+En iyi performans için her zaman sıradan `for` döngüsü kullanılmalı ve 
+`length` özelliği saklanmalıdır. Dizilerde `for in` döngüsünün kullanılmış
+olması hatalara meyilli kötü yazılmış bir programa işaret eder.
+

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 İlavesi
+
+JavaScript sentaksı C'ye benzese de, noktalı virgül kullanılması
+zorunlu **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 hemen 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 edilir, 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çinde 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.
+