ES6 let Anahtar Kelimesi

Giriş
Bir  değişkenin sadece bir kere tanımlanabilmesini sağlar. Açıklaması şöyle

..."let" scopes your variable to the block (or, "locally", more or less meaning "in the brackets") in which you declare it.

If you declare a variable without "let", it scopes the variable globally.

Örnek - scope
let ve var anahtar kelimeleri değişkene scope getirir. Elimizde şöyle bir kod olsun. Burada b ve c let ile tanımlanmadıkları için global kabul edilirler ve second() metodu için görünür olurlar. Ancak a ve d değişkenleri let ile tanımlandıkları için yerel kabul edilirler ve second() metodu tarafından ulaşılamazlar.

function first() {
   let a = b = c = 10;
   var d = 20;
   second();
}

function second() {
   alert(b + ", " + c); //shows "10, 10"
   alert(a); //reference error
   alert(d); //reference error
}

Örnek - nesne tanımlama

Şöyle yaparız. Burada let ile ismi question olan bir nesne tanımlanıyır ve if/else ile kullanlıyor.

let currentIndex = 1;

let index = 2;

let question = {
    visited: true,
    review: false,
    selected_answer: null
}

let output = '';


if(currentIndex == index){
    output = 'question-box bg-red-box'
} else if (question.visited) {
    if(question.review){
        output =  "question-box review-box"
    } else if (question.selected_answer == null) {
        output =  "question-box white-box"
    } else {
        output =  "question-box orange-box"
    }
} else {
    output =  "question-box"
}

console.log(output)

async function Anahtar Kelimesi

Giriş
Açıklaması şöyle.

We have the async function and the await operator. When we use them together we get a new way to structure and work with Promises that makes our code a whole lot easier to work with.

async function Promise döner.

await yazısına göz atabilirsiniz.

async Function Nedir
Daha sonra çalıştırılmak üzere bir diziye callback eklemek gibidir. Açıklaması şöyle.

async functions run synchronously when they called until the first await statement.

Elimizde şöyle bir kod olsun

async function doSomething() {
  ...
}

İki tane dosomething() çağrısı şöyledir.

                ┌───┬──────┬───┐
doSomething(1)  │   │ WAIT │   │
                └───┴──────┴───┘
                    ┌───┬──────┬───┐
doSomething(2)      │   │ WAIT │   │
                    └───┴──────┴───┘
                ├───────────────────────────────▶ time

Örnek
Elimizde şöyle bir kod olsun.

(async () => {... })();

Şu kod ile aynıdır.

let callbacks = [];

callbacks.push(() => {...});

callbacks.forEach(cb => {
  cb();
});

async function Tanımlama
Şöyle yaparız.

async function findSomething(id) {
  var query = "my_query";
  return connection.query(query);
};

async function Çağırma
Örnek
Şöyle yaparız.

var result = (async (global) => {
  // other code here (includes await's; thus the async)
  return 123;
})(this);

result.then((res)=> console.log(res));

async function içinde await
Örnek

Elimizde şöyle bir kod olsun

async function doSomething() {
  const result = await doExpensiveOperation()
  const result2 = await doAnotherExpensiveOperation()
  return { result, result2 }
}

Bu kod aslında şöyle de yazılabilirdi. İki tane doSomething() çağrısı paralel çalışabilir. Ancak doSomething() kendisi çalışırken her şeyi sıralı yapar. Önce doExpensiveOperation() çalışır sonra doAnotherExpensiveOperation()

function doSomething() {
  return doExpensiveOperation().then(result => {
    return doAnotherExpensiveOperation().then(result2 => {
      return { result, result2 }
    })
  })
}

Örnek
Şöyle yaparız. Burada async içinde await() kullanılıyor.

let i = 3;

(async () => {
  while (i) {
    await Promise.resolve();
    console.log(i);
    i--;
  }
})();

Çıktı olarak şunu alırız.

3
2
1

Örnek
Şöyle yaparız. Burada async içinde await() kullanılıyor.

let x = 0;

async function test() {
  // Enter asynchrony
  await 0;

  x += 5;
  console.log('x :', x);
}

test();
x += 1;
console.log('x :', x);