# Dahili Tipler (Build-in Types)

Dart dilinde şu özel tiplere özel destek bulunmaktadır:

* Sayılar (int, double)
* Dizeler (String)
* Booleanlar (bool)
* Kayıtlar (value1, value2)
* Listeler (List, aynı zamanda diziler olarak bilinir)
* Setler (Set)
* Haritalar (Map)
* Runes (Runes; genellikle karakterler API tarafından değiştirilir)
* Semboller (Symbol)
* null değeri (Null)

Bu destek, nesneleri literaller kullanarak oluşturma yeteneğini içerir. Örneğin, 'bu bir dizedir' bir dize literali ve true bir boolean literali.

Dart'ta her değişkenin bir sınıf örneği olan bir nesneye atıfta bulunduğunu unutmayın. Genellikle değişkenleri başlatmak için yapılandırıcıları kullanabilirsiniz. Bazı yerleşik tiplerin kendi yapılandırıcıları vardır. Örneğin, bir harita oluşturmak için `Map()` yapılandırıcısını kullanabilirsiniz.

Bazı diğer tipler de Dart dilinde özel rolleri vardır:

* Object: Null hariç tüm Dart sınıflarının üst sınıfı.
* Enum: Tüm enumların üst sınıfı.
* Future ve Stream: Asenkron destekte kullanılır.
* Iterable: for-in döngülerinde ve senkron jeneratör fonksiyonlarında kullanılır.
* Never: Bir ifadenin asla başarıyla değerlendirilemeyeceğini belirtir. Genellikle her zaman istisna fırlatan fonksiyonlar için kullanılır.
* dynamic: Statik kontrolü devre dışı bırakmak istediğinizi belirtir. Genellikle bunun yerine Object veya Object? kullanmalısınız.
* void: Bir değerin asla kullanılmadığını belirtir. Genellikle bir dönüş türü olarak kullanılır.

Object, Object?, Null ve Never sınıfları sınıf hiyerarşisinde özel rolleri vardır. Bu roller hakkında bilgi için "null safety" anlayışını inceleyin.

### Sayılar

Dart sayıları iki türde gelir:

* int: Platforma bağlı olarak 64 bit'ten büyük olmayan tamsayı değerleri. Web üzerinde tamsayı değerleri, JavaScript sayıları olarak temsil edilir (kesirli kısmı olmayan 64 bit kayan noktalı sayılar) ve -253 ile 253 - 1 arasında olabilir.
* double: IEEE 754 standardında belirtildiği gibi 64 bit (çift hassasiyetli) kayan noktalı sayılar.

Hem `int` hem de `double`, `num` alt tipleridir. `num` tipi, +, -, / gibi temel operatörleri içerir ve aynı zamanda `abs()`, `ceil()`, `floor()` gibi diğer yöntemleri bulunan yerdir. (<< gibi bitişik operatörler `int` sınıfında tanımlanmıştır.) Eğer `num` ve alt tiplerinde aradığınız şey yoksa, `dart:math` kütüphanesinde bulabilirsiniz.

Tamsayılar ondalık noktasız sayılardır. İşte tamsayı literallerini tanımlamanın bazı örnekleri:

```dart
var x = 1;
var hex = 0xDEADBEEF;
```

Bir sayı ondalık içeriyorsa, o bir double'dır. İşte double literallerini tanımlamanın bazı örnekleri:

```dart
var y = 1.1;
var exponents = 1.42e5;
```

Ayrıca bir değişkeni `num` olarak bildirebilirsiniz. Bunu yaptığınızda, değişken hem `int` (tamsayı) hem de `double` değerlere sahip olabilir.

```dart
num x = 1; // x hem int hem de double değerlere sahip olabilir
x += 2.5;
```

Tamsayı literalleri otomatik olarak `double`'lara dönüştürülür:

```dart
// String -> int
var bir = int.parse('1');
assert(bir == 1);

// String -> double
var birNoktaBir = double.parse('1.1');
assert(birNoktaBir == 1.1);

// int -> String
String birAsString = 1.toString();
assert(birAsString == '1');

// double -> String
String piAsString = 3.14159.toStringAsFixed(2);
assert(piAsString == '3.14');
```

`int` türü, geleneksel bit kaydırma (<<, >>, >>>), tümleme (\~), VE (&), VEYA (|), ve XOR (^) operatörlerini belirtir. Bunlar bit alanlarında bayrakları manipüle etmek için kullanışlıdır. Örneğin:

```dart
assert((3 << 1) == 6); // 0011 << 1 == 0110
assert((3 | 4) == 7); // 0011 | 0100 == 0111
assert((3 & 4) == 0); // 0011 & 0100 == 0000
```

Daha fazla örnek için bitişik ve kaydırma operatörü bölümüne bakın.

Literal sayılar derleme zamanı sabitleridir. Operandları sayı olan derleme zamanı sabitler olduğu sürece, birçok aritmetik ifade de derleme zamanı sabitidir.

```dart
const msSaniyeBasi = 1000;
const tekrarDenemeyeKadarSaniyeler = 5;
const tekrarDenemeyeKadarMilisaniyeler = tekrarDenemeyeKadarSaniyeler * msSaniyeBasi;
```

Daha fazla bilgi için Dart'ta Sayılar sayfasına bakın.

### Dizeler

Bir Dart dizesi (String nesnesi), UTF-16 kod birimlerinin bir dizisini tutar. Bir dize oluşturmak için tek veya çift tırnakları kullanabilirsiniz:

```dart
var s1 = 'Tek tırnaklar dize literalleri için iyi çalışır.';
var s2 = "Çift tırnaklar da aynı şekilde çalışır.";
var s3 = 'Dize sınırlayıcısını kaçırmak kolaydır.';
var s4 = "Diğer sınırlayıcıyı kullanmak ise daha da kolaydır.";
```

Bir ifadenin değerini bir dizenin içine yerleştirmek için `${expression}` kullanabilirsiniz. Eğer ifade bir tanımlayıcı ise, `{}`'yi atlayabilirsiniz. Bir nesnenin karşılık gelen dizesini almak için Dart, nesnenin `toString()` yöntemini çağırır.

```dart
var s = 'dize enterpolasyonu';

assert('Dart\'ın $s özelliği çok kullanışlıdır.' ==
    'Dart\'ın dize enterpolasyonu, '
        'çok kullanışlıdır.');
assert('Bunu bütün harflerle yazmalısın. '
        '${s.toUpperCase()} çok kullanışlıdır!' ==
    'Bunu bütün harflerle yazmalısın. '
        'DİZE ENTERPOLASYONU çok kullanışlıdır!');
```

> **Not**
>
> `==` operatörü, iki nesnenin eşit olup olmadığını test eder. İki dize, aynı kod birimleri dizisini içeriyorsa eşittir.

Dizeleri bitişik dize literalleri veya + operatörü kullanarak birleştirebilirsiniz:

```dart
var s1 = 'Dize '
    'birleştirmesi'
    " hatta satır sonları üzerinde çalışır.";
assert(s1 ==
    'Dize birleştirmesi hatta satır sonları üzerinde '
        'çalışır.');

var s2 = 'Artı operatörü ' + 'çalışır, aynı şekilde.';
assert(s2 == 'Artı operatörü çalışır, aynı şekilde.');
```

Çok satırlı bir dize oluşturmak için üçlü tırnak kullanın, ya tek ya da çift tırnak işareti ile:

```dart
var s1 = '''
Bu şekilde
çok satırlı diziler oluşturabilirsiniz.
''';

var s2 = """Bu da bir
çok satırlı dizedir.""";
```

"Ham" bir dize oluşturmak için başına r ekleyin:

```dart
var s = r'Düz bir dizide, hatta \n bile özel işlem görmez.';
```

Unicode karakterlerini bir dizide nasıl ifade edeceğiniz hakkında detaylar için Runes ve grafem kümeleri bölümüne bakın.

Literal dizeler derleme zamanı sabitleridir, iç içe geçmiş ifade bir derleme zamanı sabitine dönüşürse ve bu sabit null veya sayısal, dize veya boolean bir değere değerlendirilirse.

```dart
// Bu bir const dizede çalışır.
const birSabitSayi = 0;
const birSabitBool = true;
const birSabitDize = 'sabit bir dize';

// Bu bir const dizede ÇALIŞMAZ.
var birSayi = 0;
var birBool = true;
var birDize = 'bir dize';
const birSabitListe = [1, 2, 3];

const gecerliSabitDize = ${birSabitSayi} ${birSabitBool} ${birSabitDize};
// const gecersizSabitDize = ${birSayi} ${birBool} ${birDize} ${birSabitListe};
```

Dizeleri kullanma hakkında daha fazla bilgi için Dizeler ve düzenli ifadeler sayfasına göz atın.

### Boolean

Boolean değerleri temsil etmek için Dart'ta bool adında bir tür bulunmaktadır. `bool` türünde yalnızca iki nesne bulunur: true ve false boolean literalleri, her ikisi de derleme zamanı sabitleridir.

Dart'ın tip güvenliği, `if (nonbooleanValue)` veya `assert (nonbooleanValue)` gibi kodları kullanamayacağınız anlamına gelir. Bunun yerine, değerleri açıkça kontrol etmelisiniz, örneğin:

```dart
// Boş bir dize için kontrol et.
var tamAd = '';
assert(tamAd.isEmpty);

// Sıfır için kontrol et.
var vurusNoktasi = 0;
assert(vurusNoktasi <= 0);

// Null için kontrol et.
var tekboynuz = null;
assert(tekboynuz == null);

// NaN için kontrol et.
var isteğimiYaptım = 0 / 0;
assert(isteğimiYaptım.isNaN);
```

### Runes ve Grafem Kümeleri

Dart'ta, runeler bir dizenin Unicode kod noktalarını ortaya çıkarır. Kullanıcı tarafından algılanan karakterleri, yani Unicode (genişletilmiş) grafem kümelerini görüntülemek veya manipüle etmek için characters paketini kullanabilirsiniz.

Unicode, dünyanın tüm yazı sistemlerinde kullanılan her harf, rakam ve simge için benzersiz bir sayısal değer tanımlar. Bir Dart dizesi UTF-16 kod birimlerinin bir dizisi olduğundan, bir dize içinde Unicode kod noktalarını ifade etmek için özel bir sözdizimi gereklidir. Bir Unicode kod noktasını ifade etmenin yaygın yolu `\uXXXX`, burada XXXX 4 haneli onaltılık bir değerdir. Örneğin, kalp karakteri (♥) `\u2665`'tir. 4 onaltılık hane yerine değeri süslü parantez içine alabilirsiniz. Örneğin, gülme emoji (😆) `\u{1f606}`'dır.

Bireysel Unicode karakterlerini okuma veya yazma ihtiyacınız varsa, characters paketi tarafından String üzerinde tanımlanan characters alıcısını kullanın. Dönen Characters nesnesi, dizenin bir dizi grafem kümesi olarak temsilidir. İşte characters API'ını kullanmanın bir örneği:

```dart
import 'package:characters/characters.dart';

void main() {
  var merhaba = 'Merhaba 🌍';
  print(merhaba);
  print('Dizenin sonu: ${merhaba.substring(merhaba.length - 1)}');
  print('Son karakter: ${merhaba.characters.last}');
}
```

Çıktı, ortamınıza bağlı olarak şuna benzer olacaktır:

```
dart run main.dart
Merhaba 🌍
Dizenin sonu: ???
Son karakter: 🌍
```

Dize manipülasyonları için characters paketini kullanma hakkında daha fazla bilgi için characters paketinin örnek ve API referansına bakın.

### Semboller

Bir Symbol nesnesi, bir Dart programında bildirilen bir operatörü veya tanımlayıcıyı temsil eder. Semboller kullanmanız gerekli olmayabilir, ancak tanımlayıcı adlarını değiştirmeğin, ancak sembol adlarını değiştirmediği API'lar için çok değerli oldukları durumlar vardır.

Bir tanımlayıcı için sembolü almak için, sadece tanımlayıcının yanına `#` ekleyin:

```dart
#foo
#bar
```