Concurrency to Eşzamanlılık

README.md

@@ -901,41 +901,41 @@ inventoryTracker('apples', req, 'www.inventory-awesome.io');
 ```
 **[⬆ en başa dön](#içindekiler)**
 
-## **Objects and Data Structures**
-### Use getters and setters
-Using getters and setters to access data on objects could be better than simply
-looking for a property on an object. "Why?" you might ask. Well, here's an
-unorganized list of reasons why:
+## **Nesneler ve Veri Yapıları**
+### Get ve Set erişimcilerini Kullanın.
+Nesne üzerindeki veriye ulaşmak için erişim belirleyicilerini kullanmak ,
+basitçe nesne üzerinde bir özelliği aramaktan daha iyidir. 
+"Neden?" diye sorabilirsin.O halde sana neden olabileceğini gösteren düzensiz bir liste:
 
-* When you want to do more beyond getting an object property, you don't have
-to look up and change every accessor in your codebase.
-* Makes adding validation simple when doing a `set`.
-* Encapsulates the internal representation.
-* Easy to add logging and error handling when getting and setting.
-* You can lazy load your object's properties, let's say getting it from a
-server.
+* Bir nesnenin özelliğini elde etmenin ötesinde daha fazlasını yapmak istiyorsan,tüm koda bakıp
+her erişimciyi değiştirmene gerek yok.
+* `set` kullandığında,doğrulama eklemesi kolaylaşır.
+* Dahili tasarımı kapsüller.
+* Get ve Set erişimcilerini kullandığıngda raporlama ve hata denetimi kolaylaşır.
+* Nesne özelliklerini, sadece kullanılacağı zaman çalışmasını sağlayabilirsin,örnek olarak
+onu sunucudan almak.
 
 
 **Kötü:**
 ```javascript
-function makeBankAccount() {
+function bankaHesapOlustur() {
   // ...
 
   return {
-    balance: 0,
+    bakiye: 0,
     // ...
   };
 }
 
-const account = makeBankAccount();
-account.balance = 100;
+const hesap = bankaHesapOlustur();
+hesap.bakiye = 100;
 ```
 
 **İyi:**
 ```javascript
-function makeBankAccount() {
-  // this one is private
-  let balance = 0;
+function bankaHesapOlustur() {
+  // bu özellik gizli.
+  let bakiye = 0;
 
   // a "getter", made public via the returned object below
   function getBalance() {
@@ -1717,25 +1717,25 @@ describe('MakeMomentJSGreatAgain', () => {
 ```
 **[⬆ en başa dön](#içindekiler)**
 
-## **Concurrency**
-### Use Promises, not callbacks
-Callbacks aren't clean, and they cause excessive amounts of nesting. With ES2015/ES6,
-Promises are a built-in global type. Use them!
+## **Eşzamanlılık**
+### Callback yerine Promise kullanın
+Callbackler kusursuz değildir , ve aşırı miktarda iç içe geçmeye neden olurlar. ES2015/ES6
+ile birlikte Promiseler bir yerleşik evrensel tiptir.. Onları kullan!
 
 **Kötü:**
 ```javascript
 import { get } from 'request';
 import { writeFile } from 'fs';
 
-get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin', (requestErr, response) => {
+get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin', (istekHatasi, cevap) => {
   if (requestErr) {
-    console.error(requestErr);
+    console.error(istekHatasi);
   } else {
-    writeFile('article.html', response.body, (writeErr) => {
-      if (writeErr) {
-        console.error(writeErr);
+    writeFile('makale.html', cevap.body, (yazmaHatasi) => {
+      if (yazmaHatasi) {
+        console.error(yazmaHatasi);
       } else {
-        console.log('File written');
+        console.log('Dosya yazildi');
       }
     });
   }
@@ -1749,25 +1749,25 @@ import { get } from 'request';
 import { writeFile } from 'fs';
 
 get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin')
-  .then((response) => {
-    return writeFile('article.html', response);
+  .then((cevap) => {
+    return writeFile('makale.html', cevap);
   })
   .then(() => {
-    console.log('File written');
+    console.log('Dosya yazildi');
   })
-  .catch((err) => {
-    console.error(err);
+  .catch((hata) => {
+    console.error(hata);
   });
 
 ```
 **[⬆ en başa dön](#içindekiler)**
 
-### Async/Await are even cleaner than Promises
-Promises are a very clean alternative to callbacks, but ES2017/ES8 brings async and await
-which offer an even cleaner solution. All you need is a function that is prefixed
-in an `async` keyword, and then you can write your logic imperatively without
-a `then` chain of functions. Use this if you can take advantage of ES2017/ES8 features
-today!
+### Async/Await ,Promise'den daha temizdir.
+Promiseler Callbacklere nazaran daha temizdir, fakat ES2017/ES8 daha 
+temiz bir çözüm sunan async await'i getirdi. Tek ihtiyacın `async` önekine sahip bir fonksiyon, 
+ve sonrasında `then`li fonksiyonlar zincirini kullanmaksızın 
+mantığını zorunlu olarak yazabilirsin. ES2017 / ES8 özelliklerinden yararlanabiliyorsanız bunu
+bugün kullanın!.
 
 **Kötü:**
 ```javascript
@@ -1775,14 +1775,14 @@ import { get } from 'request-promise';
 import { writeFile } from 'fs-promise';
 
 get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin')
-  .then((response) => {
-    return writeFile('article.html', response);
+  .then((cevap) => {
+    return writeFile('makale.html', cevap);
   })
   .then(() => {
-    console.log('File written');
+    console.log('Dosya yazildi');
   })
-  .catch((err) => {
-    console.error(err);
+  .catch((hata) => {
+    console.error(hata);
   });
 
 ```
@@ -1792,13 +1792,13 @@ get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin')
 import { get } from 'request-promise';
 import { writeFile } from 'fs-promise';
 
-async function getCleanCodeArticle() {
+async function temizKodMakalesiniAl() {
   try {
-    const response = await get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin');
-    await writeFile('article.html', response);
-    console.log('File written');
-  } catch(err) {
-    console.error(err);
+    const cevap = await get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin');
+    await writeFile('makale.html', cevap);
+    console.log('Dosya yazildi');
+  } catch(hata) {
+    console.error(hata);
   }
 }
 ```