# Dart'a Giriş

Bu sayfa, Dart programlama diline kısa bir giriş sunarak temel özellikleri örneklerle anlatmaktadır.

Dart dilini daha fazla tanımak ve öğrenmek için, sol taraftaki menüde listelenen konu sayfalarını ziyaret edebilirsiniz.

Unutmayın ki, Dart'ı keşfetmek heyecan verici bir yolculuktur ve bu yazı size bu yolculukta rehberlik etmeyi amaçlamaktadır. Keyifli okumalar!

### Merhaba Dünya

Dart dili yürütmenin başladığı `main()` fonksiyonuna ihtiyaç duyar. Geri dönüş değeri açıkca belirtilmeyen fonksiyonlar `void` geri dönüş türüne sahiptir. Metni konsolda görüntülemek için `print()` fonksiyonunu kullanabilirsiniz:

```dart
void main() {
  print('Merhaba, Dünya!');
}
```

Dart'taki `main()` fonksiyonu hakkında, komut satırı argümanları için isteğe bağlı parametreler dahil olmak üzere daha fazla bilgi için okumaya devam edin.

### Değişkenler

Bir çok değişkeni var anahtar kelimesini kullanarak açıkca veri tipi belirtmeden tanımlayabilirsiniz. Veri tipi çıkarımı özelliği sayesinde, bu değişkenlerin veri tipi başlangıç değerine göre otomatik olarak belirlenir.

```dart
var isim = 'Bayram';
var yil = 2000;
var boy = 172.5;
var gezegenler = ['Merkür', 'Venüs', 'Dünya', 'Mars', 'Jüpiter'];
var resim = {
  'etiketler': ['Venüs'],
  'url': '//dizin/venus.jpg'
};
```

Varsayılan değerler, `final` ve `const` anahtar kelimeleri, ve `static` türler dahil değişkenler hakkında daha fazla bilgi için okumaya devam edin.

### Kontrol Akışı İfadeleri

Dart, genel kontrol akışı ifadelerini destekler:

```dart
if (yil >= 2001) {
  print('21. yüzyıl');
} else if (yil >= 1901) {
  print('20. yüzyıl');
}

for (final gezegen in gezegenler) {
  print(gezegen);
}

for (int ay = 1; ay <= 12; ay++) {
  print(ay);
}

while (yil < 2016) {
  yil += 1;
}
```

Dart'taki kontrol akışı ifadeleri hakkında, `break` ve `continue`, `switch` ve `case`, ve `assert` dahil olmak üzere daha fazla bilgi için okumaya devam edin.

### Fonksiyonlar

Her fonksiyonun argümanları ve geri dönüş değeri türlerini belirtmenizi öneririz:

```dart
int fibonacci(int n) {
  if (n == 0 || n == 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

var sonuc = fibonacci(20);
```

Tek bir ifade içeren fonksiyonlar için ok atama (arrow) sözdizimi, özellikle anonim fonksiyonları argüman olarak iletmek için kullanışlıdır:

```dart
gezegenler.where((gezegen) => gezegen.contains('türn')).forEach(print);
```

Bu kod, bir anonim fonksiyonu (`where()` fonksiyonuna olan argümanı) göstermenin yanı sıra, bir fonksiyonu bir argüman olarak kullanabileceğinizi gösterir: `print()` fonksiyonu, `forEach()` fonksiyonuna olan bir argümandır.

Fonksiyonlar hakkında daha fazla [bilgi için](https://dart.bayramalacam.com/fonksiyonlar-functions/genel-bakis), isteğe bağlı parametreler, varsayılan parametre değerleri ve leksikal kapsam dahil olmak üzere Dart'taki fonksiyonlar hakkında okumaya devam edin.

### Yorum Satırı

Dart yorumları satırları genellikle // ile başlar.

```dart
// Bu, normal tek satırlı bir yorumdur.

/// Bu, kütüphaneleri, sınıfları ve üyelerini belgelemek için kullanılan bir belgeleme yorumudur.
/// IDE'ler ve dartdoc gibi araçlar, belge yorumlarını özel olarak işler.
```

```dart
/* Bu tür yorumlar da desteklenir. */
```

Dart'ta yorumlar hakkında ve belgelendirme araçları nasıl çalışır, dahil olmak üzere daha fazla bilgi için okumaya devam edin.

### Import (İçe Aktarma)

Diğer kütüphanelerde tanımlanan API'lara erişmek için import kullanılır.

```dart
// Temel kütüphaneleri içe alma
import 'dart:math';

// Harici paketlerden kütüphaneleri içe alma
import 'package:test/test.dart';

// Dosyaları içe alma
import 'dizin/diger_dosya.dart';
```

Kütüphaneler ve görünürlük hakkında, kütüphane ön ekleri, `show` ve `hide`, ve `deferred` anahtar kelimesi aracılığıyla tembel yükleme dahil olmak üzere Dart'taki daha fazla bilgi için okumaya devam edin.

### Class (Sınıflar)

İşte üç özelliği, iki kurucusu ve bir yöntemi olan bir sınıfın örnekleriyle ilgili bir örnek. Bir özelliğin doğrudan ayarlanamaması durumunda, bir değişken yerine bir `getter` yöntemi kullanılarak tanımlanır.

```dart
class UzayAraci {
  String isim;
  DateTime? firlatmaTarihi;

  // Salt okunur, değiştirilemeyen özellik
  int? get firlatmaYili => firlatmaTarihi?.year;

  // Kurucu, üye değişkenlere atama için sentaktik şeker içerir.
  UzayAraci(this.isim, this.firlatmaTarii) {
    // Başlatma kodu buraya yazılır.
  }

  // Varsayılan kurucuya yönlendiren adlandırılmış kurucu.
  UzayAraci.firlatilmamis(String isim) : this(isim, null);

  // Yöntem.
  void tanimla() {
    print('Uzay Aracı: $isim');
    // Tip tanıma, getter'lar üzerinde çalışmaz.
    var firlatmaTarihi = this.firlatmaTarihi;
    if (firlatmaTarihi != null) {
      int yil = DateTime.now().difference(firlatmaTarihi).inDays ~/ 365;
      print('Fırlatıldı: $firlatmaYili ($yil yıl önce)');
    } else {
      print('Fırlatılmadı');
    }
  }
}
```

Daha fazla bilgi için, `string` içlemeleri, `string` yerine koyma, ifadeler, ve `toString()` yöntemi dahil stringler hakkında okumaya devam edin.

UzayAraci sınıfını şu şekilde kullanabilirsiniz:

```dart
var voyager = UzayAraci('Voyager I', DateTime(1977, 9, 5));
voyager.tanimla();

var voyager3 = UzayAraci.firlatilmamis('Voyager III');
voyager3.tanimla();

```

Başlatıcı listeleri, isteğe bağlı `new` ve `const`, yönlendiren kurucular, fabrika kurucular, `getter`'lar, `setter`'lar ve daha fazlası dahil olmak üzere Dart'taki sınıflar hakkında daha fazla bilgi için okumaya devam edin.

### Enum'lar

Enum'lar, belirli bir küme değeri veya örneği sıralamak için kullanılan bir yoldur ve bu türün başka örneklerinin olmamasını sağlar.

İşte basit bir enum örneği, önceden tanımlanmış gezegen türlerini içeren:

```dart
enum GezegenTuru { kara, gaz, buz }
```

İşte gezegenleri tanımlayan bir sınıfın gelişmiş enum deklarasyonu örneği, kendi güneş sistemimizin gezegenlerini içeren sabit örnek setini tanımlar.

```dart
/// Gezegen türünü ve bazı özelliklerini sıralayan bir enum
enum Gezegen {
  merkur(gezegenTuru: GezegenTuru.kara, uydular: 0, halkalariVar: false),
  venus(gezegenTuru: GezegenTuru.kara, uydular: 0, halkalariVar: false),
  // ···
  uranus(gezegenTürü: GezegenTuru.buz, uydular: 27, halkalariVar: true),
  neptun(gezegenTürü: GezegenTuru.buz, uydular: 14, halkalariVar: true);

  /// Sabit üreten kurucu
  const Gezegen(
      {required this.gezegenTuru, required this.uydular, required this.halkalariVar});

  /// Tüm örnek değişkenleri final
  final GezegenTuru gezegenTuru;
  final int uydular;
  final bool halkalariVar;

  /// Gelişmiş enum'lar getter ve diğer yöntemleri destekler
  bool get devGezegen =>
      gezegenTürü == GezegenTuru.gaz || gezegenTuru == GezegenTuru.buz;
}
```

Gezegen enum'ını şu şekilde kullanabilirsiniz:

```dart
final gezegeniniz = Gezegen.dunya;

if (!gezegeniniz.devGezegen) {
  print('Gezegeniniz bir "dev gezegen" değil.');
}
```

Dart'ta enum ile ilgili daha fazla bilgi edinmek için, geliştirilmiş enum gereksinimleri, otomatik olarak tanıtılan özellikler, enum değer isimlerine erişim, `switch` ifadesi desteği ve daha fazlasını içeren konulara odaklanabilirsiniz.

### Inheritance (Miras Alma) <a href="#inheritance" id="inheritance"></a>

Dart, tek miras alma özelliğine sahiptir.

```dart
class Uydu extends UzayAraci {
  double yukseklik;

  Uydu(super.isim, DateTime super.fizikselBaslangicTarihi, this.yukseklik);
}
```

Sınıfları genişletme, isteğe bağlı `@override` açıklaması ve daha fazlası hakkında bilgi edinin.

### Mixin

Mixin, kodu birden fazla sınıf hiyerarşisinde yeniden kullanmanın bir yoludur. Aşağıda bir mixin örneği bulunmaktadır:

```dart
mixin Pilotlu {
  int astronotlar = 1;

  void ekiptenBahset() {
    print('Astronot sayısı: $astronotlar');
  }
}
```

Bir sınıfa bir mixin'in yeteneklerini eklemek için sadece mixin'i sınıf ile genişletin.

```dart
class PilotluArac extends UzayAraci with Pilotlu {
  // ···
}
```

`PilotluArac` artık astronotlar alanına sahiptir ve `ekiptenBahset()` metodunu içerir.

Mixin'ler hakkında daha fazla bilgi edinin.

### Interface (Arayüz) ve Abstract (Soyut) Sınıflar

Tüm sınıflar örtük olarak bir arayüz tanımlar. Bu nedenle herhangi bir sınıfı uygulayabilirsiniz.

```dart
class SahteUzayGemisi implements UzayAraci {
  // ···
}
```

Örtük arayüzler veya açık arayüz anahtar kelimesi hakkında daha fazla bilgi edinin.

Bir soyut sınıf oluşturarak bir sınıf tarafından genişletilmek (veya uygulanmak) üzere tasarlanmış soyut metodlar içerebilirsiniz. Soyut sınıflar boş gövdeler içeren soyut metodları içerebilir.

```dart
abstract class Tanitilabilir {
  void tanimla();

  void vurguIleTanimla() {
    print('=========');
    tanimla();
    print('=========');
  }
}
```

`Tanitilabilir`'i genişleten herhangi bir sınıf, `tanimla()` metodunun uygulamasına sahip olacak ve `vurguIleTanimla()` metodunu çağıracaktır.

Abstract sınıfı ve metodlar hakkında daha fazla bilgi edinin.

### Async (Asenkron)

`Async` ve `await` kullanarak geri çağrı karmaşasını önleyin ve kodunuzu çok daha okunabilir hale getirin.

```dart
const birSaniye = Duration(seconds: 1);
// ···
Future<void> gecikmeliYazdir(String mesaj) async {
  await Future.delayed(birSaniye);
  print(mesaj);
}
```

Yukarıdaki yöntem, aşağıdaki gibi eşdeğerdir:

```dart
Future<void> gecikmeliYazdir(String mesaj) {
  return Future.delayed(birSaniye).then((_) {
    print(mesaj);
  });
}
```

Aşağıdaki örnek gösterildiği gibi, async ve await asenkron kodu okunması kolay hale getirir.

```dart
Future<void> aciklamalarOlustur(Iterable<String> nesneler) async {
  for (final nesne in nesneler) {
    try {
      var dosya = File('$nesne.txt');
      if (await dosya.exists()) {
        var degistirilmeTarihi = await dosya.lastModified();
        print('$nesne için dosya zaten var. Son değiştirme tarihi: $degistirilmeTarihi.');
        continue;
      }
      await dosya.create();
      await dosya.writeAsString('$nesne için açıklama yapmaya başla.');
    } on IOException catch (e) {
      print('$nesne için açıklama oluşturulamıyor: $e');
    }
  }
}
```

Ayrıca async\* kullanabilirsiniz, bu size güzel, okunabilir bir şekilde akışlar oluşturmanıza olanak tanır.

```dart
Stream<String> rapor(UzayAraci arac, Iterable<String> nesneler) async* {
  for (final nesne in nesneler) {
    await Future.delayed(birSaniye);
    yield '${arac.isim} $nesne tarafından uçuyor';
  }
}
```

Asenkron işlemleri destekleyen async fonksiyonlar, `Future`, `Stream` ve asenkron döngü (await for) hakkında daha fazla bilgi edinin.

### Exceptions (İstisnalar)

Bir istisna çıktısı için throw kullanın:

```dart
if (astronotlar == 0) {
  throw StateError('Astronot yok.');
}
```

Bir istisnayı yakalamak için, `try` ifadesini `on` veya `catch` (veya her ikisi) ile kullanın:

```dart
Future<void> ucanNesneleriAcikla(List<String> ucanNesneler) async {
  try {
    for (final nesne in ucanNesneler) {
      var aciklama = await File('$nesne.txt').readAsString();
      print(aciklama);
    }
  } on IOException catch (e) {
    print('Nesne açıklanamadı: $e');
  } finally {
    ucanNesneler.clear();
  }
}

```

Yukarıdaki kod asenkron olduğuna dikkat edin; `try`, hem senkron kod hem de asenkron fonksiyon içinde çalışır.

İstisnalar hakkında, yığın izleme, yeniden atma ve Hata ile İstisna arasındaki fark gibi konularda daha fazla bilgi edinin.

\
\ <br>