Ana içeriğe geç

İlk Programınız

Bu dokümantasyon, Lordex programlama dilinde temel program yapılarını ve sözdizimini uygulamalı örneklerle açıklar. Her bölüm, belirli bir dil özelliğini tanıtmak ve pratik kullanım senaryolarını göstermek üzere tasarlanmıştır.

Temel Program Yapısı​

Bir Lordex programı, yorumlayıcı tarafından sırayla çalıştırılan ifadelerden oluşur. Program akışı, kontrol yapıları ve fonksiyon çağrıları ile yönetilir. Lordex, dinamik tip sistemine sahiptir ve değişken tanımlamaları için özel anahtar kelime gerektirmez.

Minimum Program Örneği​

En basit Lordex programı, tek bir çıktı ifadesinden oluşabilir. .lordex veya .lx uzantılı bir dosya oluşturun:

yaz("Merhaba Dünya!")

Bu program, yaz() built-in fonksiyonunu kullanarak standart çıktıya metin yazdırır. Fonksiyon, parametre olarak aldığı değeri otomatik olarak string temsiline dönüştürür ve sonuna satır sonu karakteri ekler.

Geliştirme Ortamı Notları:

  • Lordex için özel IDE desteği bulunmamaktadır (Alpha sürümü)
  • Herhangi bir metin editörü kullanılabilir (VS Code, Notepad++, Sublime Text)
  • Syntax highlighting için JavaScript veya Python dil modları yaklaşık uyum sağlayabilir

Program Çalıştırma​

Lordex yorumlayıcısı, komut satırından dosya yolu parametre olarak verilerek çalıştırılır:

lordex merhaba.lordex

Beklenen Çıktı:

Merhaba Dünya!

Yorumlayıcı, programı baştan sona okuyarak her ifadeyi sırayla çalıştırır. Hata durumunda, hata mesajı satır ve sütun bilgisi ile birlikte raporlanır.

Değişken Tanımlama ve Kullanma​

Lordex'te değişkenler dinamik olarak tiplendirilir ve tanımlama için özel anahtar kelime kullanılmaz. Atama operatörü (=) ile değer atandığında değişken otomatik olarak oluşturulur ve tipi belirlenir.

Tip Sistemi ve Değişken Yaşam Döngüsü​

// String tipinde değişken
isim = "Lordex"

// Float tipinde değişken
versiyon = 0.1

// Boolean tipinde değişken (Lordex'e özgü anahtar kelime)
aktif = evet

// Değişken değerlerinin kullanımı
yaz("Programlama Dili: " + isim)
yaz("Versiyon: " + versiyon)
yaz("Aktif mi? " + aktif)

Çıktı Analizi:

Programlama Dili: Lordex
Versiyon: 0.1
Aktif mi? true

String birleştirme operatörü (+), farklı tiplerdeki değerleri otomatik olarak string temsiline dönüştürür. Boolean değer evet (true) çıktıda İngilizce karşılığı ile gösterilir.

Değişken İsimlendirme Kuralları:

Lexer seviyesinde uygulanan kısıtlamalar:

  • İlk karakter: harf (a-z, A-Z) veya alt çizgi (_)
  • Sonraki karakterler: harf, rakam (0-9) veya alt çizgi
  • Unicode desteği: Türkçe karakterler (ç, ğ, ı, ö, ş, ü) kullanılabilir
  • Rezerve edilmiş kelimeler değişken ismi olamaz: yaz, oku, eger, iken, icin, fonksiyon, geri_don, evet, hayir

Uygun örnekler: isim, toplam_sayi, kullanici_1, yaş, _private Uygun olmayan örnekler: 1sayi (sayı ile başlıyor), eger (rezerve kelime), değer-tutarı (tire karakteri)

Aritmetik Operatörler ve İfadeler​

Lordex, standart aritmetik operatörleri destekler. Operatör önceliği ve sonuçlandırma kuralları C diline benzer şekilde uygulanır.

Temel Operatörler​

sayi1 = 10
sayi2 = 5

// Toplama operatörü (+)
toplam = sayi1 + sayi2        // 15

// Çıkarma operatörü (-)
fark = sayi1 - sayi2          // 5

// Çarpma operatörü (*)
carpim = sayi1 * sayi2        // 50

// Bölme operatörü (/)
bolum = sayi1 / sayi2         // 2

// Mod operatörü (%) - kalan hesabı
kalan = sayi1 % sayi2         // 0

yaz("Toplam: " + toplam)
yaz("Fark: " + fark)
yaz("Çarpım: " + carpim)
yaz("Bölüm: " + bolum)

Operatör Önceliği:

  1. Parantez içi ifadeler ()
  2. Çarpma, bölme, mod: *, /, %
  3. Toplama, çıkarma: +, -

Tip Dönüşümü: İki integer arasında bölme işlemi, sonuç kesirli ise float tipine dönüştürülür. Örneğin 10 / 3 sonucu 3.333... değerini üretir.

Kullanıcı Etkileşimi ve Girdi İşleme​

oku() fonksiyonu, standart girdiden (stdin) veri okur ve string tipinde değer döndürür. Bu fonksiyon, kullanıcının Enter tuşuna basmasını bekler.

Girdi Okuma ve Tip Dönüşümü​

yaz("Adınız nedir?")
isim = oku()

yaz("Yaşınız kaç?")
yas = int(oku())

yaz("")
yaz("=== Bilgileriniz ===")
yaz("İsim: " + isim)
yaz("Yaş: " + yas)

Çalışma Zamanı Davranışı:

Program çalıştırıldığında kullanıcıdan sırayla girdi bekler:

Adınız nedir?
> Ahmet
Yaşınız kaç?
> 25

=== Bilgileriniz ===
İsim: Ahmet
Yaş: 25

Kritik Noktalar:

  1. Dönüş Tipi: oku() her durumda string döndürür. Sayısal işlemler için explicit tip dönüşümü gereklidir.

  2. Tip Dönüşüm Fonksiyonları:

    • int(string): String'i integer'a çevirir. Geçersiz format runtime hatası üretir.
    • float(string): String'i float'a çevirir.

  3. Hata Yönetimi: Alpha sürümünde geçersiz girdi kontrolü kullanıcı sorumluluğundadır.

// Yanlış: String ile sayısal işlem
yas_str = oku()           // "25"
yas_iki_kat = yas_str * 2 // HATA: String çarpılamaz

// Doğru: Önce tip dönüşümü
yas = int(oku())          // 25 (integer)
yas_iki_kat = yas * 2     // 50

Koşullu Kontrol Yapıları​

Lordex, eger (if), degilse_eger (else if) ve degilse (else) anahtar kelimeleri ile koşullu dallanma sağlar. Koşullar boolean ifade olarak değerlendirilir.

Çok Kademeli Koşul Değerlendirme​

yaz("Notunuzu girin:")
not = int(oku())

eger (not >= 90) {
    yaz("Harf Notu: AA")
} degilse_eger (not >= 80) {
    yaz("Harf Notu: BA")
} degilse_eger (not >= 70) {
    yaz("Harf Notu: BB")
} degilse_eger (not >= 60) {
    yaz("Harf Notu: CB")
} degilse_eger (not >= 50) {
    yaz("Harf Notu: CC")
} degilse {
    yaz("Harf Notu: FF")
}

Değerlendirme Sırası: Koşullar yukarıdan aşağıya doğru kontrol edilir. İlk doğru koşulun bloğu çalıştırılır ve diğer koşullar atlanır (short-circuit evaluation).

Sözdizimi Gereksinimleri:

  • Koşul ifadesi parantez içinde olmalıdır: (koşul)
  • Blok süslü parantezlerle sarılmalıdır: { ... }
  • degilse bloğu opsiyoneldir

Döngü Yapıları​

Lordex iki tip döngü yapısı sunar: iken (while) ve icin (for). Her ikisi de iteratif işlemler için kullanılır ancak farklı kullanım senaryolarına sahiptir.

While Döngüsü (iken)​

yaz("1'den 10'a kadar sayma:")

sayac = 1
iken (sayac <= 10) {
    yaz(sayac)
    sayac = sayac + 1
}

yaz("Sayma tamamlandı!")

iken döngüsü, koşul ifadesi evet (true) değerini döndürdüğü sürece blok içindeki kodları tekrar eder. Koşul her iterasyonun başında değerlendirilir.

Kritik Uyarı: Döngü değişkeni (counter) güncellenmezse sonsuz döngü oluşur. Yukardaki örnekte sayac = sayac + 1 ifadesi, her iterasyonda sayaç değişkenini artırarak koşulun sonuçta yanlış olmasını sağlar.

Program Çıktısı:

1'den 10'a kadar sayma:
1
2
3
4
5
6
7
8
9
10
Sayma tamamlandı!

For Döngüsü (icin)​

icin döngüsü, dizi veya koleksiyon elemanları üzerinde iterasyon yapmak için tasarlanmıştır. Her iterasyonda, mevcut eleman bir değişkene atanarak blok çalıştırılır.

meyveler = ["Elma", "Armut", "Muz", "Çilek", "Portakal"]

yaz("Meyve Listesi:")
yaz("=============")

icin (meyve in meyveler) {
    yaz("- " + meyve)
}

yaz("")
yaz("Toplam meyve sayısı: " + uzunluk(meyveler))

Sözdizimi: icin (eleman in dizi) { ... }

Çalışma Mekaniği:

  1. Dizi baştan sona doğru dolanılır
  2. Her iterasyonda, mevcut eleman meyve değişkenine atanr
  3. Blok içindeki kod çalıştırılır
  4. Dizi sonuna gelinene kadar tekrar edilir

uzunluk() built-in fonksiyonu, dizinin eleman sayısını integer olarak döndürür.

Çıktı:

Meyve Listesi:
=============
- Elma
- Armut
- Muz
- Çilek
- Portakal

Toplam meyve sayısı: 5

Fonksiyon Tanımlama ve Çağırma​

Fonksiyonlar, kodun modularizasyonunu ve tekrar kullanılabilirliğini sağlar. Lordex'te fonksiyonlar fonksiyon anahtar kelimesi ile tanımlanır ve first-class citizen olarak işlenir.

// Fonksiyon tanımlama
fonksiyon kare(sayi) {
    geri_don sayi * sayi
}

fonksiyon kup(sayi) {
    geri_don sayi * sayi * sayi
}

// Fonksiyonları kullan
x = 5
yaz("Sayı: " + x)
yaz("Karesi: " + kare(x))
yaz("Küpü: " + kup(x))

Çıktı:

Sayı: 5
Karesi: 25
Küpü: 125

Bütünleşik Uygulama Örneği​

Aşağıdaki program, dilin temel bileşenlerini bir arada kullanarak çalışan bir hesap makinesi uygulaması oluşturur:

// Kullanıcı arayüzü başlığı
yaz("================================")
yaz("   LORDEX HESAP MAKİNESİ")
yaz("================================")
yaz("")

// İşlem fonksiyonlarının tanımlanması
fonksiyon topla(a, b) {
    geri_don a + b
}

fonksiyon cikar(a, b) {
    geri_don a - b
}

fonksiyon carp(a, b) {
    geri_don a * b
}

fonksiyon bol(a, b) {
    eger (b == 0) {
        yaz("HATA: Sıfıra bölme yapılamaz!")
        geri_don 0
    }
    geri_don a / b
}

// Kullanıcı girdisi alımı
yaz("Birinci sayıyı girin:")
sayi1 = float(oku())

yaz("İkinci sayıyı girin:")
sayi2 = float(oku())

// Sonuçların hesaplanması ve gösterilmesi
yaz("")
yaz("--- SONUÇLAR ---")
yaz("Toplam: " + topla(sayi1, sayi2))
yaz("Fark: " + cikar(sayi1, sayi2))
yaz("Çarpım: " + carp(sayi1, sayi2))
yaz("Bölüm: " + bol(sayi1, sayi2))

Bu program, şu teknik konuları bir arada gösterir:

  • Fonksiyon modularizasyonu
  • Kullanıcı girdisi işleme ve tip dönüşümü
  • Koşullu hata kontrolü (sıfıra bölme)
  • String birleştirme ve çıktı formatlama

Yaygın Hatalar ve Çözüm Yöntemleri​

Tanımsız Değişken Kullanımı​

Hatalı Kod:

yaz(isim)  // Runtime hatası: 'isim' tanımlanmamış

Çözüm:

isim = "Ahmet"
yaz(isim)  // Doğru: önce tanımla, sonra kullan

Açıklama: Lordex'te değişkenler kullanılmadan önce tanımlanmalıdır. Tanımsız değişkene erişim, runtime hatası üretir ve program sonlanır.

Tip Uyuşmazlığı Hataları​

Hatalı Kod:

yas_str = "25"           // String tip
yas_iki_kat = yas_str * 2  // Hata: String sayı ile çarpılamaz

Çözüm:

yas_str = "25"
yas = int(yas_str)      // Explicit tip dönüşümü
yas_iki_kat = yas * 2   // Doğru: 50

Açıklama: Dinamik tip sistemi, runtime'da tip uyumsuzluklarını kontrol eder. String ve numerik tipler arasındaki işlemler için explicit dönüşüm gereklidir.

Sıfıra Bölme​

Hatalı Kod:

x = 10
y = 0
sonuc = x / y  // Runtime hatası: Division by zero

Çözüm:

x = 10
y = 0
eger (y != 0) {
    sonuc = x / y
    yaz("Sonuç: " + sonuc)
} degilse {
    yaz("Hata: Sıfıra bölme yapılamaz")
}

Açıklama: Sıfıra bölme işlemi, matematik tanımsızdır ve runtime hatası üretir. Bölme işlemlerinden önce payda kontrolü yapılmalıdır.

Referans ve Devamı​

Bu doküman, Lordex dilinin temel yapı taşlarını tanıtır. Daha ileri konular için: