Dizi Metodları

Diziler birçok metod sunarlar. İşleri daha kolaylaştırmak için bu bölüm ikiye ayrılacaktır.

Elaman silme/ekleme

Eleman eklemenin ve silmenin baştan ve sondan nasıl olacağını gördünüz:

• arr.push(...items) – elemanları sona ekler,
• arr.pop() – sondaki elemanı çıkarır.
• arr.shift() – baÅŸlangıçtan eleman çıkarır.
• arr.unshift(...items) – baÅŸlangıça eleman ekler.

Diğer birkaç metod ise aşağıdaki gibidir.

splice

Diziden eleman nasıl silinir?

Diziler de obje olduklarından dolayı, delete kullanarak silinebilir.

let arr = ["eve", "gitmek", "istiyorum"];

delete arr[1]; // "gitmek" silinecek

alert( arr[1] ); // undefined

// ÅŸimdi arr = ["eve",  , "istiyorum"];
alert( arr.length ); // 3

Eleman silinmesine raÄŸmen, dizi hala 3 elemana sahip. Bunu arr.length == 3 kontrolünü yaparak görebilirsiniz.

Olması gereken de bu, çünkü delete obj.key deÄŸeri anahtara göre siler. Sadece bu iÅŸi yapar. Bu da objeler için yeterlidir. Fakat diziler için genelde istediÄŸimiz elamanların birbirlerinin yerleri doldurmasıdır. Bundan dolayı dizinin kısaldığını görmemiz lazım.

Bundan dolayı özel metodlar kullanılmalıdır.

arr.splice(str) metodu isviçre çakısı gibi her işe yarar. Diziye yeni bir eleman ekleyebilir ve silebilir.

Yazımı:

arr.splice(index[, deleteCount, elem1, ..., elemN])

index’ten baÅŸlar ve deleteCountkadar elemanı siler ve sonra elem1, ..., elemN ÅŸeklinde yerlerine yerleÅŸtirir. Diziden silinen elemanları dönderir.

Bu metodu örnek ile anlamak çok daha kolaydır.

Silme işlemi ile başlayalım:

let arr = ["Ben", "JavaScript", "çalışıyorum"];

arr.splice(1, 1); // index 1'den 1 elaman sil

alert( arr ); // ["Ben", "çalışıyorum"]

Kolay deÄŸil mi? 1. indeksten baÅŸlayarak 1 eleman sildi.

Bir sonraki örnekte ise 4 eleman silinecek ve yeni bir eleman bunların yerine konulacak.

let arr = ["Ben", "şu", "an", "JavaScript", "çalışıyorum"];

// İlk 4 elamanı sil ve öncesine yeni eleman ekle.
arr.splice(0, 4, "Ders")

alert( arr ) // Şimdi [Ders çalışıyorum]

Burada splice in silinen elemanları döndürdüğü görülebilir.

let arr = ["Ben", "şu", "an", "JavaScript", "çalışıyorum"];

// ilk iki elemanı sil.
let removed = arr.splice(0, 2);

alert( removed ); // "Ben", "ÅŸu" <-- silinen elemanlar

splice metodu ayrıca hiçbir ÅŸey silmeden de ekleme yapabilir. Bunun için deleteCount’u 0 yapmanız gerekmektedir:

let arr = ["Ben", "JavaScript", "çalışıyorum"];

// 1. indeksten
// 0 tane sil
// Sonrasında "karmaşık" ekle
arr.splice(1, 0,  "karmaşık");

alert( arr ); // "Ben", "karmaşık", "JavaScript", "çalışıyorum"

let arr = [1, 2, 5]

// indeks -1 ( sondan birinci )
// 0 eleman sil,
// 3 vs 4 ekle
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

slice

arr.slice metodu arr.splice’a göre daha basittir.

Yazımı:

arr.slice(start, end)

Yeni bir dizi döndürür. Bu dizi içerisinde "start" ile "end" arasında ( "end" dahil olmadan ) tüm elemanları kopyalar. start ve end negatif olabilir. Negatif durumlarda dizi sondan deÄŸer baÅŸlar.

str.slice gibi çalışır fakat karakter dizisi(string) yapmak yerine alt-dizi yapar.

Örneğin:

let str = "test";
let arr = ["t", "e", "s", "t"];

alert( str.slice(1, 3) ); // es
alert( arr.slice(1, 3) ); // e,s

alert( str.slice(-2) ); // st
alert( arr.slice(-2) ); // s,t

concat

arr.concat metodu dizi ile diğer dizileri veya elemanları birbirine eklemeye yarar.

Yazımı:

arr.concat(arg1, arg2...)

İstenildiği kadar argümanı kabul eder, bunlar dizi veya değer olabilir.

Sonuç arr, ardından arg1, arg2 ÅŸeklinde tüm dizileri ve deÄŸerleri içeren bir dizi olur.

EÄŸer bir argüman dizi ve Symbol.isConcatSpreadable özelliÄŸine sahip ise bunun tüm alt elemanları kopyalanır. DiÄŸer türlü argümanın sadece kendisi kopyalanır.

Örneğin:

let arr = [1, 2];

// diziyi [3,4] ile birleÅŸtir
alert( arr.concat([3, 4])); // 1,2,3,4

// diziyi [3,4] ve [5,6] ile birleÅŸtir
alert( arr.concat([3, 4], [5, 6])); // 1,2,3,4,5,6

// diziyi [3,4] ile birleştir ve ardından 5, 6 ekle
alert( arr.concat([3, 4], 5, 6)); // 1,2,3,4,5,6

Normalde, dizide bulunan elemanları kopyalar. Diğer objeler dizi olsalar bile bir bütün olarak eklenirler.

let arr = [1, 2];

let arrayLike = {
  0: "something",
  length: 1
};

alert( arr.concat(arrayLike) ); // 1,2,[object Object]
//[1, 2, arrayLike]

…Fakat dizi benzeri obje Symbol.isConcatSpreadable özelliÄŸine sahipse, bunların elemanları eklenir:

let arr = [1, 2];

let arrayLike = {
  0: "baÅŸka",
  1: "bir ÅŸey",
  [Symbol.isConcatSpreadable]: true,
  length: 2
};

alert( arr.concat(arrayLike) ); // 1,2,baÅŸka,bir ÅŸey

Dizide arama

Dizi içerisinde aramak için bazı metodlar bulunmaktadır.

indexOf/lastIndexOf ve includes

arr.indexOf, arr.lastIndexOf ve arr.includes aynı yazıma sahiptirler, ve aslında hepsi aynı işi yapar. Sadece karakterler yerine elemanlar üzerinde çalışırlar.

• arr.indexOf(eleman, balangic) baslangic indeksinden itibaren eleman’ı arar ve bulursa bunun indeksini döner, bulamazsa -1 döner.
• arr.lastIndexOf(eleman, baslangic) – aynı, fakat bu saÄŸdan sola doÄŸru bakar.
• arr.includes(eleman, baslangic) – eleman baslangıc’tan baÅŸlayarak elemanları kontrol eder. Bulursa true döner.

Örneğin:

let arr = [1, 0, false];

alert( arr.indexOf(0) ); // 1
alert( arr.indexOf(false) ); // 2
alert( arr.indexOf(null) ); // -1

alert( arr.includes(1) ); // true

Bu metodlar eÅŸitlik kontrolü için === kullanır. Bundan dolayı false’a bakacak olursanız 0 ile eÅŸit deÄŸildir. Sadece false ile eÅŸittir. EÄŸer sadece dizi içinde var olup olmadığını kontrol etmek istiyorsanız arr.includes tercih edilir.

find and findIndex

Objelerden oluşma bir dizinin olduğunu varsayın. Bazı şartları sağlayan objeleri nasıl bulursunuz.

Burada arr.find metodu yararlı olur.

Yazımı:

let result = arr.find(function(elaman, index, dizi) {
  //  eğer aranan eleman bulunursa true döndürmeli.
});

Bu fonksiyon her eleman için tekrar tekrar çağırılır.

• elaman eleman’ı tanımlar.
• index indeks’i tanımlar.
• array dizinin kendisidir.

EÄŸer true döndürür ise arama durur ve eleman’ın kendisi döner. EÄŸer bulunamazsa undefined döndürülür.

ÖrneÄŸin, kullanıcıların bulunduÄŸu bir dizi ve her dizide id ve isim alanları bulunsun. id == 1 olan elemanı bulalım.

let kullanicilar = [
  {id: 1, isim: "Ahmet"},
  {id: 2, isim: "Muzaffer"},
  {id: 3, isim: "Emine"}
];

let kullanici = kullanicilar.find(eleman => eleman.id == 1);

alert(kullanici.isim); // Ahmet

Objelerin dizi içerisinde yer alması çokça karşılaşılan bir olaydır, bundan dolayı find metodu çok kullanışlıdır.

Dikkat ederseniz find metodunda sadece bir tane argüman kullanılmıştır item => item.id == 1. find metodunun diÄŸer parametreleri çok nadir olarak kullanılır.

arr.findIndex metodu da aynı find metodu gibi çalışır fakat elemanın kendi yerine index’ini döndürür.

filter

find metodu sadece fonksiyonu true yapan elemana bakar.

Birden fazlası için ise arr.filter(fn) kullanılabilir.

Yazımı neredeyse find ile aynıdır, fakat tek bir eleman yerine kurala uyan elemanları dizi halinde döner.

let results = arr.filter(function(eleman, index, dizi) {
  // eğer elemanlar filtreye uygunsa true döndürür.
});

Örneğin:

let kullanicilar = [
  {id: 1, isim: "Ahmet"},
  {id: 2, isim: "Muzaffer"},
  {id: 3, isim: "Emine"}
];

// ilk iki kullaniciyi döndürür.
let baziKullanicilar = kullanicilar.filter(eleman => eleman.id < 3);

alert(baziKullanicilar.length); // 2

Dizi dönüşümleri

Bu bölüm dizinin dönüşümleri veya yeniden sıralanması hakkındadır.

map

arr.map metodu en fazla kullanılan ve kullanışlı olan metodlardandır.

Yazımı:

let sonuc = arr.map(function(eleman, index, dizi) {
  // eleman yerine yeni değer döndürür.
})

Dizinin her elemanı için fonksiyonu çalıştırır ve sonuçlarını dizi olarak döner.

Örneğin elemanların uzunlukları ile ilgili bir değişiklik yapılabilir:

let uzunluklar = ["Bilbo", "Gandalf", "Nazgul"].map(eleman => eleman.length)
alert(uzunluklar); // 5,7,6

sort(fn)

arr.sort metodu diziyi olduğu yerde sıralar.

Örneğin:

let arr = [ 1, 2, 15 ];

// metod dizinin içeriğini sıralar ve döndürür.
arr.sort();

alert( arr );  // 1, 15, 2

Çıktısında bir şey fark ettiniz mi?

Sıralama 1, 15, 2 oldu. Yanlış. Neden peki?

Diziler varsayılan olarak karakter sıralamasına göre sıralanırlar.

Tüm elemanlar karakter dizisine çevrilir ve karşılaÅŸtırılır. Bundan dolayı karakter sırasına göre "2" > "15" karşılaÅŸtırılır.

Kendi sıralamanızı yapmak için, iki argümanlı bir fonksiyonu arr.sort()'ın argüman olarak alması gerekmektedir.

Fonksiyon aşağıdaki şekilde çalışmalıdır:

function compare(a, b) {
  if (a > b) return 1;
  if (a == b) return 0;
  if (a < b) return -1;
}

Örneğin:

function compareNumeric(a, b) {
  if (a > b) return 1;
  if (a == b) return 0;
  if (a < b) return -1;
}

let arr = [ 1, 2, 15 ];

arr.sort(compareNumeric);

alert(arr);  // 1, 2, 15

Şimdi beklendiği gibi çalışmakta.

Ne olduÄŸunu düşünürsek. arr her ÅŸeyi tutabilir, deÄŸil mi? Sayı, karakter veya html elementi vs. tutabilir. İçinde bulunanları sıralamak için karşılaÅŸtırmayı yapan sıralama fonksiyonuna ihtiyaç vardır. Bunun da varsayılanı karakter sıralamadır.

arr.sort(fn) metodu içinde sıralama algoritmasına sahiptir. Bu sıralamanın nasıl çalıştığına dair bir bilgimiz olmasına gerek yok (ÇoÄŸu zaman quicksort kullanılır). Diziyi dolanır ve elemanları verilen algoritmaya göre karşılaÅŸtırır ve sıralar. Tek bilmeniz gereken fn fonksiyonunun karşılaÅŸtırmayı yaptığıdır.

Eğer hangi elemanın karşılaştırıldığını öğrenmek istiyorsanız elbette bunu görebilirsiniz.

[1, -2, 15, 2, 0, 8].sort(function(a, b) {
  alert( a + " <> " + b );
});

Algoritma aynı elemanı bir kaç defa çalıştırma ihtiyacı duyabilir, fakat yine de olduğunca az karşılaştırmaya çalışır.

let arr = [ 1, 2, 15 ];

arr.sort(function(a, b) { return a - b; });

alert(arr);  // 1, 2, 15

arr.sort( (a, b) => a - b );

reverse

arr.reverse metodu arr’in sıralamasını terse çevirir.

Örneğin:

let arr = [1, 2, 3, 4, 5];
arr.reverse();

alert( arr ); // 5,4,3,2,1

Ayrıca terse çevirmesinden sonra arr’i döndürür.

split and join

Bunun uygulamasını gerçek hayatta ÅŸu ÅŸekilde görmek mümkndür. Bir mesajlaÅŸma uygulaması yazıdğınızı düşünün. Gönderen kiÅŸi alıcıları virgülle ayırarak yazsın. ÖrneÄŸin Ahmet, Mehmet, Muzaffer gibi. Fakat bizim için bunun bir dizi olması karakter dizisi olmasından daha kullanışlıdır. Peki bu nasıl yapılmalı?

str.split(delim) tam olarak bunu yapmaktadır. Karakterleri verilen delim e göre ayırır ve sonrasında bunları dizi olarak döner.

Aşağıdaki örnekte isimler virgül ve ardından boşluk yazarak ayrılmıştır.

let isimler = 'Bilbo, Gandalf, Nazgul';

let arr = isimler.split(', ');

for (let isim of arr) {
  alert( ` ${name}'e mesaj.` ); // Bilbo'e mesaj ve diÄŸerleri.
}

split metodu isteÄŸe baÄŸlı ikincil bir sayısal argüman alabilir – dizinin boyutu. EÄŸer bu verilirse, dizi bu verilen uzunluk kadar dolduktan sonra geri kalanlar görmezden gelinir. Pratikte çok nadir kullanılır.

let dizi = 'Bilbo, Gandalf, Nazgul, Saruman'.split(', ', 2);

alert(arr); // Bilbo, Gandalf

let str = "test";

alert( str.split('') ); // t,e,s,t

arr.join(str) split in tam tersini yapar. arr’den karakter dizileri yaratır.

Örnek:

let dizi = ['Bilbo', 'Gandalf', 'Nazgul'];

let str = dizi.join(';');

alert( str ); // Bilbo;Gandalf;Nazgul

reduce/reduceRight

Dizi elemanlarının üzerinden geçilmek istendiÄŸinde forEach kullanmak mümkündür.

arr.reduce ve arr.reduceRight metodları da bu işe yarar fakat daha dallı budaklıdır. Genelde dizilere göre tek bir karakter dizisini hesaplamaya yarar.

Yazımı:

let value = arr.reduce(function(previousValue, item, index, arr) {
  // ...
}, initial);

Fonksiyon elemanlara uygulanır. İkinciden itibaren benzer bir yazıma rastlayabilirsiniz.

• item – dizinin o anki elemanı.
• index – elemanın pozisyonu.
• arr – dizi.

Åžimdiye kadar forEach/map gibi. Fakat bir argüman daha var:

• previousValue bir önceki fonksiyonun sonucudur initial ilk çaÄŸrının sonucudur.

Örnekle anlatmak gerekirse:

Aşağıda dizinin toplamı bir satırda alınmaktadır:

let arr = [1, 2, 3, 4, 5]

let result = arr.reduce((sum, current) => sum + current, 0);

alert(result); // 15

Burada reduce fonksiyonunun en çok kullanılan 2 argümanlı ÅŸekli kullanıldı.

Detaylarına bakılacak olursa:

1. Ä°lk çalıştırıldığında sum baÅŸlangıç deÄŸerini alır ( reduce’un son argümanı ) 0, ve current dizinin ilk elemanıdır 1. Bundan dolayı sonuç 1 olur.
2. Ä°kinci döngüde sum = 1, buna ikinci dizi elemanı olan 2 eklenir ve döndürülür.
3. Üçüncü döngüde ise sum = 3 ve buna bir sonraki dizi elemanı eklenir ve böyle devam eder.

Hesaplama akışı:

Form tablosunda bunu daha açık bir şekilde görebilirsiniz. Satırlar fonksiyon çağrılarını göstermektedir.

Gördüğünüz gibi bir önceki fonksiyonun sonucu sonraki fonksiyonun argümanı olmakta.

Bunun ile birlikte başlangıç değerini pas geçmekte mümkün:

let arr = [1, 2, 3, 4, 5];

// başlangıç değeri silindi, 0 değil.
let result = arr.reduce((sum, current) => sum + current);

alert( result ); // 15

Sonuç aynı. BaÅŸlangıç deÄŸeri olmadığından dolayı, reduce fonksiyonu diznin ilk elemanını baÅŸlangıç deÄŸeri olarak almakta ve ikinciden itibaren döngüye baÅŸlamaktadır.

Hesaplama tablosu yukarıdaki ile aynı olmaktadır, sadece birinci satır silinir.

Fakat böyle kullanımda çok dikkatli olunmalıdır. EÄŸer dizi boÅŸ ise, recude çaÄŸrısı baÅŸlangıç deÄŸeri olmadığında hata verir.

Örneğin:

let arr = [];

// Hata: Başlangıç değeri olmayan boş dizi ile `reduce` fonksiyonu kullanıldı.
// Eğer başlangıç değeri olsaydı, `reduce` boş diziyi döndürebilirdi.
arr.reduce((sum, current) => sum + current);

Bundan dolayı her zaman başlangıç değeri kullanılması önerilir.

arr.reduceRight metodu da reduce metodu ile aynı iÅŸi yapar fakat diziyi saÄŸdan sola doÄŸru okur.

Tekrar: forEach

arr.forEach metodu her eleman için bir fonksiyon çalıştırmaya yarar.

Yazımı:

arr.forEach(function(item, index, array) {
  // ... elemanla bir ÅŸeyler yap
});

Örneğin aşağıdaki kod dizinin her elemanını göstermeye yarar:

// her eleman için alert çağır
["Bilbo", "Gandalf", "Nazgul"].forEach(alert);

Aşağıdaki kod elemanın dizideki pozisyonu hakkında daha açıklayıcıdır:

["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
  alert(`${item} ${array}'in ${index}. indeksinde`);
});

Eğer fonksiyonun bir sonucu varsa bu görmezden gelinir.

Array.isArray

Diziler farklı bir tip değildir. Obje üzerine kurulmuşlardır.

Bundan dolayı typeof normal obje ile diziyi ayırt etmekte yardımcı olamaz:

alert(typeof {}); // object
alert(typeof []); // aynısı

… Fakat diziler çok kullanıldığından dolayı buna has metod bulunmaktadır: Array.isArray(value) . EÄŸer deÄŸer dizi ise true döndürür. DiÄŸer türlü false döndürür.

alert(Array.isArray({})); // false

alert(Array.isArray([])); // true

Çoğu metod “thisArg”'ı destekler

Fonksiyonları çağıran neredeyse tüm dizi metodları – find, filter, map gibi sort hariç, ayrıca opsiyonel thisArg parametresini kabul eder.

Yukarıdaki bölümde bu parametreden bahsedilmedi, bunun sebebi çok nadir olarak kullanılmasından dolayıdır. Fakat bütünlüğün sağlanmasından dolayı üstünden geçmekte fayda var.

Bu metodlarla “thisArg”'ın yazımı aşağıdaki gibidir:

arr.find(func, thisArg);
arr.filter(func, thisArg);
arr.map(func, thisArg);
// ...
// thisArg isteğe bağlı olarak kullanılan bir argümandır.

thisArg deÄŸeri func için this olmaktadır.

ÖrneÄŸin, aÅŸağıda objenin metodu filtre olarak kullanılmaktadır ve thisArg bu durumda oldukça kullanışlıdır:

let kullanici = {
  yas: 18,
  dahaGenc(digerKullanici) {
    return digerKullanici.yas < this.yas;
  }
};

let kullanicilar = [
  {yas: 12},
  {yas: 16},
  {yas: 32}
];

// kullanıcıdan daha genç kullanıcıları bulunuz
let dahaGencKullanicilar = kullanicilar.filter(kullanici.dahaGenc, kullanici);

alert(dahaGencKullanicilar.length); // 2

Yukarıdaki çaÄŸrıda kullanici.dahaGenc filtre olarak kullanılmaktadır. Ayrıca kullanici bu fonksiyona gönderilmektedir. EÄŸer kullanici.filter(kullanici.dahaGenc)'i vermezseniz, kullanici.dahaGenc this=undefined olarak çaÄŸrılır. Bu da anında hata verir.

Özet

Dizi metodlarının kısa açıklamaları:

• Eleman ekleme/silme metodları:

  • push(...items) – elemanları sona ekler,
  • pop() – en sondaki elemanı alır,
  • shift() – baÅŸlangıçtan eleman alır,
  • unshift(...items) – baÅŸlangıça eleman ekler
  • splice(pos, deleteCount, ...items) – pos indeksinde deleteCount sayısı kadar elemanı siler ve bunları items’a ekler.
  • slice(start, end) – start ile end pozisyonları arasındaki (end dahil deÄŸil) elemanları yeni bir diziye kopyalar.
  • concat(...items) – yeni bir dizi döndürür: var olan dizideki tüm elemanları kopyalar ve items’ı ekler. EÄŸer items dizi ise bunun elemanları da alınır.

• Elemanları aramaya yönelik metodlar:

  • indexOf/lastIndexOf(item, pos) – pos’tan baÅŸlayarak item’ı arar. Bulursa indeksini döndürür, bulamaz ise -1 döndürür.
  • includes(value) – eÄŸer dizi value’ya sahipse true döndürür. DiÄŸer türlü false döndürür.
  • find/filter(func) – Elemanları fonksiyonlar ile filtreler. Buna göre fonksiyonu true yapan ilk veya tamamını döner.
  • findIndex aynı find gibidir fakat bir deÄŸer yerine index döner.

• Diziler üzerinde dönüşümler:

  • map(func) – her eleman için func çaÄŸrılır ve bunların sonuçlarından bir dizi üretilerek döndürülür.
  • sort(func) – diziyi olduÄŸu yerde sıralar ve döndürür.
  • reverse() – diziyi terse çevirir ve döndürür.
  • split/join – karakterleri diziye çevirir veya dizileri karaktere çevirir.
  • reduce(func, initial) – dizide bulunan elemanlar sıra ile func fonksiyonu üzerinden hesaplanır ve son deÄŸer döndürülür.

• Elemanlar üzerinden dönme:

  • forEach(func) – dizide bulunan her eleman için func çaÄŸrılır. hiçbir ÅŸey döndürmez.

• Ek olarak:

  • Array.isArray(arr) arr’in dizi olup olmadığını kontrol eder.

Bu metodların içinden sadece sort, reverse ve splice doÄŸrudan dizinin kendisi üzerinden iÅŸlem yapar. DiÄŸerleri deÄŸer döndürür.

Yukarıdaki metodlar projelerin çoğundaki kullanılan dizi fonksiyonlarının %99’unu kapsar. Fakat bunun yanında farklı metodlar da bulunmaktadır:

• arr.some(fn)/arr.every(fn) diziyi kontrol eder.

  Dizinin her elemanı için fn çağırılır. Map’e çok benzer fakat herhangi biri/hepsi true ise true döndürür. DiÄŸer türlü false döndürür.

• arr.fill(value, start, end) – diziyi tekrar eden value deÄŸeri ile start ile index arasına doldurur.

• arr.copyWithin(target, start, end) – start tan end’e kadar olan elemanları target’tan itibaren var olanların üzerine yazarak yapıştırır.

Tüm liste için kullanım talimatları sayfasına bakabilirsiniz.

Görünürde çok fazla metod varmış gibi ve ezberlemesi zormuş gibi görünse de aslında göründüğünden çok daha kolaydır.

Sadece tanımların bulunduğu sayfaya bakmanız yeterlid. Ardından bu bölümdeki örnekleri çözerek pratik yaparsanız metodlar ile ilgili yeteri kadar bilgi sahibi olmuş olursunuz.

Daha sonrasında metodlar ile ilgili bir şey yapmak istediğinizde, nasıl yapıldığını bilmiyorsanız, buraya tekrar gelip doğru metodu bulabilirsiniz. Buradaki örnekler doğru bir şekilde yazmanıza yardımcı olacaktır. Sonrasında metodları hiçbir özel çaba harcamadan hatırlayacak duruma gelebilirsiniz.