↑↓ seç · Enter aç · Esc kapat

Mutlu Tekin
Mutlu Tekin
← Yazılar

Bölüm 1 — Konu 3: İlk Program (`main()`, `print()`, Dosya Yapısı)

2 dk okuma #dart
Dizi · 3/64 Dart Türkçe Tutorial
  1. Bölüm 1 — Konu 1: Dart Nedir, Nerede Kullanılır, Neden Flutter Bu Dili Seçti
  2. Bölüm 1 — Konu 2: Ortam Kurulumu (Dart SDK, DartPad, Terminal ile Çalıştırma)
  3. Bölüm 1 — Konu 3: İlk Program (`main()`, `print()`, Dosya Yapısı)
  4. Bölüm 1 — Konu 4: Yorum Satırları, Temel Sözdizimi Kuralları
  5. Bölüm 2 — Konu 5: Değişken Tanımlama — `var`, `final`, `const` Farkı
  6. Bölüm 2 — Konu 6: Temel Tipler — `int`, `double`, `String`, `bool`
  7. Bölüm 2 — Konu 7: Tip Çıkarımı (Type Inference) ve Açık Tip Belirtme
  8. Bölüm 2 — Konu 8: `dynamic` ve `Object` — Ne Zaman Kullanılır, Ne Zaman Kaçınılır
  9. Bölüm 2 — Konu 9: Null Safety Temelleri (`?`, `!`, `late`'e Giriş)
  10. Bölüm 3 — Konu 10: Aritmetik, Atama, Karşılaştırma, Mantıksal Operatörler
  11. Bölüm 3 — Konu 11: `if / else if / else`
  12. Bölüm 3 — Konu 12: `switch` / `switch expression` (Modern Dart)
  13. Bölüm 3 — Konu 13: Ternary Operatör, `??`, `??=`, `?.`
  14. Bölüm 3 — Konu 14: `for`, `while`, `do-while` Döngüleri
  15. Bölüm 4 — Konu 16: `List` — Oluşturma, Erişim, Temel Metodlar
  16. Bölüm 4 — Konu 17: `Set` — Benzersiz Eleman Mantığı
  17. Bölüm 4 — Konu 18: `Map` — Key-Value Yapılar
  18. Bölüm 4 — Konu 19: Koleksiyon Üzerinde `for-in`, `forEach`
  19. Bölüm 4 — Konu 20: Spread Operatörü (`...`, `...?`) ve Collection If/For
  20. Bölüm 5 — Konu 21: Fonksiyon Tanımlama, Parametreler (Positional, Named, Optional)
  21. Bölüm 5 — Konu 22: Varsayılan Parametre Değerleri (Derinlemesine)
  22. Bölüm 5 — Konu 23: Arrow Function (`=>`) Sözdizimi
  23. Bölüm 5 — Konu 24: Fonksiyonlar Birinci Sınıf Vatandaş — Değişkene Atama, Parametre Olarak Geçme
  24. Bölüm 5 — Konu 25: Anonim Fonksiyonlar ve Closure Kavramı (Derinlemesine)
  25. Bölüm 5 — Konu 26: Recursion (Özyineleme)
  26. Bölüm 6 — Konu 27: Class Tanımlama, Constructor (Varsayılan, Named, Factory)
  27. Bölüm 6 — Konu 28: Alanlar (Fields), Metodlar, `this` Kullanımı (Derinlemesine)
  28. Bölüm 6 — Konu 29: Initializer List, Constructor Kısayolları (Derinlemesine)
  29. Bölüm 6 — Konu 30: Getter / Setter
  30. Bölüm 6 — Konu 31: Statik Üyeler (`static`)
  31. Bölüm 7 — Konu 32: Kalıtım (`extends`), `super` Kullanımı
  32. Bölüm 7 — Konu 33: Metod Override Etme, `@override`
  33. Bölüm 7 — Konu 34: Soyut Sınıflar (`abstract class`)
  34. Bölüm 7 — Konu 35: Interface Mantığı (`implements`)
  35. Bölüm 7 — Konu 36: Mixin (`with`)
  36. Bölüm 7 — Konu 37: `enum` — Basit ve Gelişmiş (Metotlu Enum'lar)
  37. Bölüm 8 — Konu 38: `try / catch / finally`, `throw`
  38. Bölüm 8 — Konu 39: Özel Exception Sınıfları Yazma
  39. Bölüm 8 — Konu 40: Sound Null Safety Derinlemesine — `late`, `required`, Non-Nullable Varsayılan Davranış
  40. Bölüm 8 — Konu 41: `assert` ile Geliştirme Zamanı Kontrolleri
  41. Bölüm 9 — Konu 42: Generic Sınıflar ve Fonksiyonlar
  42. Bölüm 9 — Konu 43: Generic Sınırlamalar (`<T extends ...>`)
  43. Bölüm 9 — Konu 44: Dart'ın Built-in Generic Koleksiyonları Nasıl Çalışır
  44. Bölüm 10 — Konu 45: `Future` Kavramı, `async`/`await`
  45. Bölüm 10 — Konu 46: `Future.then`, Hata Yönetimi (`catchError`)
  46. Bölüm 10 — Konu 47: `Stream` Temelleri, `async*`, `yield`
  47. Bölüm 10 — Konu 48: `StreamController`, Broadcast Stream
  48. Bölüm 11 — Konu 49: `map`, `where`, `reduce`, `fold`
  49. Bölüm 11 — Konu 50: `sort`, Custom Comparator ile Sıralama
  50. Bölüm 11 — Konu 51: Iterable Kavramı Derinlemesine (Lazy Evaluation)
  51. Bölüm 11 — Konu 52: Cascade Notasyonu (`..`)
  52. Bölüm 12 — Konu 53: `pubspec.yaml`, pub.dev'den Paket Ekleme
  53. Bölüm 12 — Konu 54: Kütüphane Oluşturma, `import`/`export`, `part`/`part of`
  54. Bölüm 12 — Konu 55: Dart'ta Test Yazımı (`test` Paketi, Unit Test Mantığı)
  55. Bölüm 12 — Konu 56: Extension Methods
  56. Bölüm 12 — Konu 57: Dart'ın Derleme Modelleri (JIT vs AOT) ve Bunun Flutter'a Etkisi
  57. Bölüm 13 — Konu 59: Dart 3 Pattern Matching — Records, Destructuring, Sealed Classes, Exhaustive Switch
  58. Bölüm 13 — Konu 60: `Never` Tipi, `covariant` ve Generic Variance Detayları
  59. Bölüm 13 — Konu 61: Event Loop Derinlemesine — Microtask Queue vs Event Queue
  60. Bölüm 13 — Konu 62: Memory Model & Performans — Garbage Collection, `const` Nesnelerin Bellek Avantajı
  61. Bölüm 13 — Konu 63: Isolate'ler Arası Mesajlaşmanın Maliyeti ve `compute()`'un İç İşleyişi
  62. Bölüm 13 — Konu 64: FFI (Foreign Function Interface) — C Koduna Erişim
  63. Bölüm 13 — Konu 65: Sunucu Tarafında Dart — `dart:io`, `shelf` Paketiyle Basit Bir Backend/CLI Aracı Yazma
  64. Bölüm 13 — Konu 66: Derleyici & Analiz Araçları — `dart analyze`, Custom Lint Kuralları, `build_runner` Mimarisi
Dizinin sayfası →
İçindekiler 8 başlık
  1. main() Fonksiyonu — Programın Giriş Kapısı
  2. print() Fonksiyonu — Konsola Çıktı Verme
  3. Komut Satırı Argümanları (args) — Şimdilik Kısa Bir Bakış
  4. Dosya Yapısı — Bir Dart Dosyası Nasıl Görünür?
  5. print() ile String Birleştirme — Küçük Bir Önizleme
  6. Sık Yapılan Başlangıç Hataları
  7. 🎯 Bu Dersten Çıkarılması Gerekenler
  8. 📝 Ödevler

main() Fonksiyonu — Programın Giriş Kapısı

Her Dart programının tek bir zorunlu unsuru vardır: main() fonksiyonu. Dart çalışma zamanı (runtime), bir dosyayı çalıştırırken önce main() fonksiyonunu arar ve programı oradan başlatır.

dart
void main() {
  print("Merhaba Dart!");
}

Bunu parça parça açalım:

  • void — bu fonksiyonun geri değer döndürmediğini belirtir. main() fonksiyonu bir şey hesaplayıp döndürmez, sadece programı çalıştırır.
  • main — fonksiyonun adı. Bu isim sabittir, değiştirilemez — Dart runtime'ı özellikle bu isimde bir fonksiyon arar.
  • () — parantezler, fonksiyonun parametre almadığını gösteriyor (aslında main komut satırı argümanlarını List<String> args olarak da alabilir, buna birazdan değineceğiz).
  • { } — süslü parantezler, fonksiyonun gövdesini (body) yani çalıştırılacak kod bloğunu belirtir.

print(), Dart'ın standart kütüphanesinde (dart:core içinde, otomatik olarak her yerde erişilebilir) tanımlı bir fonksiyondur. Görevi basittir: verdiğin değeri konsola (terminale veya DartPad çıktı paneline) yazdırmak.

dart
void main() {
  print("Bu bir metin");
  print(42);
  print(3.14);
  print(true);
}

Çıktı:

metin
Bu bir metin
42
3.14
true

Dikkat et — print() sadece string değil, herhangi bir değeri yazdırabilir. Arka planda Dart, verdiğin değeri otomatik olarak string'e çevirir (bu, her nesnenin sahip olduğu toString() metodu sayesinde olur — bunu Bölüm 6'da sınıflar konusunda detaylı göreceğiz).

Komut Satırı Argümanları (args) — Şimdilik Kısa Bir Bakış

main() fonksiyonu isteğe bağlı olarak bir parametre alabilir:

dart
void main(List<String> args) {
  print("Aldığım argümanlar: $args");
}

Bu programı terminalden şöyle çalıştırırsan:

bash
dart run merhaba.dart selam dunya

Çıktı:

metin
Aldığım argümanlar: [selam, dunya]

Bu konuyu şimdi derinlemesine işlemiyoruz (koleksiyonları henüz görmedik), ama main()'in bu şekilde de kullanılabildiğini bilmen yeterli — ileride CLI araçları yazarken (Bölüm 13) bu önemli olacak.

Dosya Yapısı — Bir Dart Dosyası Nasıl Görünür?

Basit bir .dart dosyası genelde şu sırayı takip eder:

dart
// 1. Import ifadeleri (varsa) - dışarıdan kütüphane/paket dahil etme
import 'dart:math';

// 2. Üst seviye değişkenler/sabitler (varsa)
const String uygulamaAdi = "İlk Programım";

// 3. Fonksiyonlar (main dahil, başka yardımcı fonksiyonlar da olabilir)
void main() {
  print(uygulamaAdi);
  selamVer();
}

void selamVer() {
  print("Merhaba!");
}

Şu an import satırını detaylı açmıyoruz (Bölüm 12'de kütüphaneler konusunda işleyeceğiz), sadece dosyanın genel iskeletini tanıman için gösteriyorum. Önemli olan şu: Dart dosyaları yukarıdan aşağıya okunur ama main() her zaman programın gerçek başlangıç noktasıdır — dosyanın neresinde tanımlanırsa tanımlansın.

Bölüm 2'de string interpolation'ı detaylı göreceğiz ama şimdiden küçük bir örnek görmen faydalı:

dart
void main() {
  String isim = "Ayşe";
  print("Merhaba, " + isim + "!");   // klasik birleştirme (+)
  print("Merhaba, $isim!");          // Dart'a özgü, daha temiz yöntem
}

İkisi de aynı çıktıyı verir: Merhaba, Ayşe! — ama $isim kullanımı Dart'ta çok daha yaygın ve idiomatic'tir. Bunu bir sonraki bölümde detaylandıracağız.

Sık Yapılan Başlangıç Hataları

dart
void main() {
  print("Merhaba")   // ❌ noktalı virgül unutuldu
}

Dart'ta her ifade (statement) noktalı virgülle (;) biter. Bunu unutmak en yaygın başlangıç hatasıdır — derleyici sana açık bir hata mesajıyla bunu bildirecektir.

dart
void Main() {   // ❌ büyük harfle "Main" yazıldı
  print("Hata verir");
}

Dart case-sensitive (büyük/küçük harf duyarlı) bir dildir. main ile Main tamamen farklı isimlerdir, runtime sadece küçük harfle yazılan main'i tanır.


🎯 Bu Dersten Çıkarılması Gerekenler

  • main() her Dart programının zorunlu giriş noktasıdır, ismi değiştirilemez.
  • print() herhangi bir değeri konsola yazdırır, arka planda toString() kullanır.
  • main(List<String> args) ile komut satırı argümanları alınabilir (ileride kullanılacak).
  • Dart case-sensitive'dir ve her ifade noktalı virgülle biter.

📝 Ödevler

  • [ ] main() fonksiyonu içinde kendi adını, en sevdiğin sayıyı ve bugünün doğru/yanlış bir ifadesini (örn. "bugün pazartesi mi") 3 ayrı print() ile yazdır.
  • [ ] main(List<String> args) kullanarak terminalden verdiğin isim argümanını "Merhaba, [isim]!" şeklinde yazdıran bir program yaz.
  • [ ] Bilerek noktalı virgülü unutarak bir hata oluştur, derleyicinin verdiği hata mesajını oku ve ne anlama geldiğini yorumla.
  • [ ] selamVer() gibi kendi yazdığın ayrı bir fonksiyonu main() içinden çağıran bir örnek yaz (fonksiyonları detaylı işlemedik ama bu basit çağrıyı deneyerek görmen faydalı).

Sıradaki konu: Bölüm 1 — Konu 4: Yorum Satırları, Temel Sözdizimi Kuralları