translated objects section

Author: gnwx

tr/objects/README.md

@@ -0,0 +1,36 @@
+---
+layout: editorial
+chapter: 9
+pageNumber: 56
+---
+
+# Bölüm 9
+
+# Objects (Objeler)
+
+JavaScript'te objeler **değişkendir**, çünkü referans objeye işaret eden değerleri değiştiririz. Bunun yerine, bir ilkel değeri değiştirirken, referansını değiştiriyoruz, bu da şimdi yeni değere işaret ediyor ve bu nedenle ilkel **değişmezdir**. JavaScript'in ilkel türleri `true`, `false`, `numbers`, `strings`, `null` ve `undefined`'dir. Herhangi bir diğer değer bir `obje`dir. Objeler, `propertyName`: `propertyValue` çiftleri içerir. JavaScript'te bir `obje` oluşturmanın üç yolu vardır:
+
+1.  literal
+
+    ```javascript
+    let object = {};
+    // Evet, sadece bir çift süslü parantez!
+    ```
+
+    > _**Not:**_ bu **önerilen** yoldur.
+
+2.  nesne yönelimli
+
+    ```javascript
+    let object = new Object();
+    ```
+
+    > _**Not:**_ Java'ya çok benzer.
+
+3.  ve `object.create` kullanarak
+
+    ```javascript
+    let object = Object.create(proto[, propertiesObject]);
+    ```
+
+    > _**Not:**_ bu, belirtilen prototip nesnesi ve özellikleriyle yeni bir obje oluşturur.

tr/objects/delete.md

@@ -0,0 +1,36 @@
+---
+chapter: 9
+pageNumber: 62
+---
+
+# Delete (Silmek)
+
+Bir objeden **bir özelliği** kaldırmak için `delete` özelliği kullanılabilir. Bir özellik silindiğinde, objeden kaldırılır ve erişilemez veya numaralandırılamaz (yani, bir for-in döngüsünde görünmez).
+
+İşte `delete` kullanımı için sözdizimi:
+
+```javascript
+delete object.property;
+```
+
+Örneğin:
+
+```javascript
+let adult = { age: 26 },
+  child = Object.create(adult);
+
+child.age = 8;
+
+delete child.age;
+
+/* Remove age property from child, revealing the age of the prototype, because then it is not overriden. */
+
+let prototypeAge = child.age;
+// 26, because child does not have its own age property.
+```
+
+{% hint style="warning" %}
+`delete` operatörü sadece bir objenin kendi özellikleri üzerinde çalışır, miras alınan özellikler üzerinde çalışmaz. Ayrıca `configurable` niteliği `false` olarak ayarlanmış özellikler üzerinde de çalışmaz.
+{% endhint %}
+
+`delete`operatörü objenin prototip zincirini (**prototype chain**) değiştirmez. Sadece belirtilen özelliği objeden kaldırır ve ayrıca objeyi veya özelliklerini gerçekten yok etmez. Sadece özellikleri erişilemez hale getirir. Bir nesneyi yok etmeniz ve belleğini serbest bırakmanız gerekiyorsa, nesneyi `null` olarak ayarlayabilir veya belleği geri almak için bir çöp toplayıcı kullanabilirsiniz.

tr/objects/enumeration.md

@@ -0,0 +1,48 @@
+---
+chapter: 9
+pageNumber: 63
+---
+
+# Enumeration (Numaralandırma)
+
+_Enumeration_ (Numaralandırma), bir objenin özelliklerini yinelemek ve her özellik için belirli bir eylemi gerçekleştirme işlemine atıfta bulunur. JavaScript'te bir objenin özelliklerini numaralandırmanın birkaç yolu vardır.
+
+Bir objenin özelliklerini numaralandırmanın bir yolu, `for-in` döngüsünü kullanmaktır. `for-in` döngüsü, bir objenin enumerable özelliklerini rastgele bir sırayla yineler ve her özellik için bir blok kodunu çalıştırır.
+
+`for in` ifadesi, bir objedeki tüm özellik adlarını yineleyebilir. Numaralandırma, fonksiyonları ve prototip özelliklerini içerecektir.
+
+```javascript
+let fruit = {
+    apple: 2,
+    orange: 5,
+    pear: 1,
+  },
+  sentence = "I have ",
+  quantity;
+for (kind in fruit) {
+  quantity = fruit[kind];
+  sentence += quantity + " " + kind + (quantity === 1 ? "" : "s") + ", ";
+}
+// The following line removes the trailing comma.
+sentence = sentence.substr(0, sentence.length - 2) + ".";
+// I have 2 apples, 5 oranges, 1 pear.
+```
+
+Bir objenin özelliklerini numaralandırmanın başka bir yolu, `Object.keys()` yöntemini kullanmaktır. Bu yöntem, objenin kendi enumerable özellik adlarının bir diziini döndürür.
+
+Örneğin:
+
+```typescript
+let object = {
+  foo: "bar",
+  baz: "qux",
+};
+
+let properties = Object.keys(object);
+properties.forEach(function (property) {
+  console.log(property + ": " + object[property]);
+});
+
+// foo: bar
+// baz: qux
+```

tr/objects/mutable.md

@@ -0,0 +1,33 @@
+---
+chapter: 9
+pageNumber: 58
+---
+
+# Mutable (Değişebilirlik)
+
+Objeler ve primitive (_ilkel_) değerler arasındaki fark, **objeleri değiştirebileceğimiz**, ancak primitive (_ilkel_) değerlerin **değiştirilemez** olmasıdır.
+
+Örneğin:
+
+```javascript
+let myPrimitive = "first value";
+myPrimitive = "another value";
+// myPrimitive şimdi başka bir dizeye işaret ediyor.
+let myObject = { key: "first value" };
+myObject.key = "another value";
+// myObject aynı objeye işaret ediyor.
+```
+
+Bir objenin özelliklerini nokta veya köşeli ayraç gösterimi kullanarak ekleyebilir, değiştirebilir veya silebilirsiniz.
+
+```javascript
+let object = {};
+object.foo = "bar"; // Add property 'foo'
+object["baz"] = "qux"; // Add property 'baz'
+object.foo = "quux"; // Modify property 'foo'
+delete object.baz; // Delete property 'baz'
+```
+
+{% hint style="warning" %}
+Primitive (_ilkel_) değerler (sayılar ve dizeler gibi) değişmezken, objeler (diziler ve objeler gibi) değişebilirdir.
+{% endhint %}

tr/objects/properties.md

@@ -0,0 +1,47 @@
+---
+chapter: 9
+pageNumber: 57
+---
+
+# Properties (Obje Özellikleri)
+
+Obje özelliği, `propertyName`: `propertyValue` çiftidir, burada **özellik adı yalnızca bir dize olabilir**. Bir dize değilse, bir dizeye dönüştürülür. Özellikleri bir obje **oluştururken** veya **daha sonra** belirtebilirsiniz. Virgülle ayrılmış sıfır veya daha fazla özellik olabilir.
+
+```javascript
+let language = {
+  name: "JavaScript",
+  isSupportedByBrowsers: true,
+  createdIn: 1995,
+  author: {
+    firstName: "Brendan",
+    lastName: "Eich",
+  },
+  // Yes, objects can be nested!
+  getAuthorFullName: function () {
+    return this.author.firstName + " " + this.author.lastName;
+  },
+  // Yes, functions can be values too!
+};
+```
+
+Aşağıdaki kod, bir özelliğin değerini nasıl elde edeceğinizi gösterir.
+
+```javascript
+let variable = language.name;
+// variable şimdi "JavaScript" dizesini içeriyor.
+
+variable = language["name"];
+// Yukarıdaki satırlar aynı şeyi yapar. Fark, ikincisinin bir özellik adı olarak herhangi bir dize kullanmasına izin vermesidir, ancak okunması daha az kolaydır.
+
+variable = language.newProperty;
+// variable şimdi undefined, çünkü bu özelliği henüz atamamıştık.
+```
+
+Aşağıdaki örnek, yeni bir özellik **ekleme** veya **mevcut olanı değiştirme** işlemini nasıl yapacağınızı gösterir.
+
+```javascript
+language.newProperty = "new value";
+// Artık objede yeni bir özellik var. Özellik zaten varsa, değeri değiştirilecektir.
+language["newProperty"] = "changed value";
+// Yine, özellikleri her iki şekilde de erişebilirsiniz. İlki (noktalama notasyonu) önerilir.
+```

tr/objects/prototype.md

@@ -0,0 +1,51 @@
+---
+chapter: 9
+pageNumber: 61
+---
+
+# Prototype (Prototip)
+
+Her obje, bir prototip objeye bağlıdır ve bu objeden özellikler miras alır. `{}` nesnel literallerden oluşturulan nesneler, JavaScript ile birlikte gelen bir obje olan `Object.prototype`'a otomatik olarak bağlanır.
+
+Bir JavaScript yorumlayıcısı (tarayıcınızdaki bir modül), aşağıdaki kodda olduğu gibi, almak istediğiniz bir özelliği bulmaya çalıştığında:
+
+```javascript
+let adult = { age: 26 },
+  retrievedProperty = adult.age;
+// The line above
+```
+
+Öncelikle, yorumlayıcı, objenin kendisinin sahip olduğu her özelliği kontrol eder. Örneğin, `adult`'ın yalnızca bir kendi özelliği vardır — `age`. Ancak bunun dışında, aslında `Object.prototype`'dan devralınan birkaç özelliği daha vardır.
+
+```javascript
+let stringRepresentation = adult.toString();
+// the variable has value of '[object Object]'
+```
+
+`toString` , devralınan bir Object.prototype özelliğidir. Bir objenin string temsilini döndüren bir fonksiyonun değerine sahiptir. Daha anlamlı bir temsil döndürmek istiyorsanız, bunu geçersiz kılabilirsiniz. Sadece adult nesnesine yeni bir özellik ekleyin.
+
+```javascript
+adult.toString = function () {
+  return "I'm " + this.age;
+};
+```
+
+Şimdi `toString` fonksiyonunu çağırırsanız, yorumlayıcı objenin kendisinde yeni özelliği bulacak ve duracaktır.
+
+Yorumlayıcı, nesnenin kendisinden ve daha sonra prototipi boyunca bulacağı ilk özelliği alır.
+
+Varsayılan Object.prototype yerine kendi nesnenizi prototip olarak ayarlamak için `Object.create`'ı şu şekilde çağırabilirsiniz:
+
+```javascript
+let child = Object.create(adult);
+/* Bu şekilde nesneler oluşturma, varsayılan Object.prototype'u istediğimiz ile kolayca değiştirmemizi sağlar. Bu durumda, child'ın prototipi adult objesidir. */
+
+child.age = 8;
+/* Daha önce, child'ın kendi age özelliği yoktu ve yorumlayıcı bunu bulmak için child'ın prototipine bakmak zorunda kaldı.
+Şimdi, child'ın kendi yaşını ayarladığımızda, yorumlayıcı daha ileri gitmeyecek.
+Not: adult'ın yaşı hala 26. */
+let stringRepresentation = child.toString();
+/* Not: child'ın toString özelliğini geçersiz kılmadık, bu nedenle adult'ın yöntemi çağrılacak. adult'ın toString özelliği yoksa, Object.prototype'un toString yöntemi çağrılacak ve "[object Object]" yerine "I'm 8" alacağız. */
+```
+
+`child`'ın prototipi `adult`, `adult`'ın prototipi ise `Object.prototype`'dur. Bu prototipler dizisi **prototip zinciri** olarak adlandırılır.

tr/objects/reference.md

@@ -0,0 +1,65 @@
+---
+chapter: 9
+pageNumber: 59
+---
+
+# Reference (Referans)
+
+Objeler **asla kopyalanmaz**. Referansla iletilir. Obje referansı, bir nesneye atıfta bulunan bir değerdir. `new` operatörü veya nesne literal sözdizimi kullanarak bir nesne oluşturduğunuzda, JavaScript bir nesne oluşturur ve ona bir referans atar.
+
+İşte obje literal sözdizimi kullanarak bir nesne oluşturma örneği:
+
+```css
+var object = {
+  foo: "bar";
+}
+```
+
+İşte `new` operatörü kullanarak bir nesne oluşturma örneği:
+
+```typescript
+var object = new Object();
+object.foo = "bar";
+```
+
+Bir nesne referansını bir değişkene atadığınızda, değişken yalnızca nesneye referans tutar, nesneyi kendisini değil. Bu, nesne referansını başka bir değişkene atarsanız, her iki değişkenin de aynı nesneye işaret edeceği anlamına gelir.
+
+Örneğin:
+
+```javascript
+var object1 = {
+  foo: "bar",
+};
+
+var object2 = object1;
+
+console.log(object1 === object2); // Sonuç: true
+```
+
+Yukarıdaki örnekte, `obje1` ve `obje2` hem aynı nesneye referans tutan değişkenlerdir. `===` operatörü referansları karşılaştırmak için kullanılır, nesneleri değil ve her iki değişkenin de aynı nesneye referans tuttuğu için `true` döndürür.
+
+{% hint style="info" %}
+`Object.assign()` yöntemini kullanarak, var olan bir nesnenin kopyası olan yeni bir nesne oluşturabilirsiniz.
+{% endhint %}
+
+Aşağıda referansla bir nesne örneği verilmiştir.
+
+```javascript
+// Bir pizzam olduğunu düşünelim
+let myPizza = { slices: 5 };
+// Ve onu sizinle paylaştım
+let yourPizza = myPizza;
+// Ben bir dilim daha yiyorum
+myPizza.slices = myPizza.slices - 1;
+let numberOfSlicesLeft = yourPizza.slices;
+// Şimdi 4 dilimiz var çünkü myPizza ve yourPizza
+// aynı pizza nesnesine referans verin.
+let a = {},
+  b = {},
+  c = {};
+// a, b ve c her biri
+// farklı boş nesne
+a = b = c = {};
+// a, b ve c hepsi
+// aynı boş nesneye referans verin
+```