↑↓ seç · Enter aç · Esc kapat

Mutlu Tekin
Mutlu Tekin
← Yazılar

Bölüm 12 — Konu 54: Kütüphane Oluşturma, `import`/`export`, `part`/`part of`

4 dk okuma #dart
Dizi · 53/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 10 başlık
  1. Dart'ta "Kütüphane" (Library) Kavramı
  2. Basit Bir Proje Yapısı Örneği
  3. package: Prefix'i ile Import
  4. Dış Bir Paketi Import Etme
  5. export — Bir Kütüphaneyi Yeniden Dışa Aktarma
  6. Sadece Belirli Üyeleri Import/Export Etme
  7. part / part of — Bir Dosyayı Birden Fazla Fiziksel Dosyaya Bölme
  8. Gerçek Bir Proje Organizasyonu Örneği
  9. 🎯 Bu Dersten Çıkarılması Gerekenler
  10. 📝 Ödevler

Dart'ta "Kütüphane" (Library) Kavramı

Bölüm 6'da _ (alt çizgi) ile private alan/metod tanımlamayı öğrenmiştik ve "bu, dosyaya (library) özeldir" demiştik. Şimdi bu "library" kavramını tam olarak açıklayalım: Dart'ta, her .dart dosyası aslında kendi başına bir kütüphanedir (özel bir library anahtar kelimesi yazmasan bile).

Basit Bir Proje Yapısı Örneği

metin
benim_projem/
  lib/
    matematik_yardimci.dart
    main.dart
  pubspec.yaml

lib/matematik_yardimci.dart:

dart
int kare(int x) => x * x;
int kup(int x) => x * x * x;

int _dahiliYardimci(int x) => x + 1; // alt çizgi ile private

lib/main.dart:

dart
import 'matematik_yardimci.dart'; // aynı klasördeki dosyayı import ediyoruz

void main() {
  print(kare(5)); // 25
  print(kup(3));  // 27

  print(_dahiliYardimci(5)); // ❌ HATA! private, başka dosyadan erişilemez
}

import 'matematik_yardimci.dart';, bir dosyanın public (alt çizgisiz) tüm üyelerini (fonksiyonlar, sınıflar, değişkenler) mevcut dosyaya "getirir." Bölüm 6'da öğrendiğimiz _ kuralı burada devreye giriyor — _dahiliYardimci, sadece matematik_yardimci.dart dosyasının kendi içinde kullanılabilir, main.dart'a import edilmez.

package: Prefix'i ile Import

Aynı proje içinde, lib/ klasörünün kökünden import etmek için package: sözdizimi kullanılır:

dart
import 'package:benim_projem/matematik_yardimci.dart';

Bu, bir üstteki basit import 'matematik_yardimci.dart'; (relative/göreli import) ile aynı dosyayı işaret eder, ama package: sözdizimi, dosyanın projenin neresinde olursa olsun, her zaman aynı şekilde import edilmesini sağlar (Flutter projelerinde, farklı klasörlerdeki dosyalar arasında import yaparken bunu sıkça göreceksin).

Ne zaman hangisi kullanılır?

  • Relative import ('matematik_yardimci.dart' veya '../utils/matematik.dart'): Aynı proje içinde, birbirine yakın dosyalar arasında.
  • package: import: Dış bir pakete (Bölüm 12 Konu 53'te öğrendiğimiz pub.dev paketleri) erişirken zorunludur, kendi projen içinde de kullanılabilir ama genelde relative import tercih edilir.

Dış Bir Paketi Import Etme

dart
import 'package:http/http.dart' as http;

void main() async {
  // http paketinin fonksiyonlarını 'http.' öneki ile kullanabiliriz
}

as http, import edilen paketin tüm üyelerine http. öneki ile erişmeni sağlar — bu, isim çakışmalarını önlemek için kullanılır. Eğer iki farklı paket, aynı isimde bir fonksiyon/sınıf tanımlıyorsa, as ile bunları ayırt edebilirsin.

dart
import 'package:paket_a/paket_a.dart' as a;
import 'package:paket_b/paket_b.dart' as b;

void main() {
  a.birFonksiyon(); // paket_a'daki fonksiyon
  b.birFonksiyon();  // paket_b'daki, aynı isimli ama FARKLI fonksiyon
}

export — Bir Kütüphaneyi Yeniden Dışa Aktarma

dart
// lib/matematik.dart
export 'matematik_temel.dart';
export 'matematik_ileri.dart';

export, başka dosyaların içeriğini, senin dosyan üzerinden de erişilebilir hale getirir. Bu, birden fazla küçük dosyayı tek bir "giriş noktası" altında birleştirmek için kullanılır:

dart
// main.dart
import 'matematik.dart'; // hem matematik_temel.dart hem matematik_ileri.dart'ın içeriğine erişebiliyoruz!

Bu kalıp, özellikle kendi paketini yazarken (Bölüm 13'te pub.dev'e paket yayınlamayı işleyeceğiz) çok kullanışlıdır — paketini kullanan kişi, sadece tek bir dosyayı import ederek, senin içeride nasıl organize ettiğinle ilgilenmeden, tüm public API'ye erişebilir.

Sadece Belirli Üyeleri Import/Export Etme

dart
import 'matematik_yardimci.dart' show kare; // sadece 'kare' fonksiyonunu getir

void main() {
  print(kare(5)); // ✅ çalışır
  print(kup(3));  // ❌ HATA! kup import edilmedi
}
dart
import 'matematik_yardimci.dart' hide kup; // her şeyi getir, 'kup' HARİÇ

void main() {
  print(kare(5)); // ✅ çalışır
  print(kup(3));  // ❌ HATA! kup bilerek hariç tutuldu
}

show ve hide, bir import'un hangi üyeleri getireceğini kontrol etmeni sağlar — bu, büyük kütüphanelerden sadece ihtiyacın olan kısmı almak veya isim çakışmalarını önlemek için kullanışlıdır.

part / part of — Bir Dosyayı Birden Fazla Fiziksel Dosyaya Bölme

Bazen, tek bir mantıksal kütüphaneyi, okunabilirlik için birden fazla fiziksel dosyaya bölmek istersin — ama bu dosyaların hepsinin aynı kütüphanenin parçası olduğunu belirtmen gerekir. İşte bunun için part/part of kullanılır:

dart
// lib/hayvan.dart (ana dosya)
part 'hayvan_metodlari.dart';

class Hayvan {
  String isim;
  Hayvan(this.isim);
}
dart
// lib/hayvan_metodlari.dart (parça dosya)
part of 'hayvan.dart';

extension HayvanUzantisi on Hayvan {
  void selamVer() => print("Merhaba, ben ${isim}");
}

part/part of ile import arasındaki fark: import, iki ayrı kütüphane arasında bir bağlantı kurar (her biri kendi private alanına sahiptir). part/part of ise, birden fazla dosyayı tek bir kütüphane olarak birleştirir — yani hayvan.dart ve hayvan_metodlari.dart, aslında aynı private scope'u paylaşır (birindeki _ozelAlan, diğerinde de erişilebilir).

Ne zaman kullanılır? part/part of, genelde code generation (kod üretimi — Bölüm 13'te build_runner konusunda göreceğiz) ile otomatik üretilen dosyalarda veya çok büyük, tek bir mantıksal birim olan sınıfları (örneğin çok sayıda extension method içeren bir sınıf) organize etmek için kullanılır. Günlük kodlamada import/export çok daha yaygındır — part/part of'u bilmen yeterli, sık sık yazman gerekmeyebilir.

Gerçek Bir Proje Organizasyonu Örneği

metin
lib/
  models/
    kullanici.dart
    urun.dart
  services/
    api_servisi.dart
  utils/
    formatlayici.dart
  main.dart
dart
// main.dart
import 'models/kullanici.dart';
import 'models/urun.dart';
import 'services/api_servisi.dart';
import 'utils/formatlayici.dart';

Bu, gerçek Dart/Flutter projelerinde standart bir organizasyon kalıbıdır — ilgili dosyalar klasörlere gruplanır, main.dart (veya başka bir merkezi dosya) gerektiği yerlerden import eder. Bunu Flutter tutorial'ında proje yapısı konusunda çok daha detaylı göreceksin.


🎯 Bu Dersten Çıkarılması Gerekenler

  • Her .dart dosyası, kendi başına bir kütüphanedir; _ ile başlayan üyeler o dosyaya özeldir.
  • import, başka bir dosyanın public üyelerini mevcut dosyaya getirir; relative ('dosya.dart') veya package: sözdizimiyle yapılabilir.
  • as ile import edilen bir kütüphaneye önek vererek isim çakışmalarını önleyebilirsin.
  • export, birden fazla dosyayı tek bir "giriş noktası" altında birleştirmeni sağlar.
  • show/hide, bir import'un hangi üyeleri getireceğini sınırlar.
  • part/part of, birden fazla fiziksel dosyayı tek bir kütüphane (aynı private scope) olarak birleştirir — import'tan farklı olarak ayrı kütüphaneler oluşturmaz.

📝 Ödevler

  • [ ] Kendi küçük bir yardımcı kütüphaneni (lib/matematik_yardimci.dart) yaz, içinde en az 2 public ve 1 private fonksiyon olsun, başka bir dosyadan import edip kullan.
  • [ ] Aynı isimde bir fonksiyon tanımlayan iki farklı dosya oluştur, as kullanarak ikisini de aynı dosyada, çakışmadan kullan.
  • [ ] export kullanarak, iki ayrı dosyayı tek bir "giriş dosyası" üzerinden dışa aktar, başka bir dosyadan tek bir import ile ikisine de eriş.
  • [ ] show ve hide kullanarak, aynı dosyadan farklı üyeleri seçici olarak import eden iki örnek yaz.
  • [ ] Basit bir part/part of örneği dene — bir sınıfı ana dosyada tanımla, bir extension'ı part ile ayrı bir dosyada tanımla.

Sıradaki konu: Bölüm 12 — Konu 55: Dart'ta Test Yazımı (test Paketi, Unit Test Mantığı)