# Koleksiyonlar (Collections)

Dart, listeler, küme ve harita koleksiyonlarına yerleşik destek sunar. Tür koleksiyonlardaki türleri yapılandırmak için Generics konusuna göz atabilirsiniz.

### Listeler (List)

Belki de neredeyse her programlama dilinde en yaygın koleksiyon, dizi veya sıralı nesneler grubudur. Dart'ta diziler List nesneleridir, bu nedenle çoğu insan onlara sadece "lists" der.

Dart listeleri, virgülle ayrılmış bir ifade veya değer listesi ile köşeli parantez içinde belirtilen listelerdir (`[]`). İşte basit bir Dart liste örneği:

```dart
var liste = [1, 2, 3];
```

> **Not**
>
> Dart, listenin türünün `List<int>` olduğunu çıkarır. Bu liste üzerine tamsayı olmayan nesneler eklemeye çalışırsanız, analizör veya çalışma zamanı bir hata bildirir. Daha fazla bilgi için tip çıkarımını inceleyin.

Dart koleksiyon literallerinde son öğeden sonra bir virgül ekleyebilirsiniz. Bu virgül koleksiyonu etkilemez, ancak kopyala-yapıştır hatalarını önlemeye yardımcı olabilir.

```dart
var liste = [
  'Araba',
  'Tekne',
  'Uçak',
];
```

Listeler, 0'dan başlayan bir dizinle kullanılır, 0 ilk değerin dizini ve list.length - 1 son değerin dizinidir. Bir listenin uzunluğunu .length özelliğini kullanarak alabilir ve bir listenin değerlerine köşeli parantez operatörünü kullanarak erişebilirsiniz:

```dart
var liste = [1, 2, 3];
assert(liste.length == 3);
assert(liste[1] == 2);

liste[1] = 1;
assert(liste[1] == 1);
```

Derleme zamanı sabiti bir liste oluşturmak için, liste literali önüne const ekleyin:

```dart
var sabitListe = const [1, 2, 3];
// sabitListe[1] = 1; // Bu satır bir hata verecektir.
```

Daha fazla bilgi için listeler bölümüne bakın.

### Kümeler (Set)

Dart'ta bir küme, benzersiz öğelerin sırasız bir koleksiyonudur. Dart'ın kümelere yönelik desteği, küme literalleri ve Set türü tarafından sağlanır.

İşte küme literali kullanılarak oluşturulmuş basit bir Dart kümesi:

```dart
var halojenler = {'flor', 'klor', 'brom', 'iyot', 'astatin'};
```

> **Not**
>
> Dart, halojenlerin Set\<String> türünde olduğunu çıkarır. Eğer kümeye yanlış türde bir değer eklemeye çalışırsanız, analizör veya çalışma zamanı bir hata verecektir. Daha fazla bilgi için tip çıkarımını inceleyin.

Boş bir küme oluşturmak için, bir tür argümanını takiben {} kullanın veya {}'yi Set türünde bir değişkene atayın:

```dart
var isimler = <String>{};
// Set<String> isimler = {}; // Bu da çalışır.
// var isimler = {}; // Bu bir harita oluşturur, küme değil.
```

Set mi yoksa harita mı? Harita literallerinin sözdizimi, küme literallerinin sözdizimine benzer. Harita literalleri önce geldiği için, `{}` varsayılan olarak Map türüne sahiptir. `{}` veya ona atanan değişken üzerinde tür açıklamasını unutursanız, Dart `{}` veya ona atanan değişken için `Map<dynamic, dynamic>` türünde bir nesne oluşturur.

Varolan bir kümeye `add()` veya `addAll()` yöntemleri kullanarak öğe ekleyebilirsiniz:

```dart
var elementler = <String>{};
elementler.add('flor');
elementler.addAll(halojenler);
```

Kümedeki öğelerin sayısını almak için .length'yi kullanın:

```dart
var elementler = <String>{};
elementler.add('flor');
elementler.addAll(halojenler);
assert(elementler.length == 5);
```

Derleme zamanı sabiti bir küme oluşturmak için, küme literali önüne const ekleyin:

```dart
dartCopy codefinal sabitKume = const {
  'flor',
  'klor',
  'brom',
  'iyot',
  'astatin',
};
// sabitKume.add('helyum'); // Bu satır bir hata verecektir.
```

Daha fazla bilgi için setler bölümüne bakın.

### Haritalar (Maps)

Genel olarak bir harita, anahtarları ve değerleri ilişkilendiren bir nesnedir. Hem anahtarlar hem de değerler her türde nesne olabilir. Her anahtar yalnızca bir kez geçer, ancak aynı değeri birden çok kez kullanabilirsiniz. Dart'ın haritalara yönelik desteği, harita literalleri ve `Map` türü tarafından sağlanır.

İşte harita literalleri kullanılarak oluşturulmuş basit birkaç Dart haritası:

```dart
var hediyeler = {
  // Anahtar:    Değer
  'birinci': 'bayağı kuş',
  'ikinci': 'kumrular',
  'beşinci': 'altın yüzükler'
};

var soyluGazlar = {
  2: 'helyum',
  10: 'neon',
  18: 'argon',
};
```

Not: Dart, hediyelerin `Map<String, String>` türünde olduğunu ve soyluGazların `Map<int, String>` türünde olduğunu çıkarır. Haritaya yanlış türde bir değer eklemeye çalışırsanız, analizör veya çalışma zamanı bir hata verecektir. Daha fazla bilgi için tip çıkarımını inceleyin.

Aynı nesneleri bir `Map` yapıcı kullanarak oluşturabilirsiniz:

```dart
var hediyeler = Map<String, String>();
hediyeler['birinci'] = 'bayağı kuş';
hediyeler['ikinci'] = 'kumrular';
hediyeler['beşinci'] = 'altın yüzükler';

var soyluGazlar = Map<int, String>();
soyluGazlar[2] = 'helyum';
soyluGazlar[10] = 'neon';
soyluGazlar[18] = 'argon';
```

> **Not**
>
> C# veya Java gibi dillerden geliyorsanız, `new Map()` yerine sadece `Map()` görmeyi bekleyebilirsiniz. Dart'ta `new` anahtar kelimesi isteğe bağlıdır. Ayrıntılar için constructor kullanımına bakın.

Varolan bir haritaya yeni bir anahtar-değer çifti eklemek için subscript assignment operator (`[]=`) kullanın:

```dart
var hediyeler = {'birinci': 'bayağı kuş'};
hediyeler['dördüncü'] = 'cazip kuşlar'; // Bir anahtar-değer çifti ekle
```

Bir haritadan bir değeri subscript operator (`[]`) kullanarak alabilirsiniz:

```dart
var hediyeler = {'birinci': 'bayağı kuş'};
assert(hediyeler['birinci'] == 'bayağı kuş');
```

Bir haritada olmayan bir anahtarı ararsanız, null değeri alırsınız:

```dart
var hediyeler = {'birinci': 'bayağı kuş'};
assert(hediyeler['beşinci'] == null);
```

Key-value çiftlerinin sayısını almak için `.length` kullanın:

```dart
var hediyeler = {'birinci': 'bayağı kuş'};
hediyeler['dördüncü'] = 'cazip kuşlar';
assert(hediyeler.length == 2);
```

Derleme zamanı sabiti bir harita oluşturmak için, harita literali önüne `const` ekleyin:

```dart
final sabitHarita = const {
  2: 'helyum',
  10: 'neon',
  18: 'argon',
};

// sabitHarita[2] = 'Helyum'; // Bu satır bir hata verecektir.
```

Daha fazla bilgi için haritalar bölümüne bakın.

### Operatörler (Operators)

#### Yayılma operatörleri (Spread operatos)

Dart, `List`, `Map` ve `Set` literallerinde yayılma operatörünü (`...`) ve null bilincinden dolayı yayılma operatörünü (`...?`) destekler. Yayılma operatörleri, birden çok değeri bir koleksiyona eklemenin özlü bir yolunu sağlar.

Örneğin, yayılma operatörünü (`...`) kullanarak bir listenin tüm değerlerini başka bir liste ekleyebilirsiniz:

```dart
var liste = [1, 2, 3];
var liste2 = [0, ...liste];
assert(liste2.length == 4);
```

Eğer yayılma operatörünün sağındaki ifade null olabilirse, null bilincinden dolayı bir hata önlemek için null bilincinden haberdar yayılma operatörünü (`...?`) kullanabilirsiniz:

```dart
var liste2 = [0, ...?liste];
assert(liste2.length == 1);
```

Yayılma operatörünü kullanmanın ayrıntıları ve örnekleri için yayılma operatörü önerisine bakın.

#### **Kontrol Akış Operatörleri**&#x20;

Dart, `List`, `Map` ve `Set` literallerinde kullanılmak üzere koleksiyon `if` ve koleksiyon `for`'u sunar. Bu operatörleri kullanarak koşullar (`if`) ve tekrarlamalar (`for`) kullanarak koleksiyonlar oluşturabilirsiniz.

İşte koleksiyon `if`'i kullanarak üç veya dört öğeli bir liste oluşturmanın bir örneği:

```dart
var nav = ['Anasayfa', 'Mobilya', 'Bitkiler', if (promoAktif) 'Çıkış'];
```

Dart aynı zamanda koleksiyon içinde if-case'i de destekler:

```dart
var nav = ['Anasayfa', 'Mobilya', 'Bitkiler', if (giriş case 'Yönetici') 'Envanter'];
```

İşte koleksiyon `for`'u kullanarak bir listedeki öğeleri başka bir liste eklemeden önce listeyi manipüle etmenin bir örneği:

```dart
var tamsayiListesi = [1, 2, 3];
var stringListesi = ['#0', for (var i in tamsayiListesi) '#$i'];
assert(stringListesi[1] == '#1');
```

Daha fazla ayrıntı ve koleksiyon `if` ve `for` kullanma örnekleri için kontrol akış koleksiyonları önerisine bakın.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://dart.bayramalacam.com/turler-types/koleksiyonlar-collections.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
