Read/Readln Komutu

Ekrana yazı yazdırmayı gördük. Şidmi de ekrandan (daha doğrusu ekran vasıtasıyla kullanıcıdan) bir veri (isim, yaş, telefon numarası gibi..) almaya bakalım. Bu işlem için Read ya da Readln (genellikle readln) komutu kullanılır. Read komutunu kullanırsanız kullanıcı çok hata yapar. En iyisi readln kullanmak. Ben bunu anlatayım. Kullanım şekli Readln(değişken); şeklindedir ve kullanıldığından kullanıcıdan birşeyler yazıp enter'a basmasını bekler. Enter'a basılınca kullanıcının yazdığı verileri parantez içerisine yazılan değişkene aktarır ve artık bu değişkenin değeri bu olur. Yani üstüne falan eklenmez. Eski değeri silinir ve yeni değeri kullanıcı ne girdiyse o olur. Genellikle write komutuyla yan yana (daha doğrusu ar arda) kullanılır. Çünkü kullanıcının ne girmesi gerektiğini ona söylememiz lazım. Örnek için basit program:

Program Oku_bakiim;
uses crt;
var
a:integer;
isim:string[40];
begin clrscr;
write('Bu program verilen bir sayinin karesini ve kubunu bulur');
writeln;
write('Bir Sayi Giriniz: ');readln(a);
write(a,' sayisinin karesi ',a*a,' ve kubu ',a*a*a,' olur.');
writeln;
write('Adinizi giriniz: ');
readln(isim);
clrscr;
Writeln('Gule gule ',isim);
Writeln('Programi bitirmek icin Entera basiniz...');
readln;
end.

Programı TP'da yazıp çalıştırın ve sonucuna bakın. Bu program write/writeln ve readln komutlarının anlaşılmasına yeterlidir. Zaten ilerde bu iki komutu çok kullanacağız. Belki farketmişsinizdir bu readln komutunun bazı yetersizlikleri var. Mesela kullanıcıdan bir sayı girmesini istiyoruz. Ama kullanıcı sayı olmayan buraya birşeyler de yazabilir ve biz bunu engelleyemeyiz. Bu durumda program hata verir. Bunu önlemek için kendi readln komutumuzu kendimiz oluşurmalıyız. Bunu ilerde göreceğiz.

Readkey

Yeri gelmişken ilerde çok kullanacağınız Readkey fonksyonuna deyinelim. Dediğim gibi readkey bir fonksyondur ve sonucu bir karekterdir. yani sadece readkey; diye bir komut kullanılamaz. Çünkü sonucu karakter dediğimizden mesela sonucu 'A' harfi ise A; diye bir komut olabilir mi? Ama a:=readkey; ("A" için a:='A'; gibi..) ya da write(readkey); (write('A'); gibi..) gibi kullanılabilir. Readkey ingilizcede okunan harf manasına gelir. Bu fonksyonu kullanırsak program kullanıcının bir tuşa basmasını bekler. Basılan tuşun değeri readkey fonsyonunun sonucu olur. Fonksyon kavramına daha sonra değineceğiz nasl olsa. Şimdilik bir kullanılışını anlatalım yeter. Daha önceden kullanıcıya Evet mi? Hayır mı? gibi bir soru sorarken readln(değişken); gibi bir komut kullanıyorduk. Bu durumda kullanıcı illa E'ye ya da H'ye basmak zorunda değildi. Ancak readkey komutuyla bunu sağlayabiliriz. En azından sadece 1 tek harfe basılmasının ardından (Enter'a basılmasını beklemeden) bir sonraki komuta geçilmesini sağlayabiliriz. Örnek:

Program Deneme;
Uses Crt;
Var
a:char;
Begin Clrscr;
writeln('Merhaba, Devam etmek için herhangi bir tuşa basınız...');
a:=readkey;
writeln('Tabrik ederim. Tuşa basmayı başardınız');
writeln('Programı bitirmek için bir tuşa daha ihtiyaç var..');
a:=readkey;
End.

Bu şekilde kullanmamızın belki faydası olmadı ama en azından readln; komutundan daha iyi. O zaman bir de basılan tuşu ekrana yazan programı yapalım. Aşağıdaki programı çalıştırıp bir harfe ya da rakama basın:

Program Denemedir;
Uses Crt;
Var
harf:char;
Begin Clrscr;
writeln('Bir Tuşa Bas hemen ya da birdaha gözüme gözükme!');
harf:=readkey;
clrscr;
writeln('Sizin bastığınız tuş: ', harf);
writeln('Programı bitirmek için bir tuşa basınız..');
harf:=readkey;
end.

Buralarda neden char tipinde değişken kullandığımızı anlamışsınızdır. Çünkü basılan yanlızca bir tek tuş. Şimdi char tipli değişkenin ne işe yaradığını daha iyi anlamış olduk. Şimdi de programdan çıkılması için mutlaka X'e basılmasını şart koşan bir program yapalım. Birkaç ders sonra bunu çok daha kısa yapacağız ama şimdilik bildiğimiz komutları kullanalım:

Program Deneme_3;
uses crt;
label
geri;
var
harf:char;
begin clrscr;
writeln('Merhabalar..');
writeln('Kusura bakmayin, programimizi erken kapatiyoruz..');
writeln('Programi bitirmek icin X harfine basiniz..');
geri:
harf:=readkey;
if not (harf in['x','X']) then goto geri;
writeln('Efferin, programi kapattın..');
end.

if deyimini bir sonraki derste anlattım. Şimdilik kafanızı yormayın. Dikkat etmeniz gereken label kullanımı ve readkey komutu olabilir. Özellikle label'e tekrar bakın, belki unutmuşsunuzdur. Şimdilik bu kadar yeter. İlerde zaten her programımızda kullanacağımız bir komut readkey...

GotoXY

Şimdiye kadar yaptığımız programlarda hep ekranın sol üst köşesinden başlayarak bilgileri yazdırdık. Ancak sizin de aklınıza "Yahu bu ekranın istediğimiz yerine birşeyler yazdıramaz mıyız?" sorusunuz geldiğini tahmin ediyorum. Pascal'da ekranın istenilen yerine gitmek için gotoxy komutu kullanılır. Gitmek'ten kastım imleci istenilen yere götürmektir. Zaten ekrana write ile birşeyler yazarken imlecin bulunduğu yerden itibaren yazıldığını söylemiştik.

Bu komutun kullanımı

gotoxy(X,Y);

şeklindedir. Burada X yerine kaçıncı kolona gidilmesi isteniyorsa o kolonun numarası, Y yerine ise kaçıncı satıra gidilmesi isteniyorsa o satırın numarası yazılır. Normal bir ekranda 80 kolon ve 24 satır (25'e çıkartılabilir) vardır. Gotoxy komutunu kullanırken buna dikkat etmelisiniz. Yani gotoxy(83,12); komutunu yazarsanız büyük olasılıkla istediğiniz görüntüyü elde edemezsiniz! Bu komut genelde write ifadesinden önce kullanılır. Zaten amacı da ekranın istenilen yerine yazı yazdırmak değil mi? Bir örnek yapalım:

Program git_bakalim;
uses crt;
begin clrscr;
gotoxy(30,13);write('www.universiteli.net');
readln;
end.

gotoxy(X,Y); komutunda X ve Y yerine değişken de koyabiliriz. Tabii ki bir tam sayı tipli değişken (byte, integer, longint.. gibi). Bu durumda değişkenin değeri neyse ona göre işlem yapılır. Mesela küçük bir program yapalım:

Program gid_hele;
uses crt;
var
x,y:byte;
ad:string;
begin clrscr;
write('Adınız: ');readln(ad);
write('X kordinatı: ');readln(x);
write('Y kordinatı: ');readln(y);
clrscr;
gotoxy(10,23);
write('Bu program Tolga Yüzüncü tarafından yapıldı!');
gotoxy(x,y);
write(ad);
readln;
end.

Gotoxy komutunu programlarımızın içinde sıkça kullanacağız.

Karşılaştırma ve Karar verme deyimleri

Programlamanın en zevkli yanı birşeyleri karşılaştırıp sonucuna göre bir işlem yapmak ya da yapmamaktır diyebilirim. Aslında programlama da zaten budur. Programlamaya ilk başlarken algoritmalar konusunda bir örnek vermiştik. Orada "Eğer hava yağmurluysa şemyiseni al" demiştik. Bu işlemi şimdiye kadar öğrendiğimiz komutlarla yaptırmamız olanaksızdır.

Karşılaştırma ve karar verme işlemleri olmasa program ilk satırından itibaren satır satır çalışır ve en sonunda "End." komutuyla biter. Yani program içerisinde belirli şartlarda programın akışı değiştirilemez. Pascal'da (ve neredeyse bütün programlama dillerinde ve scriptlerinde) kontrol deyimi if..then..else şeklindedir. Ayrıca Pascal'da başka kontrol deyimleri de vardır. If...then...else deyiminin genel kullanımı:

if (şart ya da şartlar) then
şart doğruysa yapılacak işlem
else
şart yanlışsa yapılacak işlem

gibidir. Tabii ki hepsi bir satırda da kullanılabilir. Ayrıca şartın doğru olması (ya da yanlış olması) durumunda birden çok işlem yaptırılmak isteniyorsa bu işlemlerin hepsi begin ile end arasına şu şekilde yazılır:

if (şart ya da şartlar) then begin
şart doğruysa yapılacak işlemler
end else
şart yanlışsa yapılacak işlemler
end;

begin ve end;'i birazdan anlatacağım. Şimdi çok basit bir örnek yapalım:

Program Deneme;
Uses Crt;
Var
notu:integer;
Begin Clrscr;
write('Matematik Dersinden Aldığınız Notu Giriniz: ');Readln(notu);
clrscr;
if notu>69 then write('Aferin Geçtiniz!') else write('Malesef Kaldınız!');
write(readkey);
end.

Bu program sınavdan aldığınız notu belirli bir işlemden geçiriyor ve sonucuna göre birşeyler yazdırıyor. Şimdi biraz daha ayrıntılı görelim. if komutuna kadar olan herşeyi daha önce gördük. Readln komutuyla sayısal bir bilgi olan sınav sonucu notu değişkenine aktarılıyor. Ondan sonra ekran siliniyor. Sonra şu komut var:

if notu>69 then write('Aferin Geçtiniz!') else write('Malesef Kaldınız!');

İlk önce bu komutla ne yapılmak istendiğine bakalım. Amaç eğer notu değişkeninin değeri 69'dan büyükse ekrana 'Aferin Geçtiniz!', eğer değilse (yani notu değişkeninin değeri 69'a eşit ya da daha küçükse) ekrana 'Malesef Kaldınız' yazdırmaktan ibarettir.

Yani bu komutun Türkçe meali:

Eğer notu değişkeninin değeri 69'dan büyük ise Aferin Geçtiniz! yaz, değilse Malesef Kaldınız! yaz.

notu>69 ifadesini parantez içerisine de yazabilirsiniz. Zaten birden fazla şart varsa parantez kullanmak mecburidir. Dikkat edin write('Aferin Geçtiniz!') ifadesinde noktalı virgül yok. Neden? Çünkü komut daha bitmedi. Derslerin başında "Pascal'da her komutun sonuna noktalı virgül konulur" demiştim.

Programlamada notu>69 ifadesinin değeri ya TRUE (doğru) olur ya da FALSE (yanlış). Burada notu'nun değeri 69'dan büyükse bu şart TRUE, değilse FALSE olur. Eğer Şart true ise THEN ifadesinden sonraki işlemler, eğer şartın sonucu false ise ELSE ifadesinden sonraki işlemler yapılır. Biraz düşünürseniz burada aslında else deyimi kullanılmadan da program yapılabilir.

Program Deneme;
Uses Crt;
Var
notu:integer;
Begin Clrscr;
write('Matematik Dersinden Aldığınız Notu Giriniz: ');Readln(notu);
clrscr;
if notu>=70 then write('Aferin Geçtiniz!');
if notu<70 then write('Malesef Kaldınız!');
write(readkey);
end.

Burada şartı 69 yerine 70 yaptık. Birşey farketmez. Maksat değişiklik olsun. Bu arada eğer write(readkey); de ne diyorsanız bir önceki konuya göz atın. Gördüğünüz gibi

if (notu>=70) then write('Aferin Geçtiniz!');
if (notu<70) then write('Malesef Kaldınız!');

ile

if (notu>=70) then write('Aferin Geçtiniz!') else write('Malesef Kaldınız!');

ifadeleri aynı işi yapıyorlar. Tabii ki else kullanmak daha mantıklı. if deyimine genel olarak anladıysak (ve kendimiz de biraz örnek yaptıysak) şimdi karşılaştırma işlemlerine bir göz atalım:

Buradaki doğru (True) ya da yanlış (False) kavramlarını belirtmiştim. Program akışı bunlara göre belirlenir. Şimdiye kadar öğrendiklerimizle bir öğrencinin Matematik dersinden 100 üzerinden aldığı sınav notunu 5'lik sisteme çeviren programı yapalım. Beşlik sistemin ne olduğunu biliyorsunuzdur:

0-44 arası 1
45-54 arası 2
55-69 arası 3
70-84 arası 4
85-100 arası 5

şeklindedir. Buradan öğrencilerin 5 alamamasına kızan velilere duyurulur. Şimdi programımızı yazalım:

Program Denemedir;
Uses Crt;
Var
yuzluk, beslik:byte;
Begin Clrscr;
write('Matematik sınavının sonucu (0 ile 100 arası)..: ');readln(yuzluk);
if yuzluk<=44 then beslik:=1;
if (yuzluk>=45) and (yuzluk<=54) then beslik:=2;
if (yuzluk>=55) and (yuzluk<=69) then beslik:=3;
if (yuzluk>=70) and (yuzluk<=84) then beslik:=4;
if yuzluk>=85 then beslik:=5;
clrscr;
writeln('Yüz üzerinden.....: ',yuzluk);
writeln('Beş üzerinden.....: ',beslik);
readln;
end.

Gördüğünüz gibi artık öğrenciler her sınavdan sonra aldıkları notun 5'lik sistemde kaça denk geldiğini kara kara düşünmeyecekler. Açacaklar programı yazacaklar notlarını, bilgisayar hesaplayacak Bu arada bu and kelimesinin nereden ve neden geldiğini anlatacağım, şimdiden paniğe kapılmayın.

Bu arada şimdiye kadar yaptığımız programlarımızı EXE yaptınız mı bilmiyorum. Eğer hala denemediyseniz bunu yapın mesela. Açın programınızı ve ilk derslerde anlattığı gibi exe yapın. Muhtelemen exe dosyanız pascal'ın bulunduğu dizinde oluşacaktır. Ordan bulabilirsiniz. Exe dosyanız oluştuğu halde bulamıyorsanız Başlat menüsünden Bul/Dosya ve Klasörler seçeneğinden dosya adını yazarak arayabilirsiniz. Dosyanızı nasıl exe yapacağınızı unuttuysanız. Programı exe yapmayı başardıysanız Windows'ta çift tıklayarak çalıştırabilirsiniz artık. If then else kalıbına genel bir giriş yaptık. Şidmi devam edelim

if then else kalıbının genel olarak "if (şart ya da şartlar) then begin işlemler.. end else begin işlemler.. end;" şeklinde olduğunu söyledik. Yani if ile birden çok şartı da sınayabiliriz. Aslında başta if kalıbının mantıksal karşılaştırma olduğunu söylemek gerekirdi ama zaten sizin anladığınızı sanıyorum. Yani siz bu if kalıbını kullanınca bilgisayara bir mantıksal karşılaştırma yaptırıyorsunuz. Bir önceki örneğimizde if ile birlikte iki şart kullandık. Şartımız şöyle idi:

if (notu>=55) and (notu<=69) then beslik:=3;

Burada and kelimesiyle (Türkçesi "ve" demektir) yanlızca iki şartın da doğru olduğu durumlarda bu işlemi yapmasını söylüyoruz. (Bu arada tahmin ettiğiniz gibi else'in kullanımı zorunlu değil.) Yukardaki şartın Türkçesi şöyledir:

Eğer notu değişkeninin değeri 55'ten büyük ya da 55'e eşit VE notu değişkeninin değeri 69'dan küçük ya da 69'a eşit ise beslik değişkeninin değerini 3 yap.

Burada >= ve <= kullandığımızdan cümle biraz karışık oldu. Başka bir örneği Türkçe'ye çevirelim. Örneğin;

if (notu>54) and (notu<70) then beslik:=3;

Kalıbının Türkçe'si daha sade olur ve yukardaki örnekle aslında aynı işi yapar (Sayılara dikkat ederseniz bunu görürsünüz):

Eğer notu 54'den büyük VE 70'den küçük ise beslik değişkeninin değerini 3 yap.

Yani burada aslında bilgisayara notu değişkeninin değerinin 55 ile 69 arasında olduğu durumlardan bahsediyoruz. Zaten notu değişkeninin değeri 54'den büyükse ve 70'den küçükse bunlardan başka bir sayı olamaz. Peki ilk derslerimizde öğrendiğimiz Set (yeni Küme) tipinde bir veri kullanarak bunu daha kısa ve anlaşılır olarak yapamaz mıyız. Mesela bilgisayara direk olarak "Eğer notu 55 ile 69 arasındaysa beslik değişkeninin değerini 3 yap" diyemez miyiz? Deminki örnekte And kullanmıştık, burdada Türkçesi içerisinde, içinde anlamında olan in kelimesini kullanacağız. Yani notu değişkeninin değerinin "55 ile 69 arasındaki tüm sayıları kapsayan bir küme" içerisinde olup olmadığını kontrol edeceğiz. Nasıl mı? İşte böyle:

if notu in [55..69] then beslik:=3;

Gördünüz mü ne kadar kısa ve anlaşılır oldu! Burada kümemiz [55..69] 'dur. Bunu daha önce anlatmıştık. Ama birazdan in ifadesiyle kullanımını özel olarak ele alacağız. Şimdi and ve in gibi diğer ifadelerin hepsine bir göz atalım:

In ifadesi bunların içerisine girmiyor. Zaten onu bir önceki sayfadaki tabloda vermiştik. Ayrıca bir de az kullanılan xor var ama ben şimdiye kadar onu hiç kullanmadım. Gerekirse ilerde anlatırız. Anlamı "veya değil"dir.

Şimdi çok kullanılan in ifadesinde kullanabileceğimiz kümeleri anlatmanın yeri geldi. Hani "ilerde yeri gelince anlatacağız" demiştik ya işte o yer bu yer. Küme'nin ne olduğunu az-çok biliyorsunuzdur. Zaten öğrenciyseniz matematiğe her sene kümelerden başlanmasına ve "İngilizce bilenlerle Fransızca bilenlerin toplamı kaçtır" türündeki saçma sapan problemlere alışmışsınızdır. Pascal'da küme (Matematikte olduğu gibi) benzer türde verilerin oluşturduğu ve aynı verinin (yani Matematikteki tabiri ile elemanın) en fazla bir defa kullanılabildiği ve üzerinde kesişim, birleşim gibi birsürü işlemin yapılabildiği elamanların tümüne denir. Mesela Sınıfınızdaki öğrencilerden bir küme oluşturabilirsiniz. Ondan sonra bir program yaparsınız ve girilen bir ismin sizin sınıfınızın içerisinde olup olmadığını kontrol edebilirsiniz. Bunu in ile yaparız. in ifadesinin sağına bir kümse soluna da bir eleman konulur.

 Eğer bu eleman kümenin içerisinde var ise sonuç doğru (true), yoksa haliyle sonuç da yanlış (false) olacaktır. Pascal'da kümenin elemanları kköşeli parantez içerisine yazılır. Örnek bir küme:

[1,2,3,4,5,6]

Bu küme 1'den 6'ya kadar olan tamsayılardan oluşuyor. Pascal'da bu tür sıralı olarak giden verileri daha kısa yazabilirsiniz. Mesela şu küme yukardaki le aynıdır:

[1..6]

Birden yüze kadar olan sayıları yapabileceğinizi düşününce eperyce bir kolaylık sağlar. Ama mesela kümseninin içerisinde bir de 9 bulunsun:

[1,2,3,4,5,6,9]

Bu durumda [1..9] yazarsanız olmaz, çünkü içerisinde 7 ve 8 de girer. Ama [1..6] yazarsanız da bu sefer 9 olmaz. O halde 9'u ayrıca yazmalısnız:

[1..6,9]

Hadi bir de kümemiz şöyle olsun:

[1,2,3,4,5,6,9,10,11,12]

Yani 1'den 12'ye kadar olan sayılardan 7 ve 8 yok. Bu durumda şöyle yapabiliriz:

[1..6,9..12]

Gördüğünüz gibi Pascal bize kolaylık sağlıyor. Hatta bu kümeyi iki küme şeklinde düşünüp ikisini toplasak da aynı olur. Burada toplamak birleştirmek manasındadır:

[1..6] + [9..12]

Tabii ki kümelerimiz sadece sayılardan oluşmayabilir. Harf ya da herhangi bir string ifade de olabilir. İşte size birkaç küme örneği:

['e','E','h','H']
['a','b','c','d','e','f','g','h','i']
['a'..'i']
['a'..'j','p','q','x'..'z']
['universite', 'www.universiteli.net','Ahmet','Osman','Nilgün']

Örnekleri siz de çoğaltabilirsiniz. Burada 2. örnekle 3. örneğin aynı olduğunu farketmişsinizdir. Şimdi bu kümeler üzerinde in metodunu kullanarak işlemler yapalım. Mesela ekrana "programdan çıkmak istiyor musunuz?" diye bir mesaj yazılsın ve eğer E tuşuna basılırsa programdan çıksın, h tuşuna basılırsa tekrar başa dönsün:

Program Denemedir;
Uses Crt;
Label
en_bas;
Var
a:longint;
tus:char;
Begin
a:=1;
en_bas:
Clrscr;
writeln('A nin su anki degeri: ',a);
a:=a+1;
writeln('Cikmak istiyor musunuz ( E -> Evet , H -> Hayir) ?');
tus:=readkey;
if tus in['h','H'] then goto en_bas;
end.

Gördüğünüz gibi burada h'ye basılıp basılmadığı kontrol ediliyor. Eğer basılmışsa başa gidiyor, başka bir tuşa basılmışsa program bitiyor. Eğer kullanıcının klavyesinin Caps Lock tuşu açıksa bastığı harf H, kapalıysa bastığı harf h (küçük h) olacaktır. Biz iki durumu da hesaba katıyoruz. Ama kullanıcı mesela s tuşuna basarsa da program biter. Bunu hesaba katmadık. İyi bir programcı herşeyi düşünür. Şu anda döngüleri bilmediğimizden kendi döngülerimizi label kullanarak goto  ile hallediyoruz. İlerde bu işler çok daha kolay olacak. Ama merak edenler için sadece E'ye basılınca programdan çıkan programı yapalım:

Program Denemedir;
Uses Crt;
Label
en_bas,yanlis_tus;
Var
a:longint;
tus:char;
Begin
a:=1;
en_bas:
Clrscr;
writeln('A nin su anki degeri: ',a);
a:=a+1;
writeln('Cikmak istiyor musunuz ( E -> Evet , H -> Hayir) ?');
yanlis_tus:
tus:=readkey;
if not (tus in ['h','H','e','E']) then goto yanlis_tus;
if tus in['h','H'] then goto en_bas;
end.

Programa eklediğimiz kodları kalın yazdım. Burada not operatörünün (Pascal dilinde böyle deniliyor) de kullanımına bir örnek vermiş olduk. not'un sağındaki değer yanlış ise sonuç doğru oluyor. Yani normalde basılan tuş E,e,H,h'den birisi ise sonuç doğru oluyordu ama başına not koyunca eğer tuş e,E,h ya da H ise sonuç yanlış, değilse sonuç doğru oluyor. Bunu küme olmadan yaptığımızı düşünelim. Kodumuz çok uzun olurdu:

if (tus<>'e') and (tus<>'E') and (tus<>'h') and (tus<>'H') then goto yanli_tus;

Yani tuş'un tek tek olmaması gereken harfleri belirmiş oluyoruz. <> ifadesinin eşit değil manasında olduğunu söylemiştik. Bir önceki programa göre eklediğimiz yerin ne iş yaptığını gördük. tus değişkeninin değeri ['h','H','e','E'] kümesinin içinde olana kadar bir sonraki adıma geçmiyor ve yanlis_tus label'inin (etiketinin) bulunduğu yere gidiyor.

Kümeleri anladığımıza ve birkaç örnek de kandimiz yaptığımıza göre(!) diğer operatörlere ve if..then..else kalıbı ile yapılmış başka örneklere geçebiliriz. Ama önce Begin-End bloklarını anlatmalıyız.

Pascal yapısal bir programlama dilidir ve bloklardan oluşur. Sınırsız sayısa iç içe blok olabilir. Bir blok begin ile başlar ve end ile sona erer. Pascal için bu begin ile end arasına yazılan kodlar bir bütün olarak düşünülür. Zaten her programın begin ile başlayıp end ile bittiğini gördük.

Daha önce if deyimini kullanmayı gördük ama THEN ifadesinden sonra sadece bir işlem yaptırabiliyorduk. Eğer belli bir şarta bağlı olarak birden çok işlem yaptırmak istiyorsak bu işlemleri begin ile end arasına almamız lazım. Yani:

if (şart ya da şartlar) then Begin
işlem 1
işlem 2
işlem 3
...
...
End;

şeklinde kullanırız. Bu durumda şart doğru ise bu işlemler yapılır, yanlış ise işlemlerin hiçbirisi yapılmadan en alttaki end; kelimesinden sonraki işlemden başlayarak programın akışı devam eder. Bu kalıbı else ile birlikte kullanacaksak;

if (şart ya da şartlar) then Begin
işlem 1
işlem 2
işlem 3
End else Begin
işlem 1
işlem 2
işlem 3
...
...
End;

şeklinde kullanırız. Tabii bunun gibi birkaç tane end arda arda kullanılında hangisi hangi begin'in karışabilir, daha doğrusu bilgisayar kesinlikle karıştırmaz ama siz daha sonra bakınca karıştırabilirsiniz. Daha önceden programın içerisine açıklama oymaya kısaca deyinmiştik. Yeri gelmişken onu da anlatalım.

Genelde uzun programlar yaptıktan sonra program içerisinde ne yaptığınızı ya da hangi değişkenin ne işe yaradığını falan unutabilirsiniz. Ya da 1 yıl önce yaptığınız programı açtığınızda "Ya bu program ne işe yarıyor" diyebilirsiniz. İyi bir programcı programın önemli gördüğü yerlerine kısa açıklamalar koyar. Bunlara daha sonra baktığında ne yaptığını hatırlamak için. Bu açıklamaları { ile } arasına ya da (* ile *) arasına yazmalısınız. Ben genelde süslü parantezi tercih ediyorum. Bu iki parantezin içerisine yazılan hiçbirşey (program kodu bile yazsanız) pascal tarafından dikkate alınmaz ve derlenmez. Yani buraya istediğiniz herşeyi yazabilirsiniz. İlerde yapacağımız programlarda bu tip açıklamalara ihtiyaç oldukça yer vereceğiz. Şimdi basit bir örnek daha yapalım:

Program Ornek_program;
{Bu program bir sayının karesini ve kökünü bulmak için yapıldı.
Yapılıs tarihi: 05.06.2002 Saat: 01:48}
Uses Crt;
Label
en_bas;
Var
sayi,kare:longint;
kok:real;
Begin {Program Başlıyor}
en_bas: Clrscr;
writeln('Programdan çıkmak için 1000''den büyük bir sayı yazın');
write('1 ile 1000 arası bir sayı giriniz: ');
readln(sayi); {Sayı isteniyor}
if (sayi<1001) and (sayi>0) then begin
kare:=sayi*sayi; {Karesi hesaplanıyor}
kok:=sqrt(sayi); {Kökü bulunuyor}
{Sonuçlar yazılmaya başlıyor...}
writeln('Bu sayının karesi:', kare:10);
writeln('Bu sayının kökü..:', kok:16:5);
{...sonuçlar yazıldı}
readln; {Enter'a basılması bekleniyor}
goto en_bas;
end; {if deyiminin sonu}
end. {Programın Sonu}

Pascal'da ekrana apostrof işareti ( ' ) yazmak için iki tane apostrof işaretini yan yana yazarız ( '' gibi..). Programda "writeln('Programdan çıkmak için 1000''den büyük bir sayı yazın');" komutuna bakabilirsiniz. Tek yazarsak Pascal'ın özel işareti olduğu için bizi uyarır. Burada hem begin..end; kalıbına hem de açıklamaya örnek(ler) var. İnceleyiniz.

Şimdi and, or ve not ifadelerini tek tek ve birlikte kullanan örnekler yapalım. İlk önce and ile ilgili basit bir örnek yapalım. Bu programı and'in kullanımına örnek olması için yapıyoruz. Yoksa program pek bir işe yaramaz:

Program and_ornegi;
Uses Crt;
Var
sayi1, sayi2 : integer;
Begin Clrscr;
writeln('Aşağıya 1 ile 10 arası 2 sayı giriniz');
write('Birinci Sayı:');Readln(sayi1);
write('İkinci Sayı:');Readln(sayi2);
clrscr;
if (sayi1 in[1..10]) and (sayi2 in[1..10]) then writeln('Sayıları doğru girdiniz')
else writeln('Sayıları Yanlış Girdiniz...');
readln;
end.

Programı TP'da yazıp çalıştırın ve birkaç sayı girin. Gördüğünüz gibi ancak sayıların ikisi de 1 ile 10 arasındaysa sonuç doğru oluyor, aksi halde (sayıların birisi bile 1 ile 10'un dışında olsa) sonuç yanlış oluyor. Çünkü VE (and) kullandık. Peki bunun yerine sayılardan en az birisinin 1 ile 10 arasında olmasını istesek ne yaparız. O zaman or (veya) kullanırız:

Program and_ornegi;
Uses Crt;
Var
sayi1, sayi2 : integer;
Begin Clrscr;
writeln('Aşağıya 1 ile 10 arası 2 sayı giriniz');
write('Birinci Sayı:');Readln(sayi1);
write('İkinci Sayı:');Readln(sayi2);
clrscr;
if (sayi1 in[1..10]) or (sayi2 in[1..10]) then writeln('Sayıları doğru girdiniz')
else writeln('Sayıları Yanlış Girdiniz...');
readln;
end.

Bu programı çalıştırdığınızda iki sayıdan birisini 1 ile 10 arasında girerseniz, diğerini ne girerseniz girin sonuç doğru olur. Eğer ikisi birden 1 ile 10 arasında değilse sonuç yanlış olur. Peki şimdi de and ile or'u birlikte kullanarak kullanıcıdan 1,2,3,4,5,11 sayılarından birisini yazmasını isteyelim. Eğer bu yazılan iki sayı da bu sayıların içindeyse sonuçta doğru yazsın, birisi bile bu sayıların dışındaysa sonuçta yanlış yazsın:

Program and_ornegi;
Uses Crt;
Var
sayi1, sayi2 : integer;
Begin Clrscr;
writeln('Aşağıya 1,2,3,4,5,11 sayılarından birisi olmak şartıyla 2 sayı giriniz');
write('Birinci Sayı:');Readln(sayi1);
write('İkinci Sayı:');Readln(sayi2);
clrscr;
if ((sayi1 in[1..5]) or (sayi1=11)) and ((sayi2 in[1..10]) or (sayi2=11)) then writeln('Sayıları doğru girdiniz')
else writeln('Sayıları Yanlış Girdiniz...');
readln;
end.

Burada ilk önce sayi1'in 1 ile 5 arasında olup olmadığına bakılır. Eğer doğruysa zaten and kelimesinin solundaki iki şartı kapsayan şart doğru olur. Yani sayı ya 1 ile 5 arasındadır, ya da 11'dir. Eğer sayı1 1 ile 5 arasında değilse şart yanlış olur ama bir de or'un sağındakine bakılır. Eğer sayı 11'e eşitse bu şart doğru (true) olacağından yine genel şart doğru olur. Bu durumda and kelimesinin solundaki şart doğru olmuş olur. Eğer and'in solundaki iki şart da yanlış ise sonuç otomatikmen yanlış olur. Sağ taraf için de (sayi2 için) aynı işlemler yapıldıktan sonra eğer genel şart doğruysa sonuç doğru olur. Kendiniz birkaç örnek yaparak bunları görebilirsiniz.

Şimdi basit bir örnek daha yapalım. Bu program kullanıcıya bir toplama işlemi sorsun. Eğer kullanıcı sonucu doğru girerse "Tebrikler, bildiniz" yazsın, aksi halde doğru sonucu ekrana yazsın. Yani ilk defa ciddi bir program yapıyoruz

Program Toplama_Programi;
Uses Crt;
var
s1,s2:integer;
toplam:integer;
Begin Clrscr;
{Rastgele iki sayi seciliyor...}
randomize;
s1:=random(100);
s2:=random(100);
{...0 ile 99 arasinda rastgele 2 sayi secildi}
writeln('Asagidaki toplama isleminin sonucunu yaziniz...');
writeln;
write(s1,' + ',s2,' = ');readln(toplam);
if (toplam=s1+s2) then writeln('Tebrikler, bildiniz...')
else writeln('Yanlis Sonuc! Cevap ',s1+s2,' olmaliydi.');
readln;
end.

Gördüğünüz gibi if deyiminde şart olarak iki sayının toplamını da verebiliriz. Hatta başka işlemler bile yapabiliriz. Mesela şart olarak (toplam=(s1*21)/(s2+4)*11+9-s2*s1) gibi uzun bir aritmetik işlem birle yazabiliriz. Ayriyete eşittir işaretinin sağ ile solu yer değiştirebilir. ((s1*21)/(s2+4)*11+9-s2*s1=toplam) gibi. Buralarda parantezlere dikkat etmelisiniz. Şimdilik rastgele sayının nasıl bulunduğunu öğrenmedik. Onun için o kısımları kafanıza takmayın. Yukardaki örnekte and ya da or kullanmadık ama faydalı bir program olduğunu düşünüyorum. Not operatörü ise sonuç doğru ise yanlış, yanlış ise doğru yapar. Bununla ilgili bir program yapmıştık ama daha iyi anlaşılması için basit bir örnek daha yapalım. Bu program da 1 ile 5 arasında bir sayı yazılmasını istesin. Eğer sayı 1 ile 5 arasında ise doğru, değilse yanlış yazsın:

Program deneme;
uses crt;
var
sayi:integer;
begin clrscr;
write('1 ile 5 arası bir sayı giriniz: ');readln(sayi);
if not (sayi in [1..5]) then writeln('Yanlış!') else writeln('Doğru.');
readln;
end.

Programlamada karşılaştırma ve (sonucuna göre) karar verme işlemleri çok önemli ve geniş kullanımlıdır. Diğer kullanım alanlarını görmeye devam edeceğiz. Ama önce şimdiye kadar pascal hakkında öğrendiklerimizin hepsini birden kullanan ve nihayet bir işe yarayan bir oyun yapalım. Bu oyunda bilgisayar 1 ile 1000 arasında rastgele bir sayı tutsun. Biz bir tahmin yapalım. Eğer tahminimiz bilgisayarın tuttuğu sayıdan küçükse ekrana ÇIK, küçükse İN yazılsın ve bu işlemler biz sayıyı doğru tahmin edene kadar sürsün. Hani bir oyun yapıyoruz ya -hiç gerek yok ama- bir de algoritmasını yapalım ki belki daha iyi anlaşılır. Algoritmamız şöyle olabilir:

1) Rastgele (1 ile 1000 arası) bir sayı tut.
2) Kullanıcıya bir sayı sor.
3) Eğer kullanıcının cevabı senin tuttuğun sayıdan büyükse ekrana "in" yaz.
4) Eğer kullanıcının cevabı senin tuttuğun sayıdan küçükse ekrana "çık" yaz.
5) Eğer kullanıcının cevabı senin tuttuğun sayıya eşitse ekrana "Aferin Bildin!" yaz.
6) Eğer kullanıcının cevabı senin tuttuğun sayıya eşit değilse 2. adıma git.
7) Programı bitir.

Bu algoritmayı kendinize göre yapabilirsiniz tabii. Zaten programcılığın en zevkli yanlarından birisi de aynı programı yapmak için çok fazla seçeneğiniz ve çözüm yolunuz olmasıdır. Şimdi de programı yazalım. Programımız şöyle olabilir:

Program Tahmin_et_bakalim;
uses crt;
label en_bas;
var
sayi, tahmin, ts : integer;
begin clrscr;
ts:=0;
randomize;
sayi:=random(1000)+1;
gotoxy(1,1);write('1 ile 1000 arasi bir sayi giriniz...');
gotoxy(1,5);write('İşlem: ');
en_bas:
gotoxy(13,3);write(' '); {Eski tahmini ekrandan siliyoruz}
gotoxy(1,3);write('Tahmininiz: ');readln(tahmin); {bir tahmin isteniyor}
ts:=ts+1; {Tahmin sayısı artırılıyor}

gotoxy(8,5);
if tahmin<sayi then write('Çık');
if sayi<tahmin then write('İn ');
if sayi=tahmin then begin
writeln('Aferin Bildin!');
writeln('Tahmin Sayısı: ',ts);
end else goto en_bas; {tahmin yanlışsa başa gidiliyor}

readln;
end.

Programı TP'da yazıp çalıştırın. İşte size güzel bir oyun! Programda asıl dikkat etmemiz gereken yerleri kalın yaptım. İsterseniz size bu oyunu geliştirelim ve bu sefer biz içimizden bir sayı tutalım, bilgisayar bulsun! O zaman aşağıdaki programı pascal'da yazıp çalıştırın ve sonra da satır satır inceleyin. Ama programı çalıştırdığınızda hile yapmayın. Yani aklınızdan tuttuğunuz sayı 430 ise ve program 420'yi tahmin ederse in demek yok! Ona göre. Bu programı Pascal'da elinizle yazın. Yani kopyala/yapıştır yapmayın. O zaman daha kolay öğrenirsiniz.

Program Tahmin_et_bakalim;
uses crt;
label en_bas;
var
tahmin, ts : integer;
alt,ust:integer;
tus:char;
begin clrscr;
writeln('Şimdi aklınızdan bir sayı tutun ve eğer benim söylediğim sayı');
writeln('sizin tuttuğunuz sayıdan küçükse çık anlamında "ç" harfine, büyükse');
writeln('in anlamındaki "i" harfine bir defa basın.');
writeln;
writeln('Not: Sayı 1 ile 100 arasında olmalı!');
writeln;
writeln('Hazırsanız Enter''a basın..');
readln;
clrscr;
alt:=1;
ust:=1000;
ts:=0;
gotoxy(1,1);write('Benim Tahminim...: ');
gotoxy(1,3);write('Ne yapıyım (i/ç).: ');
tahmin:=500;
en_bas:
gotoxy(20,1);write(tahmin);
gotoxy(20,3);
repeat
tus:=readkey;
until tus in['i','İ','ç','Ç','D','d'];
if tus in['i','İ'] then begin
ust:=tahmin;
tahmin:=(alt+ust) div 2;
end;
if tus in['ç','Ç'] then begin
alt:=tahmin;
tahmin:=(alt+ust) div 2;
end;
ts:=ts+1;
if tus in['d','D'] then begin
gotoxy(1,5);write('Aferin Bana!');
gotoxy(1,6);write('Tahmin Sayım: ',ts);
end else goto en_bas;
readln;
end.

Burada bilmediğimiz iki şey var. Birincisi repeat...until döngüsü. İkincisi div işlemi. Div (İngilizcesi division) bölmek manasındadır ve solundaki sayıyı sağındaki sayıya bölüm küsüratı atar. Yani mesela 6 div 3 = 2'dir ve 15 div 4 = 3'dür. Döngüler konusunu anlatacağız. Programın çalışma mantığı gayet basit. Ama yeni programlamaya başlayan birisine karışık gelebilir. Program siz in dediğinizde kendi kendine "Demek ki sayı bundan küçük, o zaman bundan sonra en fazla söyleyeceğim sayı bu olsun, yani üst limit bu olsun" diyor ve ust:=tahmin ifadesi ile de bunu yapıyor. alt'ın da mantığı aynı. Tahminini yaparken de alt ve ust değişkenlerini topluyor ve ikiye bölüyor. Programı çalıştırdığınızda farketmişsinizdir zaten. İlk tahmin hep 500 oluyor. Ondan sonra in derseniz 250, çık derseniz 750 oluyor... Tahmin sayısının nasıl hesaplandığı da gayet basit. Her sayı tahmininde tahmin sayısı bir artırılıyor.

İf kalıbını kullanırken hani dedik ya eğer şart (ya da şartlar) doğruysa işlem yapılır. Bir de programlama'ya başlarken veri tiplerinden bahsederken boolean diye bir tipi kısaca ele almıştık ve sonra anlatacağız demiştik. Şimdi boolean değişkenlerin kullanımına bakalım.

Daha önceden de dediğimiz gibi boolean değişkenin değeri ya TRUE (doğru) ya da FALSE (yanlış) olur. if ifadesinde de sonuç ya doğru ya da yanlış oluyordu. İşte if ifadesinde şart yerine boolean bir değişken kullanırsak program daha anlaşılır olabilir. Özellikle uzun programlarda çok işe yaradığını söyleyebilirim. İlk önce sadece nasıl kullanıldığına bakmak için bir örnek yapalım:

Program Mantiksal_Degisken;
uses crt;
var
YazilsinMi: boolean;
begin clrscr;
yazilsinmi:=true;
if yazilsinmi=true then write('Yazı Yazılıyor...');
readln;
end.

Aslında bu şekilde kullanıldığında pek bir anlamı kalmıyor. Boolean değişkenler özel olarak şöyle kullanılabilir:

Program Mantiksal_Degisken2;
uses crt;
var
YazilsinMi: boolean;
begin clrscr;
yazilsinmi:=true;
if yazilsinmi then write('Yazı Yazılıyor...');
readln;
end.

Gördüğünüz gibi bir karşılaştırma yok. Burada if deyimine dikkat edin. Eğer yazilsinmi değişkeninin değeri true ise sonuç doğru oluyor ve yazılıyor, değeri false ise sonuç da yanlış (false) oluyor ve program hiçbirşey yapmadan kapanıyor. İsterseniz yazilsinmi:=true yerine yazilsinmi:=false yazıp tekrar deneyin. Genelde boolean değişkenlere böyle direkt olarak yazilsinmi:=true; gibi değer atanmaz. Şimdi birkaç farklı atama yöntemine bakalım. Aslına yazilsinmi:= ifadesinin sağına sonucu true ya da false olabilecek herşey yazılabilir. Mesela iki tane boolean değişkenimiz varsa ve birisinin adı a diğerinin b ise;

a:=b;
ya da
b:=a;

gibi işlemleri yapabiliriz. Ayrıca if ile kullandığımız bütün operatörleri (=, <, >, <>, in, and, or, not) burada da kullanabiliriz. Mesela yine a ve b boolean değişkenleri için;

a:= not a;

kullanırsak a'nın değerini tersine çevirmiş oluruz. Yani a önceden true ise artık false, önceden false ise artık true olmuştur. Tabii ki a:=not b; de kullanılabilir. Mesela sayi diye bir değişkenimiz olsun. Eğer bu değişkenin değeri 5 ise dogruMu adlı boolean değişkenimizin değerinin true, aksi halde false olmasını isteyebiliriz.

Program deneme;
uses crt;
var
sayi:integer;
dogruMu:boolean;
begin clrscr;
write('Bir sayı giriniz: ');readln(sayi);
dogruMu:= (sayi=5);
if dogrumu then writeln('Aferin doğru') else write('Malesef yanlış');
readln;
end.

Burada sayi'nin 5'e eşit olması halinde sonuç doğru (true), yoksa yanlış (false) olacaktır. Eğer sayının 1 ile 30 arasında olmasını istiyorsak dogrumu:=(sayi=5); satırını dogrumu:=(sayi in[1..30]) olarak değiştirebiliriz. Ya da sayının 3'e veya 8'e eşit olması durumunda sonucun doğru olmasını istiyorsak dogrumu:=(sayi=3) or (sayi=8); kullanabiliriz. Anlayacağınız if'deki şartlarda ne yapıyorsak burada da aynısını yapabiliriz. Mesela boolean bir değişken kullanarak 1 ile 30 arasındaki tek sayıları ekrana yazdıran bir program yapalım:

Program Mantiksal_Degisken3;

Uses Crt;
label
tekrar;
var
sayi:byte;
tekMi, devamMi:boolean;
begin clrscr;
tekMi:=true;
devamMi:=true;
sayi:=1;
tekrar:
if tekmi then writeln(sayi);
sayi:=sayi+1;
tekMi := not TekMi;
devammi:= not (sayi=30);
if devamMi then goto tekrar;
readln;
end. {Program Sonu}

Programı yazıp çalıştırdığınızda 1 ile 30 arasındaki tek sayılar ekrana sırayla yazılır ve Enter'a basılması beklenir. Sadece tek sayıların yazılmasını tekmi değişenini bir true bir false yaparak sağlıyoruz. True ise yazılıyor, false ise yazılmıyor. Ayrıca devammi değişkeni de sayının 30 olmadığı durumlarda doğru, 30 olduğu durumda yanlış olur. Ve yanlış olunca, yani sayı 30 olunca en sondaki if ifadesi doğru olur ve program sona erer.

Eğer şimdiye kadar anlamadığınız birşey yoksa ve kendiniz de biraz örnek yaptıysanız artık baya bir Pascal biliyorsunuz demektir. Şimdiye kadar iyi bir program yapamamamızın sebebi daha döngülere girmememizden kaynaklanıyor. if kalıbını anlattık ama Pascal'da sadece karar verme komutu if değildir. Bir de Case-of deyimi var ki bazı durumlarda if'e göre çok daha kısa kod ile aynı işi yapmanızı sağlar. Ayrıca kullanımı da çok basittir. Mesela bir değişkenimiz var ve bu değişkenin aldığı 10 tane değişik değer için 10 ayrı işlem yaptırmak istiyoruz. Bunu if ile yapmak hem çok uzun olur hem de hata yapma şansımız yüksek olur. Ama Case of kullanırsak çok daha anlaşılır ve kısa yapabiliriz. Case'in genel kullanımı şöyledir:

Case değişken of
değer 1 : işlem 1;
değer 2 : işlem 2;
değer 3 : işlem 3;
...
...
End;

Tabii yine if'de (ve Pascal'ın heryerinde) olduğu gibi birden çok işlem yaptıracaksak begin ile and arasına alırız. Şunun gibi:

Case değişken of
değer 1 : begin
işlemler...
end;
değer 2 : begin
işlemler...
end;
...
...
end;

Ayrıca birden çok değer için bir işlem yapılacaksa şöyle kullanılır:

Case değişken of
değer 1, değer 2, değer 3 : işlem 1;
değer 4 : işlem 2;
değer 5, değer 6 : işlem 3;
End;

Şimdi güzel bir program yapalım. Kullanıcıdan bir sayı istesin ve ekranda bir menü olsun. Seçime göre belirli işlemler yapılsın. Programı yazmaya başlayalım:

Program Mantiksal_Sorgulama3;
Uses Crt;
Label
en_bas;
var
sayi:longint;
secim:char;
cikis:boolean;
begin clrscr;
cikis:=false;
write('1 ile 1000 arası bir sayı giriniz: ');readln(sayi);
en_bas:
clrscr;
gotoxy(30,8);write('::: Menü :::');
gotoxy(30,10);write('[1] Sayının Karesini yaz');
gotoxy(30,11);write('[2] Sayının Karekökünü yaz');
gotoxy(30,12);write('[3] Sayının Kübünü yaz');
gotoxy(30,13);write('[4] Programdan çık');
gotoxy(20,18);write('Seçiminizin önündeki sayıya basınız');
gotoxy(30,15);write('Seçiminiz: ');
secim:=readkey;
case secim of
'1': begin
clrscr;
gotoxy(30,10);
write(sayi,'''nin Karesi= ',sayi*sayi);
secim:=readkey;
end;
'2': begin
clrscr;
gotoxy(30,10);
write(sayi,'''nin Karekökü= ',sqrt(sayi):10:4);
secim:=readkey;
end;
'3': begin
clrscr;
gotoxy(30,10);
write(sayi,'''nin Kübü= ',sayi*sayi*sayi);
secim:=readkey;
end;
'4': cikis:=true;
end; {Case'in sonu}
if (not cikis) then goto en_bas;
clrscr;
writeln('Güle Güle... writen by www.universiteli.net');
end.

Gördüğünüz gibi secim:=readkey; komutuyla bir tuşa basılmasını bekliyor ve case secim of ile de bu tuşun '1', '2', '3' veya '4' olması durumunda yapılacak işlemler belirtiliyor. '4' olması durumunda cikis:=true ile cikis isimli boolean değişeknin değeri true oluyor. if (not cikis) then goto en_bas; ile de eğer cikis'in değeri false ise (ki '4'e basılmadıkça hep false olur, çünkü programın başında false yaptık) en_nas; labelinin olduğu yere gidiyor. Dolayısıyla da true olunca programdan çıkılmış oluyor. Artık programlarımızda menü yapmaya da bir örnek vermiş olduk. Tabii hareketli menü yapmayı da anlatacağız ama o daha çok ilerde.. Bu örnek karışık geldiyse konunun daha iyi anlaşılması için basit bir örnek daha yapalım:

Program Mantiksal_sorgulama;
Uses Crt;
var
sayi:longint;
begin clrscr;
write('Bir Sayı Giriniz: ');readln(sayi);
case sayi of
0..9: writeln('Bu sayı 1 basamaklıdır');
10..99: writeln('Bu sayı 2 basamaklıdır');
100..999: writeln('Bu sayı 3 basamaklıdır');
else writeln('Bu sayı 3''den çok basamaklıdır');
end;{Case'in sonu}
end.

Burda case ile birlikte else'in de kullanımını gördük. Eğer case ile belirttiğimiz hiçbir şart doğru değilse bir işlem yapmasını isteyebiliriz. Bu durumda bütün şartların sonuna else.. koyarız. Yine case kullanırken iki nokta üst üste (:) işaretinin soluna araya virgül koyarak birden çok şart da koyabilirsiniz.

case sayi of
13, 17, 4, 10, 9: writeln('Bu sayı benim sevdiğim sayılardan birisidir!');
else writeln('Bu sayıları hiç sevmem ');
end;

gibi.. Case komutunu genelde bir değişkenin birden çok sonucuna göre farklı işlemler yaptırmak istediğinizde kullanabilirsiniz. Dikkat etmeniz gereken case degisken of kalıbında belirttiğiniz değişken ile alabileceği değerlerin aynı tipte olmasıdır. Yani değişken sayı tipindeyse herhalde değeri 'D' olamaz! Ya da char tipindeyse değeri 5 olamaz, '5' olabilir. İkisinin arasındaki farkı anlatmıştım. Önceki sayı, sonraki karakterdir.

Pascal'da (ve diğer bütün programlama dillerinde) iç içe istediğiniz kadar if kullanabilirsiniz. Mesela:

if a>b then begin
if a=0 then writeln('B 0''dan küçük');
if b=0 then writeln('A 0''dan büyük');
end; gibi olabilir. Ya da aşağıdaki 3 if deyimi aynı işi yapar:

1)
if a>1 then begin
if a<7 then writeln('A değişkeninin değeri 1 ile 7 arasındadır.');
end;

2)
if a>1 then if a<7 then writeln('A değişkeninin değeri 1 ile 7 arasındadır.');

3)
if (a>1) and (a<7) then writeln('A değişkeninin değeri 1 ile 7 arasındadır.');

Programcı siz olduğunuza göre (ve amaç problemi en basit ve kısa yoldan çözmek olduğuna göre) hangisini kullanacağınıza karar vermek size kalmış. 2. örnekte if a>1 then ifadesinden sonraki mavi yazılı yerin tamamı bir komuttur. Bunu daha önceden söylemiştik. Öyleyse then'den sonraki komut bu olabilir. Burada iç içe iki if kullanılmıştır.

Pascal'da olan iki karşılaştırma deyimini (if ve case) gördük. Bunlar üzerinde istediğiniz kadar iç içe ve  birlikte kullanımlar yapabilirsiniz. Bol bol örnek yapmanızı tavsiye ederim. Son olarak if deyiminde (ve boolean değişkenlerde) kullanılan mantık işlemlerive göz atalım. Yani "doğru ve doğru" nun sonucu doğru, "doğru ve yanlış" ın sonucu yanlış, "yanlış veya doğru" nun sonucu doğru gibi.. Birkaç örnek yapalım ve bunları tablo olarak verelim ve en son da uzun bir örneği açıklayalım ki kafalarda soru işareti (?) kalmasın!

Yukardaki tabloya göre ne kadar karışık olursa olsun her işlem önce parantez içleri yapılarak basite indirgenip çözülebilir. Lise'deki mantık dersi iyi olan arkadaşlar daha kolay yapabilirler. Bilmeyenler için kelimelerin anlamını da toplu olarak birkez daha verelim:

Şimdi size biraz uzun ve karışık gelen bir problemin sonucunun true mi yoksa false mi olduğunu bulalalım:

if (((true and false) or (true or true)) and ((false or true) and (true or false) and (true and true))) or false then..

İlk önce parantez içerisinde başlayalım. İlk kalın olan yerin sonucu false olduğundan bunun yerine false koyup ikinci adıma geçelim:

if ((false or (true or true)) and ((false or true) and (true or false) and (true and true))) or false then..

Şimdi kalın olan yerin değerinin de true olduğunu biliyoruz. Onun yerine de true yazalım. Sonuç şöyle olur:

if ((false or true) and ((false or true) and (true or false) and (true and true))) or false then..

İşlem biraz kısaldı. Şimdi kalın olan yere bakalım. Değerinin true olduğunu biliyoruz. Son durum şöyle oldu:

if ((false or true) and (true and (true or false) and (true and true))) or false then..

Şimdiki kalın yazılı yerin değeri de true olduğundan yerine yazalım:

if ((false or true) and (true and true and (true and true))) or false then..

Bu seferki kalın yerin anlamı da true olduğundan son durum şu olur:

if ((false or true) and (true and true and true)) or false then..

Bu kalın yazılı yerin anlamı da true olur:

if (true and (true and true and true)) or false then..

Bu seferkinin anlamı da true olur. Çünkü 3'ü de doğrudur. Birisi yanlış olsa false olurdu. Sonuçta durum şöyle oldu:

if (true and true) or false then..

Artık işlem çok basit:

if (true or false) then..

Bu zaten tablomuzda direk verimişti Sonuç doğru (TRUE) olur:

if true then...

Demek ki ilk durumdaki if deyiminin sonucu true imiş ve eğer then'den sonra bir işlem varsa gerçekleşir. Tabii siz programlarınızda direk olarak true false diye yazmayacaksınız. Bunun yerine sonucu true ya da false olabilecek karşılaştırmalar (ya da boolean değişkenler) kullanacaksınız. Ayrıca size böyle şeyleri de düşünmeyeceksiniz aslında. Program bulacak sonucun ne olduğunuz. Ama siz programı yazarken ne istediğinizi bildiğinizden if kalıbını siz kuruacaksınız. Bu durumda bilgisayarın ne düşüneceğini ya da ne yapacağını bilmeniz iyi olur. Özellikle parantezlere dikkat edin. Eğer parantezler farklı olursa sonuc farklı olabilir.