> For the complete documentation index, see [llms.txt](https://uby-rn.gitbook.io/react-native/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://uby-rn.gitbook.io/react-native/ders-1.0/javascript-temelleri/array-dizi/dizi-metodlari.md).

# Dizi Metodları

JavaScript'te, dizilerle çalışırken işlerinizi kolaylaştıran bir dizi metod bulunmaktadır. Bu metodlar, dizilerde eleman eklemek, çıkarmak, döngü içinde işlem yapmak, filtreleme yapmak gibi birçok faydalı işlevi yerine getirir. Bu rehberde, JavaScript'in yaygın kullanılan dizi metodlarını ayrıntılı bir şekilde ele alacağız.

### 1. push()

`push()` metodu, bir dizinin sonuna bir veya daha fazla eleman ekler.

```javascript
let meyveler = ["elma", "armut", "muz"]; 

meyveler.push("çilek"); 

console.log(meyveler); // ["elma", "armut", "muz", "çilek"]
```

### 2. pop()

`pop()` metodu, bir dizinin sonundaki elemanı kaldırır ve bu elemanı döndürür.

```javascript
let meyveler = ["elma", "armut", "muz"]; 
let sonMeyve = meyveler.pop();

console.log(sonMeyve);
// "muz"

console.log(meyveler);
// ["elma", "armut"]
```

### 3. shift()

`shift()` metodu, bir dizinin başındaki elemanı kaldırır ve bu elemanı döndürür.

```javascript
let meyveler = ["elma", "armut", "muz"]; 
let ilkMeyve = meyveler.shift();

console.log(ilkMeyve); 
// "elma" 

console.log(meyveler); 
// ["armut", "muz"]
```

### 4. unshift()

`unshift()` metodu, bir dizinin başına bir veya daha fazla eleman ekler.

```javascript
let meyveler = ["elma", "armut", "muz"]; 

meyveler.unshift("çilek");

console.log(meyveler); 
// ["çilek", "elma", "armut", "muz"]
```

### 5. concat()

`concat()` metodu, iki veya daha fazla diziyi birleştirir ve yeni bir dizi oluşturur.

```javascript
let meyveler1 = ["elma", "armut"]; 
let meyveler2 = ["muz", "çilek"]; 
let yeniMeyveler = meyveler1.concat(meyveler2); 

console.log(yeniMeyveler); 
// ["elma", "armut", "muz", "çilek"]
```

### 6. slice()

`slice()` metodu, belirtilen başlangıç ve bitiş indisleri arasındaki elemanları kesip yeni bir dizi oluşturur.

```javascript
let meyveler = ["elma", "armut", "muz", "çilek", "karpuz"]; 
let dilim = meyveler.slice(1, 4); 

console.log(dilim); 
// ["armut", "muz", "çilek"]
```

### 7. splice()

`splice()` metodu, belirtilen indisten başlayarak bir diziye eleman ekler veya belirtilen indisten başlayarak belirtilen sayıda elemanı kaldırır.

```javascript
let meyveler = ["elma", "armut", "muz", "çilek"]; 

meyveler.splice(2, 0, "karpuz"); 
// 2. indisten başlayarak 0 elemanı sil ve "karpuz" ekle 

console.log(meyveler);
// ["elma", "armut", "karpuz", "muz", "çilek"] 

meyveler.splice(1, 2);
// 1. indisten başlayarak 2 elemanı sil 

console.log(meyveler); 
// ["elma", "muz", "çilek"]
```

### 8. forEach()

`forEach()` metodu, bir dizideki her bir eleman üzerinde belirtilen işlevi uygular.

```javascript
let meyveler = ["elma", "armut", "muz"]; 

meyveler.forEach(function(meyve) {
    console.log(meyve); 
}); 
// "elma" // "armut" // "muz"
```

### 9. indexOf()

`indexOf()` metodu, belirli bir öğenin dizideki ilk indeksini bulur. Eğer öğe dizide bulunmazsa -1 döner.

```javascript
let meyveler = ["elma", "armut", "muz", "çilek", "karpuz"]; 
let index = meyveler.indexOf("muz"); 

console.log(index); 
// 2
```

### 10. lastIndexOf()

`lastIndexOf()` metodu, belirli bir öğenin dizideki son indeksini bulur. Eğer öğe dizide bulunmazsa -1 döner.

```javascript
let meyveler = ["elma", "armut", "muz", "çilek", "muz"]; 
let lastIndex = meyveler.lastIndexOf("muz"); 

console.log(lastIndex); 
// 4
```

### 11. includes()

`includes()` metodu, belirli bir öğenin dizide bulunup bulunmadığını kontrol eder. Bulunursa `true`, bulunmazsa `false` döner.

```javascript
let meyveler = ["elma", "armut", "muz", "çilek"];
let varMi = meyveler.includes("armut");

console.log(varMi); 
// true
```

### 12. every()

`every()` metodu, dizideki her bir öğe için belirli bir koşulu kontrol eder. Eğer tüm öğeler koşulu sağlarsa `true`, en az bir öğe koşulu sağlamazsa `false` döner.

```javascript
let sayilar = [10, 20, 30, 40, 50]; 

let hepsiBuyukMu = sayilar.every(function(sayi) {
    return sayi > 20; 
}); 

console.log(hepsiBuyukMu); 
// false
```

### 13. some()

`some()` metodu, dizideki en az bir öğe için belirli bir koşulu kontrol eder. Eğer en az bir öğe koşulu sağlarsa `true`, hiçbir öğe koşulu sağlamazsa `false` döner.

```javascript
let sayilar = [10, 20, 30, 40, 50]; 

let enAzBirTaneBuyukMu = sayilar.some(function(sayi) { 
    return sayi > 20;
}); 

console.log(enAzBirTaneBuyukMu); 
// true
```

### 14. filter()

`filter()` metodu, belirli bir koşulu sağlayan öğeleri içeren yeni bir dizi döndürür.

```javascript
let sayilar = [10, 20, 30, 40, 50]; 

let buyukSayilar = sayilar.filter(function(sayi) {
    return sayi > 20; 
});

console.log(buyukSayilar);
// [30, 40, 50]
```

### 15. map()

`map()` metodu, bir dizi içindeki her bir öğe için belirli bir işlemi uygular ve sonuçları yeni bir dizi olarak döndürür.

```javascript
let sayilar = [1, 2, 3, 4, 5]; 

let kareler = sayilar.map(function(sayi) { 
    return sayi * sayi; 
}); 

console.log(kareler); 
// [1, 4, 9, 16, 25]
```

### 16. reduce()

`reduce()` metodu, bir dizi içindeki her bir öğeyi belirli bir işlemle azaltarak tek bir değer döndürür.

```javascript
let sayilar = [1, 2, 3, 4, 5]; 

let toplam = sayilar.reduce(function(acc, curr) { 
    return acc + curr; 
}, 0); 

console.log(toplam); 
// 15
```

### 17. join()

`join()` metodu, bir dizinin elemanlarını birleştirerek bir dize oluşturur.

```javascript
let meyveler = ["elma", "armut", "muz"];
let meyveString = meyveler.join(", ");

console.log(meyveString);
// "elma, armut, muz"
```

### 18. reverse()

`reverse()` metodu, bir dizinin elemanlarını ters çevirir.

```javascript
let sayilar = [1, 2, 3, 4, 5];
sayilar.reverse();

console.log(sayilar);
// [5, 4, 3, 2, 1]
```

### 19. sort()

`sort()` metodu, bir dizinin elemanlarını alfabetik olarak veya belirli bir sıraya göre sıralar. Varsayılan sıralama alfabetiktir.

```javascript
let meyveler = ["elma", "armut", "muz"];

meyveler.sort();

console.log(meyveler); 
// ["armut", "elma", "muz"]

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

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

console.log(sayilar);
// [1, 2, 3, 4, 5]
```

### 20. fill()

`fill()` metodu, bir dizinin belirli bir aralığına belirli bir değeri atar.

```javascript
let sayilar = [1, 2, 3, 4, 5];

sayilar.fill(0, 2, 4); 
// 2. indeksten başlayarak 4. indekse kadar olan aralığı 0 ile doldurur 

console.log(sayilar); 
// [1, 2, 0, 0, 5]
```

### 21. find()

`find()` metodu, belirli bir koşulu sağlayan ilk öğeyi bulur ve bu öğeyi döndürür.

```javascript
let sayilar = [10, 20, 30, 40, 50];

let bulunanSayi = sayilar.find(function(sayi) {
    return sayi > 20;
}); 

console.log(bulunanSayi); // 30
```

### 22. findIndex()

`findIndex()` metodu, belirli bir koşulu sağlayan ilk öğenin indeksini bulur ve bu indeksi döndürür.

```javascript
let sayilar = [10, 20, 30, 40, 50];

let indeks = sayilar.findIndex(function(sayi) {
    return sayi > 20;
});

console.log(indeks);
// 2
```

### 23. flat()

`flat()` metodu, iç içe geçmiş alt dizileri belirli bir derinlik seviyesine kadar düzleştirir.

```javascript
let dizi = [1, 2, [3, 4], [5, [6, 7]]];

let duzDizi = dizi.flat();

console.log(duzDizi);
// [1, 2, 3, 4, 5, [6, 7]]
```

### 24. flatMap()

`flatMap()` metodu, bir dizi elemanına bir işlev uygulayarak ve ardından sonuçları düzleştirerek yeni bir dizi oluşturur.

```javascript
let dizi = [1, 2, 3];

let yeniDizi = dizi.flatMap(function(sayi) {
    return [sayi * 2, sayi * 3];
}); 

console.log(yeniDizi);
// [2, 3, 4, 6, 6, 9]
```

***

{% hint style="info" %}
Bu metodlar da JavaScript'te dizilerle çalışırken faydalı olan ve sıklıkla kullanılan dizi metodlarıdır.
{% endhint %}