15. Olay Tabanlı Programlama (Event-Driven Programming)

Olay tabanlı programlama (event-driven programming), programın akışının olaylar (events) tarafından belirlendiği bir programlama paradigmasıdır. Bu olaylar, kullanıcı etkileşimleri (örneğin, fare tıklamaları, klavye girişleri), sensörlerden gelen veriler, diğer programlar tarafından gönderilen mesajlar veya sistem olayları (örneğin, zamanlayıcı olayları) olabilir. Geleneksel prosedürel programlamadan farklı olarak, olay tabanlı programlamada program, belirli bir olay meydana gelene kadar pasif bir şekilde bekler ve ardından o olaya karşılık gelen bir işlem gerçekleştirir.

Olay Tabanlı Programlamanın Temel Kavramları

Olay tabanlı programlamayı anlamak için aşağıdaki temel kavramları bilmek önemlidir:

• Olay (Event): Bir durum değişikliği veya meydana gelen bir aksiyon. Örnekler: Bir düğmeye tıklamak, bir tuşa basmak, bir mesaj almak.
• Olay Kaynağı (Event Source): Olayı başlatan nesne veya bileşen. Örnekler: Düğme (button), klavye, ağ bağlantısı.
• Olay Dinleyici (Event Listener): Belirli bir olayı dinleyen ve olay meydana geldiğinde tetiklenen kodu içeren nesne veya fonksiyon. Olay işleyici (event handler) olarak da adlandırılır.
• Olay Döngüsü (Event Loop): Olayları dinleyen ve uygun olay dinleyicilerini tetikleyen bir döngü. Programın ana akışını yönetir.

Delphi’de Olay Tabanlı Programlama

Delphi, olay tabanlı programlamayı destekleyen güçlü bir araçtır. Görsel tasarım arayüzü (Visual Component Library – VCL) sayesinde, kullanıcı arayüzü bileşenleri (düğmeler, metin kutuları, listeler vb.) ile kolayca etkileşim kurabilirsiniz. Her bileşenin, olaylarını işlemek için kullanabileceğiniz önceden tanımlanmış olayları (Onclick, OnKeyPress, OnChange gibi) vardır.

Olay İşleyiciler (Event Handlers)

Delphi’de bir olay işleyici oluşturmak için, olayına karşılık gelen bileşenin olay özelliklerini (Object Inspector’da bulunur) kullanırsınız. Bir olay seçildiğinde, Delphi otomatik olarak ilgili olay işleyici fonksiyonunu oluşturur ve bu fonksiyonun içine olay gerçekleştiğinde çalışacak kodu yazabilirsiniz.

Örneğin, bir düğmenin (Button1) tıklanma olayını (OnClick) işlemek için aşağıdaki adımları izleyebilirsiniz:

1. Delphi IDE’sinde bir form oluşturun ve forma bir adet Button bileşeni ekleyin.
2. Object Inspector penceresinde Button1’i seçin.
3. Events sekmesine gidin ve OnClick olayının karşısındaki boş alana çift tıklayın.
4. Delphi, otomatik olarak bir TForm1.Button1Click olay işleyici fonksiyonu oluşturacaktır.
5. Bu fonksiyonun içine, düğme tıklanıldığında çalışmasını istediğiniz kodu yazın.

procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage('Düğmeye Tıklandı!');
end;

Örnek: Basit Bir Hesap Makinesi Uygulaması

Olay tabanlı programlamayı daha iyi anlamak için, basit bir hesap makinesi uygulaması örneğini inceleyelim. Bu uygulama, iki sayıyı toplama işlemini gerçekleştiren bir düğmeye sahip olacaktır.

1. Delphi IDE’sinde yeni bir proje oluşturun.
2. Forma iki adet TEdit (metin kutusu) bileşeni (Edit1, Edit2) ve bir adet TButton bileşeni (Button1) ekleyin.
3. Button1’in Caption özelliğini ‘+’ olarak ayarlayın.
4. Forma bir adet TLabel bileşeni (Label1) ekleyin. Bu, sonucun görüntüleneceği yer olacaktır.
5. Button1’in OnClick olayına aşağıdaki kodu ekleyin:

procedure TForm1.Button1Click(Sender: TObject);
var
  sayi1, sayi2, sonuc: Integer;
begin
  try
    sayi1 := StrToInt(Edit1.Text);
    sayi2 := StrToInt(Edit2.Text);
    sonuc := sayi1 + sayi2;
    Label1.Caption := IntToStr(sonuc);
  except
    on EConvertError do
      ShowMessage('Lütfen geçerli sayısal değerler girin.');
  end;
end;

Bu kod, Edit1 ve Edit2’den girilen metinleri tamsayılara dönüştürmeye çalışır, ardından bu sayıları toplar ve sonucu Label1’in başlığına yazar. Hata durumunda (geçersiz sayısal değerler girilirse), bir hata mesajı görüntüler.

Olay Tabanlı Programlamanın Avantajları

• Esneklik: Olay tabanlı programlar, farklı olaylara farklı şekillerde yanıt verebilir, bu da onları çok çeşitli uygulamalar için uygun hale getirir.
• Kullanıcı Arayüzü (UI) Odaklı: Özellikle kullanıcı arayüzleri geliştirmek için idealdir. Kullanıcı etkileşimleri (tıklamalar, klavye girişleri vb.) kolayca işlenebilir.
• Modülerlik: Olay dinleyicileri, bağımsız modüller olarak geliştirilebilir, bu da kodun yeniden kullanılabilirliğini ve bakımını kolaylaştırır.
• Eş Zamanlılık: Olay tabanlı programlar, birden fazla olayı aynı anda işleyebilir, bu da uygulamanın yanıt verme hızını artırır.

Olay Tabanlı Programlamanın Dezavantajları

• Karmaşıklık: Program akışının olaylar tarafından belirlenmesi, özellikle büyük ve karmaşık uygulamalarda programın anlaşılmasını ve hata ayıklamasını zorlaştırabilir.
• Debug Zorluğu: Olayların sıralaması ve zamanlaması, hataların nedenini belirlemeyi zorlaştırabilir.
• Performans: Çok sayıda olayın işlenmesi, performans sorunlarına yol açabilir.

Sonuç

Olay tabanlı programlama, modern yazılım geliştirmede yaygın olarak kullanılan güçlü bir paradigmadır. Özellikle kullanıcı arayüzleri, oyunlar ve gerçek zamanlı sistemler gibi etkileşimli uygulamalar için uygundur. Delphi, olay tabanlı programlamayı kolaylaştıran araçlar ve kütüphaneler sunar. Bu paradigmayı anlamak, daha esnek, modüler ve kullanıcı dostu uygulamalar geliştirmenize yardımcı olacaktır. Olay tabanlı programlama, programın akışını kontrol etmenin farklı bir yolunu sunarak, yazılım geliştirme sürecinde önemli bir rol oynar.

Bu makalede, olay tabanlı programlamanın temel kavramlarını, Delphi’deki uygulamasını, avantaj ve dezavantajlarını inceledik. Umarım bu bilgiler, olay tabanlı programlamayı anlamanıza ve uygulamalarınıza dahil etmenize yardımcı olur.

Unutmayın, pratik yapmak öğrenmenin en iyi yoludur! Küçük projelerle başlayarak, olay tabanlı programlama becerilerinizi geliştirebilirsiniz.

15. Olay Tabanlı Programlama (Event-Driven Programming) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

14. Formlar ve Bileşenler ile Çalışma (Button, Label, Edit, vb.)

Delphi programlama dilinde, kullanıcı arayüzleri (UI) formlar ve bu formlar üzerine yerleştirilen bileşenler aracılığıyla oluşturulur. Formlar, uygulamanın ana penceresini veya diyalog kutularını temsil ederken, bileşenler (button, label, edit, vb.) kullanıcıların etkileşimde bulunabileceği görsel elemanlardır. Bu makalede, Delphi’de formlarla ve temel bileşenlerle nasıl çalışılacağını ayrıntılı bir şekilde inceleyeceğiz.

Formlar (Forms)

Formlar, Delphi uygulamalarının temel yapı taşlarıdır. Her Delphi uygulaması en az bir forma sahip olmalıdır. Formlar, görsel bir tasarım yüzeyi sağlar ve üzerine yerleştirilen bileşenlerin düzenlenmesini ve yönetilmesini kolaylaştırır.

Form Oluşturma

Delphi’de yeni bir form oluşturmak için şu adımları izleyebilirsiniz:

1. Delphi IDE’sini açın.
2. File > New > VCL Form Application seçeneğini tıklayın.
3. Yeni bir form otomatik olarak oluşturulacaktır.

Oluşturulan form, Object Inspector penceresi aracılığıyla özelliklerini değiştirebileceğiniz bir nesnedir. Örneğin, formun başlığını (Caption), boyutunu (Width, Height) ve konumunu (Left, Top) ayarlayabilirsiniz.

Form Özellikleri

Formların birçok önemli özelliği vardır. İşte en sık kullanılanlardan bazıları:

• Caption: Formun başlık çubuğunda görünen metin.
• Name: Formun kod içinde kullanılan adı.
• Width: Formun genişliği (piksel cinsinden).
• Height: Formun yüksekliği (piksel cinsinden).
• Left: Formun ekranın sol kenarından uzaklığı (piksel cinsinden).
• Top: Formun ekranın üst kenarından uzaklığı (piksel cinsinden).
• Color: Formun arka plan rengi.
• Font: Form üzerindeki metinlerin yazı tipi özellikleri.
• BorderStyle: Formun kenarlık stili (bsSingle, bsSizeable, bsNone, vb.).
• Position: Formun ekranda nasıl konumlandırılacağı (poDesigned, poDesktopCenter, poMainFormCenter, vb.).

Bileşenler (Components)

Bileşenler, formlar üzerine yerleştirilen ve kullanıcıların etkileşimde bulunabileceği görsel nesnelerdir. Delphi, çok çeşitli bileşenler sunar. En sık kullanılanlardan bazıları şunlardır:

• TButton: Düğme.
• TLabel: Etiket (statik metin).
• TEdit: Metin giriş kutusu.
• TMemo: Çok satırlı metin giriş kutusu.
• TCheckBox: Onay kutusu.
• TRadioButton: Seçim düğmesi.
• TListBox: Liste kutusu.
• TComboBox: Açılır liste kutusu.
• TImage: Resim görüntüleme bileşeni.

Bileşen Ekleme ve Yerleştirme

Bileşenleri forma eklemek için şu adımları izleyebilirsiniz:

1. Delphi IDE’sindeki Tool Palette (Araç Paleti) penceresini açın.
2. Eklemek istediğiniz bileşeni (örneğin, TButton) seçin.
3. Form üzerinde bileşeni yerleştirmek istediğiniz yere tıklayın.

Bileşenler eklendikten sonra, Object Inspector penceresi aracılığıyla özelliklerini değiştirebilirsiniz. Örneğin, bir düğmenin başlığını (Caption), boyutunu (Width, Height) ve konumunu (Left, Top) ayarlayabilirsiniz.

Temel Bileşenler ve Kullanımları

Şimdi, en sık kullanılan bazı bileşenleri ve nasıl kullanıldıklarını inceleyelim.

TButton (Düğme)

Düğmeler, kullanıcıların bir eylemi tetiklemek için tıkladığı bileşenlerdir. Bir düğmenin OnClick olayına kod ekleyerek, düğmeye tıklandığında yapılacak işlemleri tanımlayabilirsiniz.

Örnek:

procedure TForm1.Button1Click(Sender: TObject);
begin
 ShowMessage('Düğmeye Tıklandı!');
end;

TLabel (Etiket)

Etiketler, form üzerinde statik metin görüntülemek için kullanılır. Genellikle, diğer bileşenlerin açıklamalarını veya başlıklarını göstermek için kullanılırlar.

Örnek:

Label1.Caption := 'Adınız:';

TEdit (Metin Giriş Kutusu)

Metin giriş kutuları, kullanıcıların metin girmesi için kullanılır. Kullanıcı tarafından girilen metin, Text özelliği aracılığıyla okunabilir ve değiştirilebilir.

Örnek:

var
 KullaniciAdi: string;
begin
 KullaniciAdi := Edit1.Text;
 ShowMessage('Merhaba, ' + KullaniciAdi + '!');
end;

TMemo (Çok Satırlı Metin Giriş Kutusu)

Çok satırlı metin giriş kutuları, kullanıcıların birden fazla satırda metin girmesi için kullanılır. Lines özelliği, metin satırlarını bir dizi olarak tutar.

Örnek:

Memo1.Lines.Add('İlk Satır');
Memo1.Lines.Add('İkinci Satır');

Olay Yönetimi (Event Handling)

Delphi’de olaylar, bileşenlerin belirli durumlara yanıt vermesini sağlar. Örneğin, bir düğmenin tıklanması, bir metin kutusuna metin girilmesi veya bir formun yüklenmesi birer olaydır. Olaylara yanıt vermek için, ilgili bileşenin olay işleyicisine (event handler) kod yazmanız gerekir.

Örneğin, bir düğmenin OnClick olayına yanıt vermek için, düğmenin OnClick olay işleyicisine aşağıdaki gibi kod ekleyebilirsiniz:

procedure TForm1.Button1Click(Sender: TObject);
begin
 ShowMessage('Düğmeye Tıklandı!');
end;

Örnek Uygulama

Şimdi, basit bir örnek uygulama oluşturalım. Bu uygulama, kullanıcının adını ve soyadını girmesini isteyecek ve ardından bir mesaj kutusunda kullanıcıya merhaba diyecektir.

1. Yeni bir Delphi projesi oluşturun (File > New > VCL Form Application).
2. Form üzerine iki adet TLabel, iki adet TEdit ve bir adet TButton bileşeni ekleyin.
3. Etiketlerin başlıklarını (Caption) sırasıyla “Adınız:” ve “Soyadınız:” olarak ayarlayın.
4. Düğmenin başlığını (Caption) “Merhaba De!” olarak ayarlayın.
5. Düğmenin OnClick olay işleyicisine aşağıdaki kodu ekleyin:

procedure TForm1.Button1Click(Sender: TObject);
var
 Ad: string;
 Soyad: string;
begin
 Ad := Edit1.Text;
 Soyad := Edit2.Text;
 ShowMessage('Merhaba, ' + Ad + ' ' + Soyad + '!');
end;

Bu adımları tamamladıktan sonra, uygulamayı çalıştırabilirsiniz. Uygulama, kullanıcının adını ve soyadını girmesini isteyecek ve ardından bir mesaj kutusunda kullanıcıya merhaba diyecektir.

Sonuç

Bu makalede, Delphi programlama dilinde formlar ve temel bileşenlerle nasıl çalışılacağını ayrıntılı bir şekilde inceledik. Formların nasıl oluşturulacağını, bileşenlerin nasıl ekleneceğini ve yerleştirileceğini, temel bileşenlerin nasıl kullanılacağını ve olayların nasıl yönetileceğini öğrendik. Bu bilgiler, Delphi ile kullanıcı arayüzleri oluşturmaya başlamak için sağlam bir temel sağlayacaktır. Delphi’nin zengin bileşen kütüphanesi ve olay güdümlü programlama modeli, güçlü ve etkileşimli uygulamalar geliştirmenize olanak tanır.

14. Formlar ve Bileşenler ile Çalışma (Button, Label, Edit, vb.) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

13. Dosya İşlemleri (File I/O) – Temel Seviye

Delphi programlama dilinde dosya işlemleri (File I/O), programınızın dış dünya ile iletişim kurmasını sağlayan temel bir yetenektir. Bu, verilerin kalıcı olarak saklanması, yapılandırılmış verilerin okunması, log dosyalarının oluşturulması veya farklı uygulamalar arasında veri alışverişi gibi birçok senaryoda kullanılır. Bu makalede, Delphi’de dosya işlemlerinin temel seviyesine odaklanacağız ve dosya okuma, yazma ve yönetme konularını ele alacağız.

Dosya İşlemlerine Giriş

Dosya işlemleri, programınızın disk üzerindeki dosyalarla etkileşim kurmasını içerir. Bu etkileşim, dosyaları açma, okuma, yazma, kapatma ve silme gibi işlemleri kapsar. Delphi, dosya işlemlerini gerçekleştirmek için çeşitli fonksiyonlar ve nesneler sunar.

Dosya Türleri

Delphi’de, temelde iki tür dosya bulunur:

• Metin Dosyaları (Text Files): ASCII veya Unicode karakterler içeren dosyalardır. İnsan tarafından okunabilir formatta veri saklarlar.
• İkili Dosyalar (Binary Files): Herhangi bir türde veri (sayılar, yapılar, nesneler vb.) içerebilen dosyalardır. Genellikle insan tarafından doğrudan okunamazlar.

Metin Dosyası İşlemleri

Metin dosyaları, genellikle yapılandırılmış verileri saklamak ve işlemek için kullanılır. Delphi’de metin dosyalarıyla çalışmak için `TextFile` türünü ve ilgili fonksiyonları kullanırız.

Dosya Açma ve Kapama

Bir metin dosyasını açmak için `AssignFile`, `Reset` (okuma için) veya `Rewrite` (yazma için) fonksiyonları kullanılır. Dosya işlemleri tamamlandıktan sonra `CloseFile` fonksiyonu ile dosya kapatılmalıdır.

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'data.txt');
  Rewrite(MyFile); // Yeni bir dosya oluştur veya varsa üzerine yaz
  // Dosyaya yazma işlemleri
  CloseFile(MyFile);
end;

Okuma için ise:

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'data.txt');
  Reset(MyFile); // Dosyayı okuma modunda aç
  // Dosyadan okuma işlemleri
  CloseFile(MyFile);
end;

Dosyaya Yazma

Metin dosyasına veri yazmak için `Write` veya `WriteLn` fonksiyonları kullanılır. `Write`, veriyi olduğu gibi dosyaya yazarken, `WriteLn` veriyi yazdıktan sonra bir satır sonu karakteri ekler.

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'output.txt');
  Rewrite(MyFile);
  WriteLn(MyFile, 'Merhaba, Dünya!');
  WriteLn(MyFile, 'Bu bir Delphi örneğidir.');
  CloseFile(MyFile);
end;

Dosyadan Okuma

Metin dosyasından veri okumak için `Read` veya `ReadLn` fonksiyonları kullanılır. `Read`, belirli sayıda karakteri okurken, `ReadLn` bir satır sonuna kadar okur.

var
  MyFile: TextFile;
  Line: string;
begin
  AssignFile(MyFile, 'output.txt');
  Reset(MyFile);
  while not Eof(MyFile) do
  begin
    ReadLn(MyFile, Line);
    ShowMessage(Line); // Okunan satırı göster
  end;
  CloseFile(MyFile);
end;

`Eof(MyFile)` fonksiyonu, dosyanın sonuna gelinip gelinmediğini kontrol eder. Bu, döngü içinde dosya okurken önemlidir.

İkili Dosya İşlemleri

İkili dosyalar, yapılandırılmış verileri daha verimli bir şekilde saklamak için kullanılır. Delphi’de ikili dosyalarla çalışmak için `File` türünü ve ilgili fonksiyonları kullanırız.

Dosya Açma ve Kapama (İkili)

İkili dosyaları açmak için `AssignFile`, `Reset` (okuma için) veya `Rewrite` (yazma için) fonksiyonları kullanılır. Ancak, ikili dosyalar için `File` türü kullanılır.

var
  MyFile: File;
begin
  AssignFile(MyFile, 'data.bin');
  Rewrite(MyFile, 1); // Boyut parametresi (genellikle 1 kullanılır)
  // Dosyaya yazma işlemleri
  CloseFile(MyFile);
end;

Okuma için:

var
  MyFile: File;
begin
  AssignFile(MyFile, 'data.bin');
  Reset(MyFile, 1); // Boyut parametresi (genellikle 1 kullanılır)
  // Dosyadan okuma işlemleri
  CloseFile(MyFile);
end;

Dosyaya Yazma (İkili)

İkili dosyaya veri yazmak için `BlockWrite` fonksiyonu kullanılır. Bu fonksiyon, bir bellek bloğunu doğrudan dosyaya yazar.

var
  MyFile: File;
  Data: array[0..9] of Integer;
  i: Integer;
begin
  AssignFile(MyFile, 'data.bin');
  Rewrite(MyFile, SizeOf(Integer));

  // Veri doldur
  for i := 0 to 9 do
    Data[i] := i * 10;

  BlockWrite(MyFile, Data, SizeOf(Data));
  CloseFile(MyFile);
end;

Dosyadan Okuma (İkili)

İkili dosyadan veri okumak için `BlockRead` fonksiyonu kullanılır. Bu fonksiyon, dosyadan bir bellek bloğunu okur.

var
  MyFile: File;
  Data: array[0..9] of Integer;
  i: Integer;
  BytesRead: Integer;
begin
  AssignFile(MyFile, 'data.bin');
  Reset(MyFile, SizeOf(Integer));

  BlockRead(MyFile, Data, SizeOf(Data), BytesRead);

  // Okunan veriyi işle
  for i := 0 to 9 do
    ShowMessage(IntToStr(Data[i]));

  CloseFile(MyFile);
end;

`BlockRead` fonksiyonu, okunan byte sayısını `BytesRead` parametresinde döndürür. Bu, dosyanın sonuna ulaşıldığında veya bir hata oluştuğunda önemlidir.

Ek Fonksiyonlar ve Dikkat Edilmesi Gerekenler

• FileExists(FileName: string): Boolean: Dosyanın var olup olmadığını kontrol eder.
• DeleteFile(FileName: string): Boolean: Dosyayı siler.
• RenameFile(OldName, NewName: string): Boolean: Dosyanın adını değiştirir.
• Dosya işlemlerinde hata kontrolü önemlidir. `IOResult` değişkenini kullanarak hataları kontrol edebilirsiniz.
• Dosyaları açarken ve kapatırken dikkatli olun. Açık unutulan dosyalar, kaynak tüketimine ve veri kaybına neden olabilir.

Sonuç

Delphi’de dosya işlemleri, uygulamalarınızın dış dünya ile etkileşim kurmasını sağlayan güçlü bir araçtır. Bu makalede, temel metin ve ikili dosya işlemlerini ele aldık. Bu bilgilerle, kendi uygulamalarınızda dosya okuma, yazma ve yönetme işlemlerini gerçekleştirebilirsiniz. Unutmayın, dosya işlemlerinde dikkatli olmak ve hata kontrolünü ihmal etmemek önemlidir.

Dosya işlemleri konusunu daha derinlemesine incelemek için Delphi’nin online yardımına ve çeşitli kaynaklara başvurabilirsiniz. Başarılar!

Önemli Not: Bu makale temel seviyede dosya işlemlerini kapsamaktadır. Daha karmaşık senaryolar için, örneğin veritabanı işlemleri veya ağ üzerinden dosya transferi, daha gelişmiş teknikler ve kütüphaneler kullanmanız gerekebilir.

Umarım bu makale Delphi programlama dilinde dosya işlemleri konusunda size yardımcı olmuştur. İyi kodlamalar!

13.Dosya İşlemleri (File I/O) – Temel Seviye yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

12. Hata Yakalama (Try-Except-Finally Blokları)

Delphi programlama dilinde, hata yakalama, uygulamanızın beklenmedik durumlarla başa çıkmasını sağlayan kritik bir mekanizmadır. Try-Except-Finally blokları, potansiyel hataların oluşabileceği kod bölümlerini güvenli bir şekilde yönetmek ve uygulamanın çökmesini önlemek için kullanılır. Bu makalede, Delphi’de hata yakalama yöntemlerini, Try-Except-Finally bloklarının nasıl kullanıldığını ve iyi bir hata yönetimi stratejisinin nasıl oluşturulacağını ayrıntılı olarak inceleyeceğiz.

Hata Yönetiminin Önemi

Bir uygulamanın sağlamlığı ve kullanıcı deneyimi, hata yönetimi ile doğrudan ilişkilidir. İyi bir hata yönetimi, uygulamanın beklenmedik durumlarda düzgün bir şekilde çalışmaya devam etmesini, kullanıcıya anlamlı mesajlar göstermesini ve veri kaybını önlemesini sağlar. Özellikle kritik sistemlerde (örneğin, finansal uygulamalar, tıbbi cihazlar) hata yönetimi hayati öneme sahiptir.

Hata yönetimi aşağıdaki avantajları sunar:

• Uygulama Kararlılığı: Beklenmedik hataların uygulamanın çökmesine neden olmasını engeller.
• Kullanıcı Deneyimi: Hatalar hakkında kullanıcıya anlaşılır ve yardımcı bilgiler sunar.
• Veri Bütünlüğü: Hata durumlarında veri kaybını veya bozulmasını önler.
• Hata Ayıklama Kolaylığı: Hataların nedenlerini belirlemeye ve düzeltmeye yardımcı olur.

Try-Except Blokları

Try-Except blokları, hata yakalamanın temel yapı taşıdır. Try bloğu, potansiyel hataların oluşabileceği kodu içerir. Eğer Try bloğu içerisinde bir hata oluşursa, program akışı ilgili Except bloğuna yönlendirilir.

Temel Sözdizimi

Try-Except bloğunun temel sözdizimi aşağıdaki gibidir:

try
  // Hata oluşabilecek kod
except
  on E: Exception do
  begin
    // Hata işleme kodu
  end;
end;

Burada:

• try: Hata oluşabilecek kodun başladığı bloğu belirtir.
• except: Hata oluştuğunda çalışacak kodun başladığı bloğu belirtir.
• on E: Exception do: Belirli bir hata türünü (Exception veya türetilmiş bir sınıf) yakalamak için kullanılır. E, yakalanan hata nesnesini temsil eder.
• begin ... end: Hata işleme kodunu içerir.

Örnek Kullanım

Aşağıdaki örnek, bir dosya açma işlemi sırasında oluşabilecek hataları yakalamayı göstermektedir:

var
  MyFile: TextFile;
begin
  try
    AssignFile(MyFile, 'C:\NonExistentFile.txt');
    Reset(MyFile);
    // Dosya işlemleri
  except
    on E: Exception do
    begin
      ShowMessage('Dosya açılırken bir hata oluştu: ' + E.Message);
    end;
  end;
  CloseFile(MyFile);
end;

Bu kod, C:\NonExistentFile.txt dosyasını açmaya çalışır. Eğer dosya bulunamazsa veya başka bir hata oluşursa, Except bloğu devreye girer ve kullanıcıya bir hata mesajı gösterilir.

Try-Finally Blokları

Try-Finally blokları, bir kod bloğunun her durumda (hata oluşsa da oluşmasa da) belirli işlemlerin yapılmasını sağlamak için kullanılır. Bu bloklar, özellikle kaynakların (örneğin, dosyalar, bellek, veritabanı bağlantıları) serbest bırakılması gerektiğinde önemlidir.

Temel Sözdizimi

Try-Finally bloğunun temel sözdizimi aşağıdaki gibidir:

try
  // Korunan kod
finally
  // Her durumda çalışacak kod
end;

Burada:

• try: Korunması gereken kodun başladığı bloğu belirtir.
• finally: Try bloğundan sonra her durumda (hata oluşsa da oluşmasa da) çalışacak kodun başladığı bloğu belirtir.

Örnek Kullanım

Aşağıdaki örnek, bir dosyanın her durumda kapatılmasını sağlamayı göstermektedir:

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'C:\MyFile.txt');
  try
    Reset(MyFile);
    // Dosya işlemleri
  finally
    CloseFile(MyFile);
  end;
end;

Bu kod, C:\MyFile.txt dosyasını açar ve bazı işlemler yapar. Finally bloğu, dosya açma işlemi başarılı olsa da olmasa da CloseFile komutunu çalıştırarak dosyanın kapatılmasını garanti eder.

Try-Except-Finally Bloklarının Birleşimi

Try-Except ve Try-Finally blokları, daha karmaşık hata yönetimi senaryolarında birleştirilebilir. Bu, hem hataları yakalamayı hem de kaynakları serbest bırakmayı sağlar.

Temel Sözdizimi

Try-Except-Finally bloğunun temel sözdizimi aşağıdaki gibidir:

try
  // Hata oluşabilecek kod
except
  on E: Exception do
  begin
    // Hata işleme kodu
  end;
finally
  // Her durumda çalışacak kod
end;

Örnek Kullanım

Aşağıdaki örnek, hem dosya açma hatalarını yakalamayı hem de dosyanın her durumda kapatılmasını sağlamayı göstermektedir:

var
  MyFile: TextFile;
begin
  AssignFile(MyFile, 'C:\MyFile.txt');
  try
    Reset(MyFile);
    // Dosya işlemleri
  except
    on E: Exception do
    begin
      ShowMessage('Dosya açılırken veya işlenirken bir hata oluştu: ' + E.Message);
    end;
finally
    CloseFile(MyFile);
  end;
end;

Bu kod, C:\MyFile.txt dosyasını açar ve bazı işlemler yapar. Eğer dosya açılırken veya işlenirken bir hata oluşursa, Except bloğu devreye girer ve kullanıcıya bir hata mesajı gösterilir. Finally bloğu, dosya açma işlemi başarılı olsa da olmasa da CloseFile komutunu çalıştırarak dosyanın kapatılmasını garanti eder.

Özel Hata Sınıfları Oluşturma

Delphi, kendi özel hata sınıflarınızı oluşturmanıza olanak tanır. Bu, uygulamanızın belirli ihtiyaçlarına uygun hata yönetimi sağlamanıza yardımcı olur. Özel hata sınıfları, Exception sınıfından türetilir ve belirli hata durumlarını temsil eder.

Örnek Hata Sınıfı

Aşağıdaki örnek, EInvalidData adında bir özel hata sınıfı tanımlamayı göstermektedir:

type
  EInvalidData = class(Exception)
  private
    FData: string;
  public
    constructor Create(const Message, Data: string);
    property Data: string read FData;
  end;

constructor EInvalidData.Create(const Message, Data: string);
begin
  inherited Create(Message);
  FData := Data;
end;

Kullanım Örneği

Bu özel hata sınıfını kullanarak, geçersiz veri tespit edildiğinde bir hata fırlatabilirsiniz:

procedure ProcessData(Data: string);
begin
  if not IsValidData(Data) then
    raise EInvalidData.Create('Geçersiz veri tespit edildi!', Data);
  // Veri işleme
end;

Bu kod, IsValidData fonksiyonu tarafından geçersiz olarak tespit edilen veriler için bir EInvalidData hatası fırlatır. Bu hatayı yakalayarak, uygulamanızın belirli bir hata durumuna nasıl tepki vereceğini kontrol edebilirsiniz.

İyi Bir Hata Yönetimi Stratejisi Oluşturma

İyi bir hata yönetimi stratejisi, uygulamanızın sağlamlığını ve güvenilirliğini artırır. Aşağıdaki adımlar, etkili bir hata yönetimi stratejisi oluşturmanıza yardımcı olabilir:

1. Potansiyel Hata Kaynaklarını Belirleyin: Uygulamanızda hataların oluşabileceği tüm noktaları (örneğin, dosya işlemleri, veritabanı erişimi, kullanıcı girişi) belirleyin.
2. Hata Yakalama Blokları Kullanın: Potansiyel hata kaynaklarının etrafına Try-Except-Finally blokları yerleştirin.
3. Özel Hata Sınıfları Oluşturun: Uygulamanızın belirli ihtiyaçlarına uygun özel hata sınıfları oluşturun.
4. Hata Mesajlarını Anlamlı Hale Getirin: Kullanıcılara anlaşılır ve yardımcı hata mesajları gösterin.
5. Hata Günlüğü Tutun: Hataları bir günlük dosyasına kaydedin, böylece daha sonra analiz edebilir ve düzeltebilirsiniz.
6. Test Edin: Hata yönetimi stratejinizi kapsamlı bir şekilde test edin. Farklı hata senaryolarını simüle edin ve uygulamanızın doğru şekilde tepki verdiğinden emin olun.

Sonuç

Delphi’de hata yakalama, uygulamanızın güvenilirliğini ve kararlılığını sağlamak için kritik bir öneme sahiptir. Try-Except-Finally blokları, potansiyel hataların oluşabileceği kod bölümlerini güvenli bir şekilde yönetmek ve uygulamanın çökmesini önlemek için güçlü bir araçtır. İyi bir hata yönetimi stratejisi oluşturarak, uygulamanızın beklenmedik durumlarla başa çıkmasını ve kullanıcıya sorunsuz bir deneyim sunmasını sağlayabilirsiniz.

12. Hata Yakalama (Try-Except-Finally Blokları) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

11.Kayıt Tipleri (Records) ve Sabitler (Const)

Delphi programlama dilinde, veri yapılarını düzenlemek ve programın okunabilirliğini artırmak için çeşitli araçlar bulunur. Bu araçlardan ikisi de kayıt tipleri (records) ve sabitler (constants)‘dir. Bu makalede, kayıt tiplerinin ne olduğunu, nasıl kullanıldığını ve sabitlerin programlamadaki önemini detaylı bir şekilde inceleyeceğiz.

Kayıt Tipleri (Records) Nedir?

Kayıt tipleri, farklı veri türlerini tek bir çatı altında toplamanıza olanak tanıyan veri yapılarıdır. Başka bir deyişle, birbiriyle ilişkili farklı türdeki verileri bir araya getirerek daha anlamlı ve düzenli yapılar oluşturabilirsiniz. Örneğin, bir öğrencinin adını, soyadını, numarasını ve not ortalamasını tek bir kayıt altında tutabilirsiniz.

Kayıt Tipi Tanımlama

Kayıt tipleri, type anahtar kelimesiyle tanımlanır. İşte basit bir örnek:

type
  Ogrenci = record
    Ad: string;
    Soyad: string;
    Numara: Integer;
    NotOrtalamasi: Real;
  end;

Bu tanımlamada, Ogrenci adında bir kayıt tipi oluşturduk. Bu kayıt tipi, Ad (string), Soyad (string), Numara (Integer) ve NotOrtalamasi (Real) olmak üzere dört farklı alana sahiptir.

Kayıt Tipi Kullanımı

Kayıt tipini tanımladıktan sonra, bu tipten değişkenler oluşturabilir ve alanlarına erişebilirsiniz. İşte bir örnek:

var
  ogr1: Ogrenci;

begin
  ogr1.Ad := 'Ahmet';
  ogr1.Soyad := 'Yılmaz';
  ogr1.Numara := 12345;
  ogr1.NotOrtalamasi := 3.5;

  ShowMessage('Öğrenci Adı: ' + ogr1.Ad);
  ShowMessage('Öğrenci Soyadı: ' + ogr1.Soyad);
  ShowMessage('Öğrenci Numarası: ' + IntToStr(ogr1.Numara));
  ShowMessage('Öğrenci Not Ortalaması: ' + FloatToStr(ogr1.NotOrtalamasi));
end;

Bu örnekte, ogr1 adında bir Ogrenci tipinde değişken oluşturduk ve bu değişkenin alanlarına değerler atadık. Daha sonra, bu değerleri ekrana yazdırdık.

İç İçe Kayıtlar (Nested Records)

Kayıt tipleri, iç içe de kullanılabilir. Yani, bir kayıt tipinin içinde başka bir kayıt tipi bulunabilir. Bu, daha karmaşık veri yapıları oluşturmanıza olanak tanır. Örneğin, bir öğrencinin adres bilgilerini ayrı bir kayıt tipinde tanımlayıp, bu kayıt tipini Ogrenci kayıt tipinin içinde kullanabilirsiniz.

type
  Adres = record
    Sehir: string;
    Ilce: string;
    Mahalle: string;
  end;

  Ogrenci = record
    Ad: string;
    Soyad: string;
    Numara: Integer;
    NotOrtalamasi: Real;
    AdresBilgisi: Adres;
  end;

var
  ogr1: Ogrenci;

begin
  ogr1.Ad := 'Ahmet';
  ogr1.Soyad := 'Yılmaz';
  ogr1.Numara := 12345;
  ogr1.NotOrtalamasi := 3.5;
  ogr1.AdresBilgisi.Sehir := 'İstanbul';
  ogr1.AdresBilgisi.Ilce := 'Kadıköy';
  ogr1.AdresBilgisi.Mahalle := 'Caferağa';

  ShowMessage('Öğrenci Şehri: ' + ogr1.AdresBilgisi.Sehir);
end;

Bu örnekte, Adres adında bir kayıt tipi tanımladık ve bu kayıt tipini Ogrenci kayıt tipinin içinde AdresBilgisi adıyla kullandık.

Sabitler (Constants) Nedir?

Sabitler, programın çalışması sırasında değeri değişmeyen değerlerdir. Program içinde sabit bir değeri birden fazla yerde kullanmanız gerektiğinde, bu değeri bir sabit olarak tanımlamak, hem kodun okunabilirliğini artırır hem de değeri değiştirmek istediğinizde tek bir yerden değişiklik yapmanızı sağlar.

Sabit Tanımlama

Sabitler, const anahtar kelimesiyle tanımlanır. İşte basit bir örnek:

const
  PI = 3.14159;
  MAKSIMUM_OGRENCI_SAYISI = 100;
  UYGULAMA_ADI = 'Delphi Uygulaması';

Bu tanımlamada, PI, MAKSIMUM_OGRENCI_SAYISI ve UYGULAMA_ADI adında üç farklı sabit tanımladık. Sabitlerin değerleri programın çalışması sırasında değiştirilemez.

Sabit Kullanımı

Sabitler, değişkenler gibi kullanılabilir. İşte bir örnek:

const
  PI = 3.14159;

var
  yaricap: Real;
  alan: Real;

begin
  yaricap := 5;
  alan := PI * yaricap * yaricap;

  ShowMessage('Dairenin Alanı: ' + FloatToStr(alan));
end;

Bu örnekte, PI sabitini kullanarak bir dairenin alanını hesapladık.

Tip Belirtilmiş Sabitler (Typed Constants)

Delphi’de, sabitlere tip de belirtebilirsiniz. Bu, daha güvenli ve okunabilir kod yazmanıza yardımcı olur. İşte bir örnek:

const
  PI: Real = 3.14159;
  MAKSIMUM_OGRENCI_SAYISI: Integer = 100;
  UYGULAMA_ADI: string = 'Delphi Uygulaması';

Bu tanımlamada, sabitlerin tiplerini de belirttik. Bu, derleyicinin tip uyumsuzluğu hatalarını daha erken yakalamasına yardımcı olur.

Kayıtlar ve Sabitlerin Birlikte Kullanımı

Kayıt tipleri ve sabitler, birlikte kullanılarak daha karmaşık ve düzenli yapılar oluşturulabilir. Örneğin, bir şirketin çalışan bilgilerini tutan bir kayıt tipi tanımlayabilir ve şirketin adını bir sabit olarak tanımlayabilirsiniz.

const
  SIRKET_ADI = 'Delphi A.Ş.';

type
  Calisan = record
    Ad: string;
    Soyad: string;
    Departman: string;
    Maas: Real;
  end;

var
  calisan1: Calisan;

begin
  calisan1.Ad := 'Ayşe';
  calisan1.Soyad := 'Demir';
  calisan1.Departman := 'Yazılım Geliştirme';
  calisan1.Maas := 5000;

  ShowMessage('Şirket Adı: ' + SIRKET_ADI);
  ShowMessage('Çalışan Adı: ' + calisan1.Ad);
end;

Bu örnekte, SIRKET_ADI adında bir sabit tanımladık ve Calisan adında bir kayıt tipi oluşturduk. Daha sonra, bu sabit ve kayıt tipini birlikte kullandık.

Sonuç

Kayıt tipleri (records) ve sabitler (constants), Delphi programlama dilinde veri yapılarını düzenlemek ve programın okunabilirliğini artırmak için önemli araçlardır. Kayıt tipleri, farklı veri türlerini tek bir çatı altında toplamanıza olanak tanırken, sabitler programın çalışması sırasında değeri değişmeyen değerleri tanımlamanızı sağlar. Bu araçları doğru kullanarak, daha düzenli, okunabilir ve bakımı kolay programlar yazabilirsiniz.

Bu makalede, kayıt tiplerinin ve sabitlerin ne olduğunu, nasıl tanımlandığını ve kullanıldığını detaylı bir şekilde inceledik. Umarım bu bilgiler, Delphi programlama becerilerinizi geliştirmenize yardımcı olur.

11.Kayıt Tipleri (Records) ve Sabitler (Const) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

10. Tarih ve Saat İşlemleri (TDateTime Kullanımı)

Delphi programlama dilinde tarih ve saat işlemleri, finansal uygulamalardan, log kayıtlarına, randevu sistemlerinden, oyun geliştirmeye kadar birçok alanda kritik bir rol oynar. Delphi, tarih ve saat bilgilerini saklamak ve işlemek için TDateTime veri tipini sunar. Bu makalede, TDateTime’ın ne olduğunu, nasıl kullanıldığını ve Delphi’de tarih ve saatlerle nasıl etkili bir şekilde çalışabileceğinizi ayrıntılı olarak inceleyeceğiz.

TDateTime Veri Tipi Nedir?

TDateTime, Delphi’de tarih ve saat bilgilerini temsil etmek için kullanılan bir kayan noktalı sayı veri tipidir (Double). Tamsayı kısmı tarihi, ondalık kısmı ise günü temsil eder. Bu yapı, tarih ve saat bilgilerini tek bir değişken içinde saklamayı ve bu bilgiler üzerinde matematiksel işlemler yapmayı kolaylaştırır.

TDateTime, 30 Aralık 1899 saat 12:00’ı sıfır (0) olarak kabul eder. Bu tarihten sonraki her gün için tamsayı kısmı 1 artar. Örneğin, 31 Aralık 1899 saat 12:00, 1.0 değerine karşılık gelir. Saati temsil eden ondalık kısım ise, günün kesirsel bir parçasını ifade eder. Örneğin, öğlen 12:00 0.5 değerine, akşam 18:00 ise 0.75 değerine karşılık gelir.

TDateTime ile Çalışmak

TDateTime Değerleri Oluşturma

Delphi’de TDateTime değerleri oluşturmanın birkaç yolu vardır:

• Date ve Time Fonksiyonlarını Kullanmak: Date fonksiyonu geçerli tarihi, Time fonksiyonu ise geçerli saati TDateTime türünde döndürür.
• EncodeDate ve EncodeTime Fonksiyonlarını Kullanmak: Bu fonksiyonlar, sırasıyla yıl, ay, gün ve saat, dakika, saniye bilgilerini alarak bir TDateTime değeri oluşturur.
• StrToDateTime Fonksiyonunu Kullanmak: Bir string ifadeyi TDateTime türüne dönüştürmek için kullanılır.

var
  TarihSaat: TDateTime;
begin
  // Geçerli tarihi alır
  TarihSaat := Date;

  // Geçerli saati alır
  TarihSaat := Time;

  // Belirli bir tarih ve saat oluşturur
  TarihSaat := EncodeDate(2024, 10, 27) + EncodeTime(14, 30, 0);

  // String'den TDateTime'a dönüştürme
  TarihSaat := StrToDateTime('27.10.2024 14:30:00');
end;

TDateTime Değerlerini Ayrıştırma

Bir TDateTime değerinden tarih ve saat bilgilerini ayrı ayrı elde etmek için aşağıdaki fonksiyonlar kullanılabilir:

• DecodeDate: Bir TDateTime değerinden yıl, ay ve gün bilgilerini ayrıştırır.
• DecodeTime: Bir TDateTime değerinden saat, dakika, saniye ve milisaniye bilgilerini ayrıştırır.
• YearOf, MonthOf, DayOf, HourOf, MinuteOf, SecondOf, MilliSecondOf: Bu fonksiyonlar da bir TDateTime değerinden ilgili bileşenleri ayrıştırmak için kullanılabilir.

var
  TarihSaat: TDateTime;
  Yil, Ay, Gun, Saat, Dakika, Saniye, Milisaniye: Word;
begin
  TarihSaat := Now; // Şu anki tarih ve saati alır

  // DecodeDate ile tarih bileşenlerini ayrıştırma
  DecodeDate(TarihSaat, Yil, Ay, Gun);

  // DecodeTime ile saat bileşenlerini ayrıştırma
  DecodeTime(TarihSaat, Saat, Dakika, Saniye, Milisaniye);

  // YearOf, MonthOf, DayOf fonksiyonlarını kullanma
  Yil := YearOf(TarihSaat);
  Ay  := MonthOf(TarihSaat);
  Gun := DayOf(TarihSaat);
end;

TDateTime ile Aritmetik İşlemler

TDateTime, tarih ve saatler üzerinde aritmetik işlemler yapmayı kolaylaştırır. Örneğin, iki tarih arasındaki farkı hesaplayabilir, bir tarihe gün ekleyebilir veya çıkarabilirsiniz.

var
  Tarih1, Tarih2: TDateTime;
  Fark: Double;
begin
  Tarih1 := EncodeDate(2024, 10, 27);
  Tarih2 := EncodeDate(2024, 10, 30);

  // İki tarih arasındaki farkı gün cinsinden hesaplar
  Fark := Tarih2 - Tarih1;

  // Bir tarihe gün ekleme
  Tarih1 := Tarih1 + 7; // Tarih1'e 7 gün ekler
end;

Tarih ve Saat Biçimlendirme

TDateTime değerlerini kullanıcıya daha anlaşılır bir şekilde sunmak için biçimlendirme önemlidir. Delphi, tarih ve saatleri biçimlendirmek için FormatDateTime fonksiyonunu sunar. Bu fonksiyon, bir TDateTime değeri ve bir biçim stringi alır ve biçimlendirilmiş bir string döndürür.

var
  TarihSaat: TDateTime;
  BicimlendirilmisTarih: string;
begin
  TarihSaat := Now;

  // Tarihi belirli bir formatta biçimlendirme
  BicimlendirilmisTarih := FormatDateTime('dd.mm.yyyy hh:nn:ss', TarihSaat);

  // Farklı bir formatta biçimlendirme
  BicimlendirilmisTarih := FormatDateTime('yyyy-mm-dd', TarihSaat);
end;

FormatDateTime fonksiyonunda kullanılabilecek bazı yaygın biçim belirteçleri şunlardır:

• dd: Gün (01-31)
• mm: Ay (01-12)
• yyyy: Yıl (dört haneli)
• yy: Yıl (iki haneli)
• hh: Saat (00-23)
• nn: Dakika (00-59)
• ss: Saniye (00-59)
• zzz: Milisaniye (000-999)
• ddd: Haftanın günü (kısaltılmış)
• dddd: Haftanın günü (tam)
• mmm: Ay (kısaltılmış)
• mmmm: Ay (tam)

Örnek Uygulama: Kronometre

Aşağıdaki örnek, Delphi’de basit bir kronometre uygulamasının nasıl oluşturulabileceğini göstermektedir. Bu uygulama, Timer bileşenini ve TDateTime’ı kullanarak geçen süreyi hesaplar.

Bu örneği çalıştırmak için öncelikle Delphi’de yeni bir VCL Forms Application oluşturun. Form üzerine bir adet TButton, bir adet TLabel ve bir adet TTimer bileşeni ekleyin. Timer bileşeninin Enabled özelliğini False olarak ayarlayın.

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Label1: TLabel;
    Timer1: TTimer;
    procedure Button1Click(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
  private
    { Private declarations }
    StartTime: TDateTime;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  if Timer1.Enabled then
  begin
    Timer1.Enabled := False;
    Button1.Caption := 'Başlat';
  end
  else
  begin
    StartTime := Now;
    Timer1.Enabled := True;
    Button1.Caption := 'Durdur';
  end;
end;

procedure TForm1.Timer1Timer(Sender: TObject);
var
  ElapsedTime: TDateTime;
begin
  ElapsedTime := Now - StartTime;
  Label1.Caption := FormatDateTime('nn:ss:zzz', ElapsedTime);
end;

end.

Formun .dfm dosyası (isteğe bağlı):

object Form1: TForm1
  Left = 0
  Top = 0
  Caption = 'Kronometre'
  ClientHeight = 150
  ClientWidth = 300
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'Tahoma'
  Font.Style = []
  OldCreateOrder = False
  PixelsPerInch = 96
  TextHeight = 13
  object Button1: TButton
    Left = 112
    Top = 24
    Width = 75
    Height = 25
    Caption = 'Başlat'
    TabOrder = 0
    OnClick = Button1Click
  end
  object Label1: TLabel
    Left = 120
    Top = 72
    Width = 58
    Height = 13
    Caption = '00:00:000'
    TabOrder = 1
  end
  object Timer1: TTimer
    Interval = 1
    OnTimer = Timer1Timer
  end
end

Bu örnekte, Timer bileşeninin Interval özelliği 1 milisaniyeye ayarlanmıştır. Bu, Timer’ın her milisaniyede bir Timer1Timer olayını tetiklemesini sağlar. Timer1Timer olayında, geçen süre hesaplanır ve Label1 bileşeninde görüntülenir.

Sonuç

Delphi’de TDateTime veri tipi, tarih ve saatlerle çalışmayı son derece kolaylaştırır. Bu makalede, TDateTime’ın ne olduğunu, nasıl kullanıldığını ve tarih/saat bilgilerini nasıl biçimlendirebileceğinizi öğrendiniz. Ayrıca, basit bir kronometre uygulaması örneğiyle TDateTime’ın pratik kullanımını gördünüz. Bu bilgilerle, Delphi projelerinizde tarih ve saat işlemlerini etkili bir şekilde yönetebilirsiniz.

10. Tarih ve Saat İşlemleri (TDateTime Kullanımı) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

9. String İşlemleri (String Manipülasyonu ve Formatlama)

Delphi programlama dilinde, metin verileriyle çalışmak, birçok uygulamanın temelini oluşturur. Kullanıcı arayüzlerinden veri tabanlarına, dosya işlemlerinden ağ iletişimine kadar her alanda stringlerle etkileşim halindeyiz. Delphi, string manipulasyonu ve formatlama için zengin bir araç seti sunar. Bu makalede, Delphi’de stringlerle nasıl etkili bir şekilde çalışabileceğinizi, farklı string fonksiyonlarını ve formatlama tekniklerini detaylı bir şekilde inceleyeceğiz.

String Tanımlama ve Kullanımı

Delphi’de stringler, String veri tipiyle tanımlanır. Delphi’nin modern versiyonlarında (Delphi 2009 ve sonrası), UnicodeString kullanılır; bu da çok çeşitli karakter setlerini destekleyerek global uygulamalar geliştirmeyi kolaylaştırır. Temel string tanımlama ve kullanma örneklerine bakalım:

var
  isim: String;
  soyisim: String;
  tamAd: String;
begin
  isim := 'Ahmet';
  soyisim := 'Yılmaz';
  tamAd := isim + ' ' + soyisim; // String birleştirme
  ShowMessage(tamAd);
end;

Bu örnekte, iki string değişkeni tanımlayıp, değerlerini atadık ve ardından bu iki stringi birleştirerek yeni bir string oluşturduk. + operatörü, Delphi’de string birleştirme için kullanılır.

Temel String Fonksiyonları

Delphi, stringlerle çalışmayı kolaylaştıran birçok yerleşik fonksiyon sunar. İşte en sık kullanılanlardan bazıları:

• Length(String): Bir stringin uzunluğunu (karakter sayısını) döndürür.
• Copy(String, Başlangıç, Adet): Bir stringin belirli bir bölümünü kopyalar.
• Pos(AltString, String): Bir alt stringin, bir string içindeki ilk konumunu bulur. Eğer alt string bulunamazsa, 0 döndürür.
• Delete(String, Başlangıç, Adet): Bir stringden belirli sayıda karakteri siler.
• Insert(AltString, String, Pozisyon): Bir stringin içine başka bir stringi ekler.
• UpperCase(String): Bir stringi tamamen büyük harfe çevirir.
• LowerCase(String): Bir stringi tamamen küçük harfe çevirir.
• Trim(String): Bir stringin başındaki ve sonundaki boşlukları temizler.
• TrimLeft(String): Bir stringin solundaki boşlukları temizler.
• TrimRight(String): Bir stringin sağındaki boşlukları temizler.

Örnek Kullanımlar

Bu fonksiyonların nasıl kullanıldığına dair bazı örnekler görelim:

var
  metin: String;
  uzunluk: Integer;
  altMetin: String;
  pozisyon: Integer;
begin
  metin := '  Merhaba Dünya!  ';
  uzunluk := Length(metin); // Uzunluk: 17 (boşluklarla birlikte)
  ShowMessage('Metnin uzunluğu: ' + IntToStr(uzunluk));

  altMetin := Copy(metin, 3, 7); // AltMetin: 'Merhaba'
  ShowMessage('Alt metin: ' + altMetin);

  pozisyon := Pos('Dünya', metin); // Pozisyon: 12
  ShowMessage('Dünya kelimesinin pozisyonu: ' + IntToStr(pozisyon));

  Delete(metin, 1, 2); // Metin: 'Merhaba Dünya!  ' (baştaki boşluklar silindi)
  ShowMessage('Silinmiş metin: ' + metin);

  Insert('Yeni ', metin, 9); // Metin: 'Merhaba Yeni Dünya!  '
  ShowMessage('Eklenmiş metin: ' + metin);

  metin := Trim(metin); // Metin: 'Merhaba Yeni Dünya!' (baştaki ve sondaki boşluklar silindi)
  ShowMessage('Trimlenmiş metin: ' + metin);
end;

String Formatlama

String formatlama, değişken değerlerini belirli bir düzende bir stringe yerleştirmek için kullanılır. Delphi, bu işlem için Format fonksiyonunu ve FormatFloat fonksiyonunu sunar.

Format Fonksiyonu

Format fonksiyonu, genel amaçlı formatlama için kullanılır. Biçimlendirme stringi ve bir dizi parametre alır.

var
  ad: String;
  yas: Integer;
  mesaj: String;
begin
  ad := 'Ayşe';
  yas := 25;
  mesaj := Format('Merhaba, %s! Yaşınız: %d', [ad, yas]);
  ShowMessage(mesaj); // Çıktı: Merhaba, Ayşe! Yaşınız: 25
end;

Bu örnekte, %s stringleri, %d ise integer değerleri temsil eder. Format fonksiyonuna geçirilen dizi, bu yer tutucuların yerine konacak değerleri içerir.

FormatFloat Fonksiyonu

FormatFloat fonksiyonu, ondalıklı sayıları belirli bir biçimde formatlamak için kullanılır. Özellikle para birimi veya hassas ölçümlerle çalışırken kullanışlıdır.

var
  fiyat: Double;
  formatliFiyat: String;
begin
  fiyat := 1234.567;
  formatliFiyat := FormatFloat('0.00', fiyat); // İki ondalık basamaklı format
  ShowMessage('Fiyat: ' + formatliFiyat); // Çıktı: Fiyat: 1234.57 (yuvarlama yapılır)

  formatliFiyat := FormatFloat('#,##0.00', fiyat); // Binlik ayraçlı format
  ShowMessage('Fiyat: ' + formatliFiyat); // Çıktı: Fiyat: 1,234.57
end;

Bu örnekte, '0.00' format stringi, sayının iki ondalık basamakla gösterilmesini sağlar. '#,##0.00' ise binlik ayraçlarını ekler.

String Builder Kullanımı

Büyük string manipulasyonları yaparken, özellikle döngüler içinde string birleştirmeleri yaparken, performans sorunları yaşanabilir. Bu durumda StringBuilder sınıfını kullanmak daha verimli olabilir. StringBuilder, stringleri bellekte sürekli yeniden oluşturmak yerine, bir arabellek kullanarak stringleri bir araya getirir ve sonunda tek bir string olarak döndürür.

uses
  System.SysUtils, System.Classes;

var
  i: Integer;
  sb: TStringBuilder;
  sonuc: String;
begin
  sb := TStringBuilder.Create;
  try
    for i := 1 to 1000 do
    begin
      sb.Append('Satır ' + IntToStr(i) + #13#10); // #13#10: Yeni satır karakteri
    end;
    sonuc := sb.ToString;
    // ShowMessage(sonuc); // Çok uzun olduğu için göstermiyoruz
  finally
    sb.Free;
  end;
end;

Bu örnekte, TStringBuilder nesnesi oluşturulur, döngü içinde stringler bu nesneye eklenir ve sonunda ToString metodu ile tek bir string elde edilir. try...finally bloğu, StringBuilder nesnesinin her durumda serbest bırakılmasını sağlar.

Sonuç

Delphi’de string işlemleri, uygulama geliştirmenin ayrılmaz bir parçasıdır. Bu makalede, temel string fonksiyonlarını, formatlama tekniklerini ve StringBuilder sınıfını kullanarak daha verimli string manipulasyonları yapmayı öğrendik. Bu bilgiler, Delphi projelerinizde metin verileriyle daha etkili bir şekilde çalışmanıza yardımcı olacaktır. String manipulasyonu ve formatlama konusundaki bu bilgilerle, uygulamalarınızı daha kullanıcı dostu ve işlevsel hale getirebilirsiniz.

9. String İşlemleri (String Manipülasyonu ve Formatlama) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

8. Diziler (Arrays) ve Koleksiyonlar (List, Dictionary, vb.)

Delphi programlama dilinde, verileri düzenli bir şekilde saklamak ve yönetmek için diziler (arrays) ve koleksiyonlar (collections) önemli araçlardır. Bu yapılar, aynı türden birden fazla veriyi tek bir değişken adı altında toplamamızı ve bu verilere kolayca erişmemizi sağlar. Bu makalede, Delphi’de dizilerin ve koleksiyonların ne olduğunu, nasıl kullanıldığını ve hangi durumlarda tercih edilmesi gerektiğini detaylı bir şekilde inceleyeceğiz.

Diziler (Arrays)

Diziler, aynı türden verilerin sıralı bir şekilde saklandığı veri yapılarıdır. Delphi’de diziler statik veya dinamik olarak tanımlanabilir. Statik dizilerin boyutu derleme zamanında belirlenirken, dinamik dizilerin boyutu çalışma zamanında değiştirilebilir.

Statik Diziler

Statik diziler, boyutları önceden belirlenmiş olan dizilerdir. Tanımlanırken eleman sayısı belirtilir ve bu sayı programın çalışması sırasında değiştirilemez.

Tanımlama:

Statik bir dizi tanımlamak için aşağıdaki sözdizimi kullanılır:

var
  diziAdi: array[baslangicIndeksi..bitisIndeksi] of veriTipi;

Örnek:

var
  sayilar: array[1..5] of Integer;
  isimler: array[0..9] of String;

Bu örnekte, sayilar adında 1’den 5’e kadar indekslere sahip integer türünde bir dizi ve isimler adında 0’dan 9’a kadar indekslere sahip string türünde bir dizi tanımlanmıştır.

Değer Atama ve Erişim:

Dizinin elemanlarına değer atamak ve erişmek için indeksler kullanılır:

sayilar[1] := 10;
sayilar[2] := 20;

var ilkSayi: Integer := sayilar[1];

Dinamik Diziler

Dinamik diziler, boyutları çalışma zamanında belirlenen ve değiştirilebilen dizilerdir. Bu, programın ihtiyaçlarına göre dizi boyutunu ayarlama esnekliği sağlar.

Tanımlama:

Dinamik bir dizi tanımlamak için aşağıdaki sözdizimi kullanılır:

var
  diziAdi: array of veriTipi;

Örnek:

var
  notlar: array of Double;
  ogrenciIsimleri: array of String;

Bu örnekte, notlar adında double türünde ve ogrenciIsimleri adında string türünde dinamik diziler tanımlanmıştır. Ancak, bu dizilerin boyutları henüz belirlenmemiştir.

Boyutlandırma:

Dinamik dizilerin boyutunu belirlemek için SetLength fonksiyonu kullanılır:

SetLength(notlar, 100); // notlar dizisinin boyutunu 100 olarak ayarla
SetLength(ogrenciIsimleri, 50); // ogrenciIsimleri dizisinin boyutunu 50 olarak ayarla

Değer Atama ve Erişim:

Dinamik dizilerin elemanlarına değer atamak ve erişmek için statik dizilerde olduğu gibi indeksler kullanılır:

notlar[0] := 95.5;
ogrenciIsimleri[0] := 'Ahmet';

Koleksiyonlar (Collections)

Koleksiyonlar, dizilere göre daha esnek ve gelişmiş veri yapılarıdır. Delphi’de birçok farklı koleksiyon türü bulunur. Bunlardan bazıları şunlardır:

• TList: Sıralı bir liste oluşturmak için kullanılır.
• TDictionary: Anahtar-değer çiftlerini saklamak için kullanılır.
• TStringList: String türündeki verileri saklamak ve yönetmek için kullanılır.
• TQueue: İlk giren ilk çıkar (FIFO) prensibine göre çalışan bir kuyruk yapısıdır.
• TStack: Son giren ilk çıkar (LIFO) prensibine göre çalışan bir yığın yapısıdır.

TList

TList, nesneleri veya pointer’ları saklamak için kullanılan sıralı bir listedir. Dinamik olarak büyüyebilir ve küçülebilir.

Kullanımı:

uses
  System.Generics.Collections;

var
  liste: TList<Integer>;
  i: Integer;
begin
  liste := TList<Integer>.Create;
  try
    liste.Add(10);
    liste.Add(20);
    liste.Add(30);

    for i := 0 to liste.Count - 1 do
      ShowMessage(IntToStr(liste[i]));
  finally
    liste.Free;
  end;
end;

TDictionary

TDictionary, anahtar-değer çiftlerini saklamak için kullanılan bir koleksiyondur. Her anahtar benzersiz olmalıdır. Bu yapı, verilere anahtar üzerinden hızlı erişim sağlar.

Kullanımı:

uses
  System.Generics.Collections;

var
  sozluk: TDictionary<String, Integer>;
begin
  sozluk := TDictionary<String, Integer>.Create;
  try
    sozluk.Add('Ahmet', 25);
    sozluk.Add('Ayşe', 30);

    ShowMessage(IntToStr(sozluk['Ahmet'])); // 25
  finally
    sozluk.Free;
  end;
end;

TStringList

TStringList, string türündeki verileri saklamak ve yönetmek için özel olarak tasarlanmış bir koleksiyondur. Metin dosyalarını okuma, yazma, sıralama ve arama gibi işlemler için kullanışlı yöntemler sunar.

Kullanımı:

var
  stringList: TStringList;
  i: Integer;
begin
  stringList := TStringList.Create;
  try
    stringList.Add('Elma');
    stringList.Add('Armut');
    stringList.Add('Kiraz');

    for i := 0 to stringList.Count - 1 do
      ShowMessage(stringList[i]);
  finally
    stringList.Free;
  end;
end;

Diziler mi, Koleksiyonlar mı?

Diziler ve koleksiyonlar arasındaki temel farklar ve ne zaman hangisinin tercih edilmesi gerektiği aşağıda özetlenmiştir:

• Boyut Esnekliği: Dinamik dizilerin boyutu çalışma zamanında değiştirilebilirken, statik dizilerin boyutu sabittir. Koleksiyonlar genellikle dinamik olarak büyüyebilir ve küçülebilir.
• Veri Türü: Diziler belirli bir veri türündeki elemanları saklarken, bazı koleksiyonlar (örneğin TList) farklı türdeki nesneleri saklayabilir. Ancak, tipleri önceden belirtmek generic koleksiyonlar ile mümkündür.
• Fonksiyonellik: Koleksiyonlar, dizilere göre daha fazla fonksiyonellik sunar. Örneğin, TStringList metin dosyalarını okuma/yazma, sıralama ve arama gibi işlemleri kolaylaştıran yöntemler içerir.
• Performans: Dizilere erişim genellikle koleksiyonlara göre daha hızlıdır. Ancak, koleksiyonların sunduğu ek fonksiyonellik ve esneklik, bazı durumlarda performanstan ödün vermeye değer olabilir.

Genel olarak:

• Eğer boyutun önceden bilindiği ve nadiren değiştiği durumlarda diziler tercih edilebilir.
• Eğer boyutun çalışma zamanında değişmesi gerekiyorsa veya daha fazla fonksiyonelliğe ihtiyaç varsa koleksiyonlar daha uygun olabilir.

Özet

Delphi’de diziler ve koleksiyonlar, verileri düzenli bir şekilde saklamak ve yönetmek için güçlü araçlardır. Diziler, aynı türden verileri sıralı bir şekilde saklarken, koleksiyonlar daha esnek ve gelişmiş veri yapılarıdır. Hangi yapının kullanılacağı, uygulamanın gereksinimlerine ve performans ihtiyaçlarına bağlıdır. Bu makalede, dizilerin ve koleksiyonların temel kavramlarını, kullanım örneklerini ve ne zaman hangisinin tercih edilmesi gerektiğini ayrıntılı olarak inceledik. Bu bilgiler, Delphi projelerinizde daha etkili veri yönetimi stratejileri geliştirmenize yardımcı olacaktır.

8. Diziler (Arrays) ve Koleksiyonlar (List, Dictionary, vb.) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

7. Prosedürler ve Fonksiyonlar (Metotlar)

Delphi programlama dilinde, kodun düzenlenmesi, yeniden kullanılabilirliğinin artırılması ve karmaşıklığının azaltılması için prosedürler ve fonksiyonlar (genellikle metotlar olarak da adlandırılır) önemli bir rol oynar. Bu yapılar, belirli bir görevi gerçekleştiren kod bloklarını temsil eder ve programın farklı yerlerinden çağrılarak tekrar tekrar kullanılabilir.

Prosedürler

Prosedürler, belirli bir işlemi gerçekleştiren ve herhangi bir değer döndürmeyen kod bloklarıdır. Bir prosedür, parametre alabilir veya almayabilir. Parametreler, prosedüre girdi olarak sağlanan değerlerdir ve prosedürün davranışını etkiler.

Prosedür Tanımlama

Bir prosedür aşağıdaki gibi tanımlanır:

procedure ProsedurAdi(Parametre1: VeriTipi; Parametre2: VeriTipi);
begin
  // Prosedürün gerçekleştireceği işlemler
end;

Örneğin, iki sayıyı toplayıp sonucu ekrana yazdıran bir prosedür şöyle olabilir:

procedure ToplaVeYaz(Sayi1: Integer; Sayi2: Integer);
var
  Sonuc: Integer;
begin
  Sonuc := Sayi1 + Sayi2;
  ShowMessage('Sonuç: ' + IntToStr(Sonuc));
end;

Prosedür Çağırma

Bir prosedürü çağırmak için adını ve varsa parametrelerini belirtmeniz yeterlidir:

ToplaVeYaz(5, 3); // Ekrana "Sonuç: 8" yazdırır

Fonksiyonlar

Fonksiyonlar, prosedürlere benzer, ancak bir değer döndürürler. Bu değer, fonksiyonun gerçekleştirdiği işlemin sonucudur. Fonksiyonlar da parametre alabilir veya almayabilir.

Fonksiyon Tanımlama

Bir fonksiyon aşağıdaki gibi tanımlanır:

function FonksiyonAdi(Parametre1: VeriTipi; Parametre2: VeriTipi): DonusTipi;
begin
  // Fonksiyonun gerçekleştireceği işlemler
  // DonusTipi türünde bir değer döndürmeli
  Result := DonusDegeri;
end;

Örneğin, iki sayıyı toplayıp sonucu döndüren bir fonksiyon şöyle olabilir:

function Topla(Sayi1: Integer; Sayi2: Integer): Integer;
begin
  Result := Sayi1 + Sayi2;
end;

Fonksiyon Çağırma

Bir fonksiyonu çağırmak ve döndürdüğü değeri kullanmak için şöyle bir ifade kullanabilirsiniz:

var
  Toplam: Integer;
begin
  Toplam := Topla(5, 3);
  ShowMessage('Toplam: ' + IntToStr(Toplam)); // Ekrana "Toplam: 8" yazdırır
end;

Prosedürler ve Fonksiyonlar Arasındaki Farklar

Temel fark, fonksiyonların bir değer döndürmesi, prosedürlerin ise döndürmemesidir. Fonksiyonlar genellikle bir hesaplama veya dönüşüm işleminin sonucunu elde etmek için kullanılırken, prosedürler genellikle bir eylemi gerçekleştirmek veya bir durumu değiştirmek için kullanılır.

• Değer Döndürme: Fonksiyonlar değer döndürür, prosedürler döndürmez.
• Kullanım Amacı: Fonksiyonlar genellikle hesaplama, dönüşüm gibi işlemler için, prosedürler ise eylem veya durum değişikliği için kullanılır.

Metotlar (Nesne Yönelimli Programlama Bağlamında)

Delphi, nesne yönelimli bir programlama dilidir. Bu bağlamda, metotlar, bir nesneye ait prosedür veya fonksiyonlardır. Metotlar, nesnenin davranışını tanımlar ve nesnenin verileri üzerinde işlem yapar.

Metot Tanımlama

Bir sınıf içinde metotlar aşağıdaki gibi tanımlanır:

type
  TOrnekSinif = class
  private
    FVeri: Integer;
  public
    procedure Metot1;
    function Metot2: String;
  end;

implementation

procedure TOrnekSinif.Metot1;
begin
  // Metot1'in gerçekleştireceği işlemler
end;

function TOrnekSinif.Metot2: String;
begin
  Result := 'Merhaba Dünya!';
end;

Metot Çağırma

Bir nesnenin metodunu çağırmak için nokta notasyonu kullanılır:

var
  OrnekNesne: TOrnekSinif;
begin
  OrnekNesne := TOrnekSinif.Create;
  OrnekNesne.Metot1; // Metot1 çağrılıyor
  ShowMessage(OrnekNesne.Metot2); // Metot2 çağrılıyor ve sonucu ekrana yazdırılıyor
  OrnekNesne.Free;
end;

Parametre Geçirme Yöntemleri

Delphi’de parametreler prosedürlere ve fonksiyonlara farklı şekillerde geçirilebilir. Bu yöntemler, parametrelerin nasıl kullanıldığı ve nasıl değiştirilebildiği üzerinde etkilidir.

• Değer ile Geçirme (By Value): Parametrenin bir kopyası fonksiyona veya prosedüre geçirilir. Fonksiyon veya prosedür içindeki değişiklikler orijinal parametreyi etkilemez.
• Referans ile Geçirme (By Reference): Parametrenin adresi fonksiyona veya prosedüre geçirilir. Fonksiyon veya prosedür içindeki değişiklikler orijinal parametreyi etkiler. `var` anahtar kelimesi ile belirtilir.
• Sabit Referans ile Geçirme (Const): Parametre referans ile geçirilir, ancak fonksiyon veya prosedür içinde değiştirilemez. Bu, performans açısından avantajlıdır çünkü veri kopyalanmaz, ancak güvenliği de sağlar.

Örnek Parametre Geçirme Yöntemleri

procedure DegerIleGec(Sayi: Integer);
begin
  Sayi := Sayi + 10; // Bu değişiklik ana programdaki Sayi değişkenini etkilemez
end;

procedure ReferansIleGec(var Sayi: Integer);
begin
  Sayi := Sayi + 10; // Bu değişiklik ana programdaki Sayi değişkenini etkiler
end;

procedure SabitReferansIleGec(const Sayi: Integer);
begin
  // Sayi := Sayi + 10; // Bu satır hata verir, çünkü Sayi değiştirilemez
end;

İleri Düzey Kullanım: Fonksiyon Göstericileri (Function Pointers)

Delphi, fonksiyon göstericilerini destekler. Bu, bir fonksiyonun adresini bir değişkende saklayıp, bu değişken aracılığıyla fonksiyonu çağırmanıza olanak tanır. Fonksiyon göstericileri, esnek ve dinamik programlama teknikleri için önemlidir.

type
  TToplamaFonksiyonu = function(Sayi1, Sayi2: Integer): Integer;

var
  FonksiyonGostericisi: TToplamaFonksiyonu;

function Topla(Sayi1, Sayi2: Integer): Integer;
begin
  Result := Sayi1 + Sayi2;
end;

begin
  FonksiyonGostericisi := Topla;
  ShowMessage(IntToStr(FonksiyonGostericisi(5, 3))); // Ekrana "8" yazdırır
end;

Sonuç

Prosedürler ve fonksiyonlar, Delphi programlama dilinde kodun modülerleştirilmesi, yeniden kullanılabilirliğinin artırılması ve okunabilirliğinin iyileştirilmesi için temel araçlardır. Metotlar ise, nesne yönelimli programlamanın önemli bir parçasıdır ve nesnelerin davranışlarını tanımlar. Parametre geçirme yöntemleri ve fonksiyon göstericileri gibi ileri düzey özellikler, daha esnek ve güçlü uygulamalar geliştirmenize olanak tanır. Bu yapıları etkin bir şekilde kullanarak, daha karmaşık ve yönetilebilir Delphi uygulamaları oluşturabilirsiniz.

“Prosedürler ve fonksiyonlar, yazılım mühendisliğinin temel taşlarıdır. İyi tasarlanmış prosedürler ve fonksiyonlar, kodun anlaşılmasını kolaylaştırır ve hataları azaltır.” – Yazılım Uzmanı

7. Prosedürler ve Fonksiyonlar (Metotlar) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

6. Döngüler (for, while, repeat-until)

Delphi programlama dilinde döngüler, belirli bir kod bloğunu tekrar tekrar çalıştırmak için kullanılan temel kontrol yapılarıdır. Bu döngüler, bir koşul doğru olduğu sürece veya belirli bir sayıda tekrar gerçekleşene kadar çalışmaya devam ederler. Delphi’de yaygın olarak kullanılan üç ana döngü türü vardır: for, while ve repeat-until. Bu makalede, bu döngülerin her birini ayrıntılı olarak inceleyeceğiz ve nasıl kullanılacaklarına dair örnekler sunacağız.

for Döngüsü

for döngüsü, belirli bir sayıda tekrar yapmak istediğimizde kullanılır. Genellikle bir sayaç değişkeni kullanılarak kontrol edilir.

for Döngüsünün Sözdizimi

for döngüsünün genel sözdizimi şu şekildedir:

for sayaç := başlangıç değeri to bitiş değeri do
begin
  // Tekrarlanacak kod bloğu
end;

Eğer sayaç değişkenini azaltarak döngü yapmak isterseniz downto anahtar kelimesini kullanabilirsiniz:

for sayaç := başlangıç değeri downto bitiş değeri do
begin
  // Tekrarlanacak kod bloğu
end;

for Döngüsü Örneği

Aşağıdaki örnek, 1’den 10’a kadar olan sayıları ekrana yazdırmak için for döngüsünü kullanır:

program ForDongusu;

{$APPTYPE CONSOLE}

var
  i: Integer;

begin
  for i := 1 to 10 do
  begin
    Writeln('Sayı: ', i);
  end;
  Readln;
end.

Bu kod, konsolda aşağıdaki çıktıyı üretir:

Sayı: 1
Sayı: 2
Sayı: 3
Sayı: 4
Sayı: 5
Sayı: 6
Sayı: 7
Sayı: 8
Sayı: 9
Sayı: 10

while Döngüsü

while döngüsü, belirli bir koşul doğru olduğu sürece bir kod bloğunu çalıştırmak için kullanılır. Koşul döngünün başında kontrol edilir, bu nedenle eğer koşul başlangıçta yanlışsa döngü hiç çalışmaz.

while Döngüsünün Sözdizimi

while döngüsünün genel sözdizimi şu şekildedir:

while koşul do
begin
  // Tekrarlanacak kod bloğu
end;

while Döngüsü Örneği

Aşağıdaki örnek, bir sayacın değeri 5’ten küçük olduğu sürece ekrana sayacı yazdırmak için while döngüsünü kullanır:

program WhileDongusu;

{$APPTYPE CONSOLE}

var
  sayac: Integer;

begin
  sayac := 1;
  while sayac < 5 do
  begin
    Writeln('Sayaç değeri: ', sayac);
    sayac := sayac + 1;
  end;
  Readln;
end.

Bu kod, konsolda aşağıdaki çıktıyı üretir:

Sayaç değeri: 1
Sayaç değeri: 2
Sayaç değeri: 3
Sayaç değeri: 4

repeat-until Döngüsü

repeat-until döngüsü, bir kod bloğunu en az bir kez çalıştırmak ve ardından bir koşul yanlış olana kadar tekrar çalıştırmak için kullanılır. Koşul döngünün sonunda kontrol edilir, bu nedenle döngü içindeki kod bloğu en az bir kez çalışır.

repeat-until Döngüsünün Sözdizimi

repeat-until döngüsünün genel sözdizimi şu şekildedir:

repeat
  // Tekrarlanacak kod bloğu
until koşul;

repeat-until Döngüsü Örneği

Aşağıdaki örnek, bir sayacın değeri 5’ten büyük veya eşit olana kadar ekrana sayacı yazdırmak için repeat-until döngüsünü kullanır:

program RepeatUntilDongusu;

{$APPTYPE CONSOLE}

var
  sayac: Integer;

begin
  sayac := 1;
  repeat
    Writeln('Sayaç değeri: ', sayac);
    sayac := sayac + 1;
  until sayac >= 5;
  Readln;
end.

Bu kod, konsolda aşağıdaki çıktıyı üretir:

Sayaç değeri: 1
Sayaç değeri: 2
Sayaç değeri: 3
Sayaç değeri: 4
Sayaç değeri: 5

Döngü Kontrol İfadeleri: break ve continue

Delphi, döngülerin akışını kontrol etmek için iki önemli ifade sunar: break ve continue.

break İfadesi

break ifadesi, döngüyü anında sonlandırır ve döngüden sonraki ilk ifadeye geçilir. Bu, belirli bir koşul karşılandığında döngüyü erken sonlandırmak için kullanışlıdır.

program BreakOrnegi;
{$APPTYPE CONSOLE}
var
  i: Integer;
begin
  for i := 1 to 10 do
  begin
    if i = 5 then
      break; // Döngüyü sonlandır
    Writeln('Sayı: ', i);
  end;
  Writeln('Döngü tamamlandı.');
  Readln;
end.

Bu örnekte, i değeri 5 olduğunda break ifadesi çalışır ve döngü sonlanır. Çıktı aşağıdaki gibi olacaktır:

Sayı: 1
Sayı: 2
Sayı: 3
Sayı: 4
Döngü tamamlandı.

continue İfadesi

continue ifadesi, döngünün mevcut iterasyonunu atlar ve bir sonraki iterasyona geçer. Bu, belirli bir koşul karşılandığında döngü içindeki belirli bir kod bloğunu atlamak için kullanışlıdır.

program ContinueOrnegi;
{$APPTYPE CONSOLE}
var
  i: Integer;
begin
  for i := 1 to 10 do
  begin
    if i mod 2 = 0 then
      continue; // Mevcut iterasyonu atla (çift sayıları atla)
    Writeln('Sayı: ', i);
  end;
  Writeln('Döngü tamamlandı.');
  Readln;
end.

Bu örnekte, i değeri çift sayı olduğunda continue ifadesi çalışır ve o iterasyon atlanır. Çıktı aşağıdaki gibi olacaktır:

Sayı: 1
Sayı: 3
Sayı: 5
Sayı: 7
Sayı: 9
Döngü tamamlandı.

İç İçe Döngüler

Delphi’de, döngülerin içine başka döngüler yerleştirmek mümkündür. Bu tür yapılara iç içe döngüler denir. İç içe döngüler, iki veya daha fazla boyutlu veri yapılarını işlemek veya karmaşık algoritmaları uygulamak için kullanışlıdır.

program IcIceDonguler;
{$APPTYPE CONSOLE}
var
  i, j: Integer;
begin
  for i := 1 to 3 do
  begin
    for j := 1 to 3 do
    begin
      Writeln('i = ', i, ', j = ', j);
    end;
  end;
  Readln;
end.

Bu örnek, 1’den 3’e kadar olan i ve j değerlerini kullanarak iç içe for döngülerini gösterir. Çıktı aşağıdaki gibi olacaktır:

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3

Sonuç

Delphi’de döngüler, programlamanın temel bir parçasıdır ve kodunuzun verimli ve etkili bir şekilde çalışmasını sağlamak için önemlidir. for, while ve repeat-until döngüleri, farklı senaryolarda kullanılabilecek güçlü araçlardır. Ayrıca, break ve continue ifadeleri ile döngülerin akışını daha da kontrol edebilirsiniz. Bu döngüleri ve kontrol ifadelerini iyi anlamak, daha karmaşık ve güçlü Delphi uygulamaları geliştirmenize yardımcı olacaktır.

Bu makalede, Delphi’deki döngülerin temel kavramlarını ve kullanımlarını ele aldık. Umarım bu bilgiler, Delphi programlama becerilerinizi geliştirmenize yardımcı olur.

6. Döngüler (for, while, repeat-until) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.