JavaScript ES6

JavaScript EcmaScript 6 ile birlikte gelen let, Default Parameters, Destructuring Assignment, const, Arrow Functions, Template Literals, Spread Operator, For..Of, Generators, Modules, Set Map WeakMap WeakSet, New Built-In Methods, Binary and Octal Literals, Tail Calls özellikleri ile ilgili bilgiler yer alıyor.

ES6 let

JavaScript EcmaScript 6 ile birlikte değişken oluşturma ve tanımlama için kullanılan let, kullanım alanı tam olarak anlaşılmayan veya tam olarak ne olduğu açıklanmayan değişken oluşturma ve tanımlama anahtar kelimesi diyebiliriz.

Aslında problem let anahtar kelimesini değişken oluşturmak ve değişken tanımlamak için kullanılan bir ifade olarak tanımladığımızda başlıyor.

Çünkü JavaScript içerisinde uzun yıllar değişken tanımlamak ve oluşturmak için var anahtar kelimesini kullandık.

Peki ne ihtiyaç var?

Standartlar !!!

JavaScript var anahtar kelimesi ile aynı isimli bir değişkeni birden fazla oluşturabiliriz.

<script>
  "use strict";
  var xSayisi = 100;
  console.log(xSayisi);

  // uzun kodlar
  // ...
  // ..
  // .

  var xSayisi = 3;
  console.log(xSayisi);
</script>

Örnekte herşey olağan gibi duruyor.

Ancak oluşturulan bir değişkeni tekrar oluşturmak kodları karmaşıklatırıyor sanki.

Peki let anahtar kelimesini kullansak;

<script>
  "use strict";
  let xSayisi = 100;
  console.log(xSayisi);

  // uzun kodlar
  // ...
  // ..
  // .

  let xSayisi = 3;  // boom
  console.log(xSayisi);
</script>

Artık JavaScript böyle bir değişken oluşturulmuş niye tekrar oluşturuyorsun diyor.

Yukarıdaki özellik let anahtar kelimesini kullanmak sizi ikna etmedi mi?

Kapsama alanı

O zaman aşağıdaki koda bakalım.

<script>
  "use strict";
  var xSayisi = 100;

  if (xSayisi === 100 ) {
    var mesaj = "Doğru cevap";
    console.log(mesaj);  // Doğru cevap
  }

  console.log(mesaj);  // Doğru cevap
</script>

Herşey normal gibi duruyor.

if bloğu içerisinde yeni bir değişken tanımlayıp onun üzerinden işlemler yapmak istedik.

Ancak JavaScript değişken kaldıraç özelliği sayesinde bu değişkene dışarıdan erişebildik.

JavaScript kaldıraç özelliği kod güvenliği açısından iyi bir özellik değildir.

<script>
  "use strict";
  var xSayisi = 100;

  if (xSayisi === 100 ) {
    let mesaj = "Doğru cevap";
    console.log(mesaj);  // Doğru Cevap
  }

  console.log(mesaj);  // ???
</script>

Aslında yukarıdaki örnekte pek anlaşılır olmayabilir.

Birde döngülerde kullanalım.

<script>
  "use strict";

  for (var i = 0; i < 10; i++) {
    console.log(i);
  }

  console.log("Sonuç : " + i);  // Sonuç :  10
</script>

JavaScript döngü için oluşturulan değişkene kaldıraç özelliği sayesinde dışarıdan erişebildik.

Bu diğer programlama dillerinde olmayan, standart dışı bir kullanım diyebiliriz.

<script>
  "use strict";

  for (let i = 0; i < 10; i++) {
    console.log(i);
  }

  console.log("Sonuç : " + i);  // ???
</script>

Artık döngü içinde oluşturulan değişkene dışarıdan erişemiyoruz.

Bir diğer kullanım örneği;

<script>
  "use strict";

  {
    let mesaj = "Merhaba JavaScript"
    console.log(mesaj);
  }

  console.log(mesaj);  // ???
</script>

Örnekte görüldüğü gibi let anahtar kelimesi ile oluşturulan değişkenlere sadece kapsama alanı içinde erişebiliyoruz.

ES6 Default Parameters

JavaScript ile fonksiyon yazarken her bir fonksiyon parametresini çeşitli kontrollerden geçirdikten sonra kullanıyorduk.

EcmaScript 6 ile birlikte fonksiyon parametrelerine varsayılan değer atayabiliyoruz.

Peki bunun bize faydası ne olacak?

JavaScript Extension Metotlar yazımda şöyle bir fonksiyon yazmıştık.

<script>
"use strict";
  Date.prototype.getYas = function(dogumYili) {
    return this.getFullYear() - dogumYili;
  }

  var tarih = new Date();
  console.log(tarih.getYas(1970));
</script>

Aslında herşey normal gibi görünüyor.

Ancak tüm kontroller yapılmadığından fonksiyona parametre girilmediği zaman fonksiyon çalışmaz hale gelecek veya yanlış bir döndürecektir.

Fonksiyona varsayılan parametre değeri yazalım.

<script>
"use strict";
  Date.prototype.getYas = function(dogumYili = 1950) {
    return this.getFullYear() - dogumYili;
  }

  var tarih = new Date();
  console.log(tarih.getYas(1970));  // 1970 gönderildi
</script>

Artık fonksiyona parametre olarak bir değer girilmediğinde fonksiyon varsayılan parametre değerini alarak hesaplama yapacaktır.

<script>
"use strict";
  Date.prototype.getYas = function(dogumYili = 1950) {
    return this.getFullYear() - dogumYili;
  }

  var tarih = new Date();
  console.log(tarih.getYas());  // değer gönderilmedi varsayılan değer hesaplanacak
</script>

Başka bir örnek aşağıda yer almaktadır.

<script>
"use strict";
  function Topla(sayi1 = 0, sayi2 = 0 ) {
    return sayi1 + sayi2;
  }
  console.log(Topla());        // Kullanım 1
  console.log(Topla(90));      // Kullanım 2
  console.log(Topla(90, 50));  // Kullanım 3
</script>

Varsayılan değer yazılmasaydı sonuç hatalı olacaktı.

ES6 Destructuring Assignment

JavaScript dizi içerisindeki değerleri ayrı ayrı değişkenlere atamak oldukça zahmetli ve zaman alanbir durumdu.

EcmaScript 6 ile birlikte Destructuring Assignment veya Çoklu Değer Atama olarak çevirebileceğimiz yöntem ile bu işlem daha kolay hale geldi.

<script>
"use strict";
  var sayilar = [1, 2, 3, 4, 5];
  var a = sayilar[0], b = sayilar[2], c = sayilar[4];

  console.log(a,b,c);  // 1 3 5
</script>

Dizide sadece 5 eleaman var.

Dizi daha fazla elemanlı olsaydı?

Birde çoklu değer atamayı deneyelim.

<script>
"use strict";
  var sayilar = [1, 2, 3, 4, 5];
  var [a,,b,,c] = sayilar;

  console.log(a,b,c);  // 1 3 5
</script>

Yukardaki kodda ilk değer a değişkenine

ikinci değere birşey yazılmadığı için pas geçildi

üçüncü değer b değişkenine atandı.

…

Görüldüğü gibi daha az kodla daha fazla iş yaptık.

Çoklu değer atama dizi değişkenlerde kullanıldığı gibi nesnelerde de kullanılabilir .

<script>
"use strict";
  var kisi = {adi: "Yusuf", soyAdi:"SEZER", yas: 75};
  var {adi, soyAdi} = kisi;

  console.log(adi, soyAdi);  // Yusuf SEZER
</script>

ES6 const

Sabit değişkenler bir defa oluşturulur ve tanımlanır.

Daha sonra sabit değişken tekrar oluşturulamaz ve değeri değiştirilemez.

Çoğu programlama dilinde olan bir özellik EcmaScript 6 ile birlikte JavaScript’te de geldi.

JavaScript Sabit Tanımlama yazımda sabit tanımlamayı karmaşık bir şekilde dolaylı olarak yaptık.

Yeni gelen const anahtar kelimesi ile JavaScript’te kolay bir şekilde sabit oluşturabilir ve tanımlayabiliriz.

Sabit değişkenler oluşturulduktan sonra herhangi bir şekilde tekrar oluşturulamaz.

<script>
  "use strict";
  const xSayisi = 100;
  console.log(xSayisi);

  // uzun kodlar
  // ...
  // ..
  // .

  var xSayisi = 3;     // hata
  let xSayisi = 5;     // hata
  const xSayisi = 18;  // hata
  console.log(xSayisi);
</script>

Sabit değişkenlerin oluşturulması ve değer ataması beraber yapılmak zorunludur.

<script>
  "use strict";
  const xSayisi;  // hata
  console.log(xSayisi);
</script>

Sabitlerinde let anahtar kelimesi gibi kapsama alanı vardır.

<script>
  "use strict";
  {
  const xSayisi = 45;
  console.log(xSayisi);
  }
  var xSayisi = 100;
  console.log(xSayisi);
</script>

Sabit tanımlamak için kullanılan const anahtar kelimesi let anahtar kelimesi ile benzer özellikleri taşır.

Aralarındaki tek fark sabit değişkenlere daha sonra tekrar değer ataması yapılmamasıdır.

ES6 Arrow Functions

JavaScript anonim fonksiyonlar sıklıkla kullanıyoruz.

Ancak sürekli function ifadesini yazmak zaman alabiliyor.

Fonksiyon tanımını kısalmak için EcmaScript 6 ile birlikte Arrow Functions olarak isimlendirilen fonksiyon ifadesi geldi.

<script>
"use strict";
  setInterval(function() {
    console.log("Merhaba");
  }, 1000);
</script>

Örnekte setInterval ile her 1 saniyede anonim fonksiyon içerisine yazılan işlem gerçekleşmektedir.

Benzer işlemi anonim fonksiyon ile yazmak istersek.

<script>
"use strict";
  setInterval(fnk='asd' => console.log("Merhaba" + fnk), 1000);
</script>

Burada fnk yerine JavaScript anahtar kelimesi haricinde herhangi bir şey yazabilir ve fonksiyon içerisinde parametre olarak kullanabiliriz.

Sadece parantez kullanarakta yazılabilir.

<script>
"use strict";
  setInterval(() => console.log("Merhaba"), 1000);
</script>

Parentez ile kullanımda parantez içerisine fonksiyonun alacağı parametreleri yazabiliriz.

<script>
"use strict";
  var Topla = (a, b) => { return a + b; };
  console.log(Topla(10, 20));
</script>

Veya;

<script>
"use strict";
  var Topla = sayi => { return sayi + 5; };
  console.log(Topla(100));
</script>

Arrow Functions veya anonim fonksiyon tanımlamak için kullanılsa da Topla örneğinde olduğu gibi genel fonksiyon tanımlamalarında da kullanılabilir.

ES6 Classes

Detaylı bilgi için JavaScript ES6 Classes yazıma bakabilirsiniz.

ES6 Template Literals

JavaScript metin veri türü (string) değerlerini ekran yazdırma karmaşıklığını ve eksikliğini gidermek için EcmaScript 6 ile birlikte Template Literals denilen Aksan İşareti (`) arasına özel ifade yazılmasına imkan veren bir yöntem eklenmiştir.

Peki böyle bir şeye ne ihtiyaç var ?

JavaScript ile metinsel değerleri yazarken çift tırnak ve tek tırnak karmaşıklığı yaşanabilir.

<script>
  "use strict";
  console.log("Merhaba ben "Yusuf SEZER"");  // hata
</script>

Ayrıca değişken yazdırmak için toplama operatörü sıklıkla kullanılır.

<script>
  "use strict";
  let adi = "Yusuf", soyAdi = "SEZER";
  console.log("Merhaba ben "+ adi + " " + soyAdi + " yazı devam ediyor");
</script>

Bu gibi karmaşıklığı en aza indirmek için Template Literals yöntemi geliştirilmiştir.

<script>
  "use strict";
  console.log(`Merhaba ben "Yusuf SEZER"`);
</script>

Veya

<script>
  "use strict";
  let adi = "Yusuf", soyAdi = "SEZER";
  console.log(`Merhaba ben ${adi} ${soyAdi} yazı devam ediyor`);
</script>

Ayrıca dolar işareti içerisinde çeşitli hesaplamalarda yapılabilir.

<script>
  "use strict";
  let x = 10, y = 20;
  console.log(`Sonuç: ${ x + y } ve ${ x * y } veya ${ 50 + (x * y) } `);
</script>

Örneklerde görüldüğü gibi ekrana yazdırma işlemlerini Template Literals ile daha esnek bir şekilde yapabiliriz.

ES6 Spread Operator

JavaScript ile birden fazla parametre alan fonksiyona dizi değişkeni içerisindeki her bir elemanı aktarmak için ayrı ayrı dizi sıra numarasını yazmamız gerekiyordu.

EcmaScrip6 Spread Operator ile artık sadece dizi değişkeninin önüne üç nokta ekleyerek dizi değişkeninin elemanlarını ayrı ayrı parametre olarak aktarabiliriz.

<script>
"use strict";
  function SayilariTopla(a, b, c) {
    return a + b + c;
  }
  var sayi = [3, 10, 8];
  console.log(SayilariTopla(sayi[0], sayi[1], sayi[2]));
</script>

Her dizi elemanının sıra numarasını ayrı ayrı yazmak sıkıcı gelmiş olabilir.

<script>
"use strict";
  function SayilariTopla(a, b, c) {
    return a + b + c;
  }
  let sayi = [3, 10, 8];
  console.log(SayilariTopla(...sayi));
</script>

Diğer bir kullanım örneği aşağıda yer almaktadır.

<script>
"use strict";
  let dizi1 = ["A", "B", "C", "Ç", "D", "E", "F"], dizi2 = ["S", "Ş", "T", "U", "Ü", "V", "Y", "Z",];

  let harfler = [...dizi1, ...dizi2];
  console.log(harfler);
</script>

Artık Spread Operator ile birlikte dizi işlemlerini daha kolay ve hızlı bir şekilde yapabiliriz.

ES6 For..Of

JavaScript diziler, nesneler ve daha bir çok sıralı değişken türleri ile işlem yaparken çeşitli döngüleri kullanıyoruz.

Ancak döngüleri kullanarak işlem yapmak için bazen çok uzun kodlar yazabiliriz.

<script>
  "use strict";
  var adi = "Yusuf SEZER", adUzunluk = adi.length;

  for(var i = 0; i < adUzunluk; i++ ) {
    console.log(adi[i]);
}
</script>

Daha az kod yazmak için for in döngüsünü de kullanabiliriz.

<script>
  "use strict";
  var adi = "Yusuf SEZER";

  for(var i in adi ) {
    console.log(adi[i]);
}
</script>

Ancak for in döngünün her adımında indis numarasıyla işlem yapar.

Yani adi değişkenine ait her bir elemanın sıra numarasını i değişkenine atar ve sıra numarası ile elemana erişim sağlarız.

EcmaScript 6 ile birlikte gelen for of döngü yapısı her bir eleman için ayrı ayrı atama yapar.

<script>
  "use strict";
  let adi = "Yusuf SEFA SEZER";

  for(let eleman of adi) {
    console.log(eleman);
}
</script>

Örnekte; for of dögüsü her bir adımda adi değişkeninin her elemanını sırayla eleman değişkenine atayarak işlem yapar.

Diğer bir kullanım örneği aşağıda yer almaktadır.

<script>
  "use strict";

  for(let eleman of "Yusuf SEZER") {
    console.log(eleman);
}
</script>

Yukarıdaki örneği for in ile yaptığımızda her bir elemanın sıra numarasını eleman değerine atayacaktı.

Ayrıca for of döngüsü Symbol.iterator ile birlikte daha esnek döngü işlemleri yapılabilir.

ES6 Generators

JavaScript’te fonksiyon içerisindeki işlemleri adım adım çalıştırmak için EcmaScript 6 ile birlikte Generators denilen bir yöntem eklenmiştir.

Generators tanımlamak için aşağıdaki gibi bir sözdizimi kullanılır.

<script>
"use strict";
  function *fonksiyonAdi() {
    // ...
  }
</script>

Generators fonksiyonun önünde yıldız işaretine * olduğuna dikkat edin.

Her işlem adımını belirtmek için yield anahtar kelimesi kullanılır.

<script>
"use strict";
  function *fonksiyonAdi() {
    yield 1;
    yield 2;
    yield 3;
  }
</script>

Artık generators ve işlem adımları tanımlandığına göre sıra fonksiyonu çalıştırmaya geldi.

Generators fonksiyonu çalıştırma normal fonksiyon çalıştırmadan farklıdır.

<script>
"use strict";
  function *fonksiyonAdi() {
    yield 1;
    yield 2;
    yield 3;
  }

  let gen = fonksiyonAdi();
  let it = gen.next();
  console.log("değer : " + it.value + " durum : " + it.done);
  it = gen.next();
  console.log("değer : " + it.value + " durum : " + it.done);
  it = gen.next();
  console.log("değer : " + it.value + " durum : " + it.done);
  it = gen.next();
  console.log("değer : " + it.value + " durum : " + it.done);
</script>

Daha esnek bir kullanım için Generators fonksiyonunu bir değişkene atıyoruz.

Daha sonra her bir işlem adımını next() metodu ile çalıştırıyoruz.

Metot çalıştırıldıktan sonra dönen değeri value özelliğine fonksiyonun bitip bitmediğini ise done özelliğine atar.

Generators fonksiyon içerisindeki adım sayısı bitince done özelliğine adım sayısı bittiğini ifade eden true değerini atar.

Generators fonksiyonlar döngüler içerisinde de kullanılabilir.

<script>
"use strict";
  function *fonksiyonAdi() {
    yield 1;
    yield 2;
    yield 3;
  }

  for(let it of fonksiyonAdi()) {
    console.log(it);
  }
</script>

Generators yöntemine ait return metodu ile generators fonksiyonu sonlandırabiliriz.

<script>
"use strict";
  function *fonksiyonAdi() {
    yield 1;
    yield 2;
    yield 3;
  }

  let gen = fonksiyonAdi();
  let it = gen.next();
  console.log("değer : " + it.value + " durum : " + it.done);
  it = gen.return("adım bitti");
  console.log("değer : " + it.value + " durum : " + it.done);
  it = gen.next();
  console.log("değer : " + it.value + " durum : " + it.done);
  it = gen.next();
  console.log("değer : " + it.value + " durum : " + it.done);
</script>

Örneklerdende anlaşılacağı üzere Generators içerisinde her işlem adımını yield anahtar kelimesiyle sıra sıra çalıştırmaya imkan veren bir yöntemdir.

ES6 Modules

JavaScript ile yazılan kodların modüler bir yapıda olması çeşitli kütüphaneler aracılığıyla yapılıyordu.

EcmaScript 6 Modules ile birlikte JavaScript’te modüler yapı dahil edildi.

JavaScript ES6 modülleri farklı dosyalara yazılır ve modüller import anahtar kelimesi ile projeye dahil edilir.

Artık farklı JavaScript modülleri farklı dosyalarda saklanabilir ve istenildiğinde projeye dahil edilebilir.

Modül yazmak

Modüller ayrı dosyalarda içerisinde çeşitli işlemleri yapan metot veya değişken olabilir.

Modül içerisindeki değişken ve fonksiyonlar export anahtar kelimesi kullanılarak yazılır.

// lib.js 
export const sqrt = Math.sqrt;
export function square(x) {
    return x * x;
}
export function diag(x, y) {
    return sqrt(square(x) + square(y));
}

Modül içerisindeki fonksiyon ve metotlar import ile projeye dahil edilir.

Örnekte sadece square ve diag fonksiyonları projeye dahil edilmiştir.

// main.js 
import { square, diag } from 'lib';
console.log(square(11)); // 121
console.log(diag(4, 3)); // 5

Örnekte modül içerisindeki tüm fonksiyon ve değişkenler lib nesnesi olarak projeye dahil edilmiştir.

// main.js 
import * as lib from 'lib';
console.log(lib.square(11)); // 121
console.log(lib.diag(4, 3)); // 5

EcmaScript6 Modules yapısı tarayıcılar tarafından desteklenmemektedir.

Modules yöntemi kullanılarak yazılan kodlar çeşitli JavaScript polyfill kütüphanesi ile tarayıcı desteği sağlanmaktadır.

ES6 Set Map WeakMap WeakSet

JavaScript EcmaScript 6 ile birlikte çeşitli algoritmalarda kullanılan veri yapısı nesneleri ( Set, Map, WeakMap ve WeakSet ) eklenmiştir.

Eklenen veri yapılarıyla veriler artık daha kolay ve hızlı bir şekilde saklanabilmekte.

Veri yapıları nesnelerinin sahip olduğu çeşitli metotlar kullanarak veriler üzerinde işlemler kolayca yapılabilmekte.

Set veri yapısı nesnesi veri saklamak için kullanılır.

<script>
  "use strict";
  let s = new Set();
  s.add("Yusuf");             // add -> yeni eleman ekler
  s.add("Yusuf");             // aynı değer tekrar eklenmez
  s.add("Sefa");
  s.add("SEZER");
  s.add("abc");

  console.log(s.has("abc"));  // has -> değer kontrolü yapar
  s.delete("abc");            // delete -> eşleşen değeri siler

  console.log(s.size);        // size -> eleman sayısını verir
  s.clear();                  // clear -> tüm değerleri siler
  console.log(s.size);
</script>

Map veri yapısı nesnesi anahtar:değer çifti olarak veri saklamak için kullanılır.

<script>
  "use strict";
  let m = new Map();

  m.set("adi", "Yusuf");      // set -> yeni eleman ekler
  m.set("adi2", "Sefa");
  m.set("soyadi", "SEZER");
  m.set("abc", "abc");

  console.log(m.has("abc"));  // has -> değer kontrolü yapar
  console.log(m.get("adi"));  // get -> anahtarın değerinin verir
  m.delete("abc");            // delete -> eşleşen değeri siler

  console.log(m.keys());      // keys -> anahtarları verir
  console.log(m.values());    // values -> değerleri verir

  console.log(m.size);        // size -> eleman sayısını verir
  m.clear();                  // clear -> tüm değerleri siler
  console.log(m.size);
</script>

WeakMap veri yapısı nesnesi anahtar:değer çifti olarak veri saklamak için kullanılır.

Map veri yapısından daha zayıf bir veri yapısı ve daha az metot içerir.

Döngü içerisinde kullanılmaz.

<script>
  "use strict";
  let m = new Map();
  let wm = new WeakMap();

  let bilgi = {
    adi: "Yusuf",
    adi2: "SEFA",
    soyadi: "SEZER"
  }

  m.set(bilgi, "Bilgilerim");
  wm.set(bilgi, "Bilgilerim");

  console.log(m.get(bilgi));   // Bilgilerim
  console.log(wm.get(bilgi));  // Bilgilerim

  bilgi = null;
  console.log(m.get());        // Bilgilerim
  console.log(wm.get(bilgi));  // undefined
</script>

WeakSet veri yapısı nesnesi veri saklamak için kullanılır.

Set veri yapısından daha zayıf bir veri yapısı ve daha az metot içerir. Döngü içerisinde kullanılmaz.

ES6 New Built-In Methods

JavaScript içerisinde çeşitli işlemler için kullanılan nesneler içerisinde çeşitli metot ve sabitleri barındırır.

Nesne metot ve sabitleri kullanılarak çeşitli işlemler yapılır.

EcmaScript 6 ile birlikte JavaScript içerisindeki hazır metot ve sabitlerine yeni eklemeler yapılmıştır.

Yeni eklenen Number metot ve sabitleri aşağıda yer almaktadır.

<script>
"use strict";
  console.log(Number.isFinite(123));
  console.log(Number.isFinite(NaN));
  console.log(Number.isNaN(42));
  console.log(Number.isNaN(NaN));
  console.log(Number.isInteger(-17));
  console.log(Number.isInteger(Infinity));
  console.log(Number.isSafeInteger(42));
  console.log(Number.isSafeInteger(9007199254740992));

  console.log(Number.EPSILON);
  console.log(Number.MAX_SAFE_INTEGER);
  console.log(Number.MIN_SAFE_INTEGER);
</script>

Yeni eklenen Math metotları aşağıda yer almaktadır.

<script>
"use strict";
  console.log(Math.sign(-8));
  console.log(Math.trunc(3.9));
  console.log(Math.cbrt(8));
  console.log(Math.expm1(1e-10));
  console.log(Math.log(1 + 1e-16));
  console.log(Math.log2(8));
  console.log(Math.log10(100));
  console.log(Math.fround(1.337));
  console.log(Math.imul(-1, 8));
  console.log(Math.clz32(2));
  console.log(Math.sinh(45));
  console.log(Math.cosh(45));
  console.log(Math.tanh(45));
  console.log(Math.asinh(45));
  console.log(Math.acosh(45));
  console.log(Math.atanh(45));
  console.log(Math.hypot(3, 4));
</script>

Diğer eklenen metotlar aşağıda yer almaktadır.

<script>
"use strict";
  "abcde".includes("cd");
  "abc".repeat(3);

  Array.from(document.querySelectorAll("*"));
  Array.of(1, 2, 3);
  [0, 0, 0].fill(7, 1);
  [1,2,3].findIndex(x => x == 2);
  ["a", "b", "c"].entries();
  ["a", "b", "c"].keys();
  ["a", "b", "c"].values();

  Object.assign(Point, { origin: new Point(0,0) })
</script>

Eklenen metot ve sabitlerle artık daha kolay ve hızlı işlemler yapılabilir.

ES6 Binary and Octal Literals

JavaScript EcmaScript 6 ile birlikte artık daha fazla sayı sistemi desteği sunuyor.

Sayıları ikilik sayı sisteminde yazmak için ikilik sayıların başına 0b eklemek yeterli olacaktır.

<script>
  "use strict";
  console.log(0b101011); // 43
</script>

Sayıları sekizlik sayı sisteminde yazmak için sekizlik sayıların başına 0o eklemek yeterli olacaktır.

<script>
  "use strict";
  console.log(0o543); // 355
</script>

Ayrıca sayı sistemlerini karşılaştırma içinde kullanabiliriz.

<script>
  "use strict";
  console.log(0b111110111 === 503);  // true
  console.log(0o543 === 355);        // true
</script>

ES6 Tail Calls

JavaScript veya diğer programlama dilleri ile kodlama yaparken bazen yazılan kodun işlemi hiç bitmeyebilir.

Örneğin sürekli birbirini çağıran fonksiyonlar, faktöriyel hesaplamaları bu işlemlere örnek verilebilir.

JavaScript EcmaScript 6 Tail Calls ile birlikte belirli sınırı aşan veya hiç sonuçlanmayacak fonksiyonlar hata üretecektir.

<script>
"use strict";

  function factorial(n, acc = 1) {
    if (n <= 1) return acc;
      return factorial(n - 1, n * acc);
  }

  factorial(100000);
</script>

Veya

<script>
"use strict";

  function a() {
    b();
  }

  function b() {
    a();
  }

  console.log(a());
</script>

Fonksiyon sürekli birbirini çağırdığı için JavaScript hata üretecektir.

ES6 Promise

Detaylı bilgi için JavaScript ES6 Promise yazıma bakabilirsiniz.

JavaScript Derslerine buradan ulaşabilirsiniz…

Hayırlı günler dilerim.