Veri Tipleri
BERK statik tipli bir dildir ve çeşitli built-in veri tipleri sunar.
Temel Tipler
Sayı (Number)
Tamsayı ve ondalıklı sayılar için:
değişken tam = 42
değişken ondalık = 3.14
değişken negatif = -100
değişken bilimsel = 1.5e10 // 15000000000
Yazı (String)
Metin değerleri:
değişken isim = "Ahmet"
değişken mesaj = 'Merhaba Dünya!'
değişken çok_satır = """
Bu
çok satırlı
bir metindir
"""
String interpolation:
değişken ad = "Ali"
değişken yaş = 25
yazdır("Benim adım {ad} ve {yaş} yaşındayım")
// Çıktı: Benim adım Ali ve 25 yaşındayım
Boolean (Mantıksal)
Doğru/yanlış değerleri:
değişken doğru_mu = doğru // true
değişken yanlış_mı = yanlış // false
// İngilizce
var is_valid = true
var is_empty = false
Null
Değer yokluğu:
değişken değer = null
değişken sonuç: Sayı? = null // Nullable tip
Koleksiyon Tipleri
Liste (List)
Sıralı elemanlar koleksiyonu:
değişken sayılar = [1, 2, 3, 4, 5]
değişken isimler: Liste<Yazı> = ["Ahmet", "Mehmet", "Ayşe"]
değişken karışık = [1, "iki", 3.0, doğru] // Mixed types
// Erişim
yazdır(sayılar[0]) // 1
yazdır(isimler[2]) // Ayşe
// Değiştirme
sayılar[0] = 10
// Uzunluk
yazdır(sayılar.uzunluk) // 5
Liste metodları:
değişken liste = [1, 2, 3]
liste.ekle(4) // [1, 2, 3, 4]
liste.çıkar(1) // [1, 3, 4]
liste.içerir(3) // doğru
liste.temizle() // []
Demet (Tuple)
Sabit boyutlu, farklı tipli elemanlar:
değişken konum = (41.0082, 28.9784) // (lat, lon)
değişken kişi = ("Ahmet", 30, "İstanbul")
// Destructuring
değişken (lat, lon) = konum
değişken (ad, yaş, şehir) = kişi
// İndeks erişimi
yazdır(konum.0) // 41.0082
yazdır(kişi.1) // 30
Harita (Map/Dictionary)
Anahtar-değer çiftleri:
değişken sözlük = {
"ad": "Ahmet",
"yaş": 30,
"şehir": "İstanbul"
}
// Erişim
yazdır(sözlük["ad"]) // Ahmet
// Ekleme/Güncelleme
sözlük["meslek"] = "Mühendis"
sözlük["yaş"] = 31
// Kontrol
eğer sözlük.içerir("ad") {
yazdır("Ad bulundu")
}
// Tip belirtimi
değişken notlar: Harita<Yazı, Sayı> = {
"Matematik": 85,
"Fizik": 90,
"Kimya": 78
}
Küme (Set)
Benzersiz elemanlar koleksiyonu:
değişken kume = {1, 2, 3, 3, 2, 1} // {1, 2, 3}
kume.ekle(4) // {1, 2, 3, 4}
kume.çıkar(2) // {1, 3, 4}
kume.içerir(3) // doğru
// Set işlemleri
değişken a = {1, 2, 3}
değişken b = {2, 3, 4}
değişken birleşim = a | b // {1, 2, 3, 4}
değişken kesişim = a & b // {2, 3}
değişken fark = a - b // {1}
Struct Tipleri
Özel veri yapıları tanımlama:
tür Kişi = struct {
ad: Yazı,
yaş: Sayı,
email: Yazı
}
// Instance oluşturma
değişken kişi = Kişi {
ad: "Ahmet",
yaş: 30,
email: "ahmet@example.com"
}
// Alan erişimi
yazdır(kişi.ad) // Ahmet
yazdır(kişi.yaş) // 30
// Güncelleme
kişi.yaş = 31
Enum Tipleri
Sabit değerler kümesi:
tür Renk = enum {
Kırmızı,
Yeşil,
Mavi
}
değişken favori = Renk.Kırmızı
eş favori {
Renk.Kırmızı => yazdır("Kırmızı seçildi"),
Renk.Yeşil => yazdır("Yeşil seçildi"),
Renk.Mavi => yazdır("Mavi seçildi")
}
Enum değerlerle:
tür HttpDurum = enum {
Tamam = 200,
Bulunamadı = 404,
Sunucu Hatası = 500
}
değişken durum = HttpDurum.Tamam
yazdır(durum.değer) // 200
Sonuç Tipi (Result)
Hata yönetimi için:
tür Sonuç<T, E> = enum {
Tamam(T),
Hata(E)
}
işlev böl(a: Sayı, b: Sayı) -> Sonuç<Sayı, Yazı> {
eğer b == 0 {
hata dön "Sıfıra bölme!"
}
tamam dön a / b
}
değişken sonuç = böl(10, 2)
eş sonuç {
Tamam(değer) => yazdır("Sonuç: ", değer),
Hata(mesaj) => yazdır("HATA: ", mesaj)
}
Seçenek Tipi (Option)
Nullable alternatifi:
tür Seçenek<T> = enum {
Bazı(T),
Hiç
}
işlev bul(liste: Liste<Sayı>, hedef: Sayı) -> Seçenek<Sayı> {
döngü i 0'dan liste.uzunluk'a kadar {
eğer liste[i] == hedef {
geri dön Bazı(i)
}
}
geri dön Hiç
}
değişken indeks = bul([1, 2, 3, 4], 3)
eş indeks {
Bazı(i) => yazdır("Bulundu: ", i),
Hiç => yazdır("Bulunamadı")
}
Tip Dönüşümleri
Açık Dönüşüm (Casting)
değişken x = 10
değişken y = x as Ondalık // 10.0
değişken metin = "42"
değişken sayı = metin.parse<Sayı>() // 42
Tip Kontrol
değişken değer: Any = "Hello"
eğer değer is Yazı {
yazdır("Bu bir string")
}
eğer değer is Sayı {
yazdır("Bu bir sayı")
}
Tip Takma Adları (Type Alias)
tür KullanıcıID = Sayı
tür Email = Yazı
tür Koordinat = (Sayı, Sayı)
değişken id: KullanıcıID = 12345
değişken email: Email = "user@example.com"
değişken konum: Koordinat = (41.0, 29.0)
Boyutlar ve Sınırlar
sabit SAYI_MIN = -9223372036854775808 // i64 min
sabit SAYI_MAX = 9223372036854775807 // i64 max
sabit ONDALIK_MIN = -1.7976931348623157e+308 // f64 min
sabit ONDALIK_MAX = 1.7976931348623157e+308 // f64 max
sabit YAZI_MAX_UZUNLUK = 2147483647 // ~2GB
Tip Çıkarımı
BERK güçlü tip çıkarımı yapar:
// Tip otomatik belirlenir
değişken sayı = 42 // Sayı
değişken pi = 3.14 // Ondalık
değişken isim = "Ahmet" // Yazı
değişken doğru_mu = doğru // Boolean
değişken liste = [1, 2, 3] // Liste<Sayı>
// Karmaşık çıkarımlar
değişken harita = { // Harita<Yazı, Sayı>
"a": 1,
"b": 2
}
değişken fonksiyon = (x) => x * 2 // (Sayı) -> Sayı
Best Practices
✅ Yapılması Gerekenler
// Açık tip belirtimi karmaşık durumlarda
değişken kullanıcılar: Liste<Kullanıcı> = []
// Immutable veri için const kullan
sabit API_ANAHTARI = "gizli_anahtar"
// Result tipi hata yönetimi için
işlev dosya_oku(yol: Yazı) -> Sonuç<Yazı, Hata> { ... }
❌ Kaçınılması Gerekenler
// Gereksiz tip belirtimi
değişken x: Sayı = 10 // "değişken x = 10" yeterli
// Any tipini fazla kullanmak
değişken karışık: Any = ... // Mümkünse spesifik tip kullan
// Null yerine Option kullan
değişken değer = null // Option<T> tercih et
Örnek: Tüm Tipler
işlev ana() {
// Temel tipler
değişken sayı: Sayı = 42
değişken ondalık: Ondalık = 3.14
değişken metin: Yazı = "Hello"
değişken bool: Boolean = doğru
// Koleksiyonlar
değişken liste: Liste<Sayı> = [1, 2, 3]
değişken demet: (Sayı, Yazı) = (1, "bir")
değişken harita: Harita<Yazı, Sayı> = {"a": 1}
değişken küme: Küme<Sayı> = {1, 2, 3}
// Özel tipler
tür Nokta = struct { x: Sayı, y: Sayı }
değişken p = Nokta { x: 10, y: 20 }
// Sonuç tipi
değişken sonuç: Sonuç<Sayı, Yazı> = Tamam(42)
}