VBScript’de Program Kontrolü

İster Script diliyle, ister gerçek programlama diliyle yazılsın, bir bilgisayar programının varlık
sebebi, çeşitli durumları değerlendirerek, belirli durumlarda belirli kararlar verebilmesidir.
Bunu programın kontrol öğelerini kullanarak yaparız. Programlar, bu öğeler sayesinde
karşılaştırma yaparlar; belirli durumların oluşup oluşmadığını sınarlar; veya belirli bir durumun
oluşmasına veya sona ermesine bağlı olarak bir iş yaparlar veya yapmazlar. Bunu sınamalarla
(koşullu ifadelerle) veya döngülerle sağlarız. Kimi zaman da, programa (programın mantığı
çerçevesinde) istediğimiz anda yapmakta olduğu işi durdurarak, başka bir işi yapmasını
bildirebiliriz. Bunlara da Süreçler (veya Prosedürler) denir. (Adındaki Basic’e bakarak,
VBScript’i basit bir dil sanmıyordunuz, umarım!)
Mantıksal Sınamalar

VBScript’te programın karar vermesini sağlayan ilk kontrol ögesini “eğer ... ise... yap!”
şeklinde özetleyebiliriz. VBScript bu işlemi iki ayrı ifadeyle yaparız:
If.. Else
VBScript’in vereceğiniz bir durumun bulunup bulunmadığını sınamasını sağlar. Genel yazım
kuralı şöyledir:
If şart Then
[şart doğru ise yapılacak işler]
Else
[şart doğru değilse yapılacak işler]
End If
Bunu bir örnekle ifade edelim: Eğer saat 12’den önce ise sayfaya “Günaydın” yazdır; saat
12’den sonra ise “Tünaydın” yazdır.
Fakat burada bir eksiklik var: Saat 18’den sonra ise sayfaya “İyi akşamlar!” yazdırmamız daha
doğru olmaz mı? If döngüsü kendi içinde sınırsız Elseif (ikinci şartlı döngü) imkanı vererek
bize bunu sağlar. Her Elseif’i yeni bir If gibi düşünebilirsiniz. İşte şu senaryoyu
gerçekleştirecek kod örneği (hosgeldiniz01.asp):
<HTML>
<HEAD>
<TITLE>ASP ILE SAATE GORE SELAM</TITLE>
<META http-equiv="content-type" content="text/html; charset=ISO-8859-9">
<META http-equiv="Content-Type" content="text/html; charset=windows-1254">
</HEAD>
<BODY>
<H2>
<CENTER>
<%
If Hour(Now) <12 Then
Response.Write "Günaydın! "
ElseIf Hour(Now) >= 18 Then
Response.Write "İyi akşamlar! "
Else
Response.Write "Tünaydın! "
End If
Response.Write "<BR>"
Response.Write "Site Onarım Sitesine Hoşgeldiniz"
%>
</CENTER>
</H2>
</BODY>
</HTML>
Bu programı çalıştırdığınız zaman, çalıştırdığınız saate göre sayfadaki selamın değiştiğini
göreceksiniz. (Bu örnekte, sadece şartlı döngü işlemi yapmıyoruz; fakat aynı zamanda
Hour(Now) fonksiyonu ile tanışıyoruz ve sayfadaki bütün unsurları ASP yöntemiyle
yazdırıyoruz! Fakat şimdilik bu iki unsurun üzerinde de durmayın.) Programımız nasıl
çalışıyor? Yukarıda başka vesile ile VBScript’in kullanılmaya hazır fonksiyonları vardır,
demiştik. Bunlardan biri de o andaki saati ve tarihi bildiren Now() fonksiyonudur. Bu
fonksiyondan dönen değerle bu andaki saati öğreniyoruz; ve bunu önce 12 ile karşılaştırıyoruz.
Fonksiyondan dönen değer, eğer 12’den küçükse, programımız Response (Karşılık)
Nesnesi’nin .Write Metodu’nu kullanarak (Nesneler ve Metodlar meselesi üzerinde de
durmayın!) ziyaretçinin Browser penceresine “Günaydın” yazdırıyor.
Dönen Değer
Fonksiyonlar, kendilerini göreve çağıran VBScript komutlarına ve işlemlerine bir değer
sunarak karşılık verirler. Buna fonksiyondan dönen değer denir. Yani diyelim ki Now()
fonksiyonunu göreve çağırdınız. Bu fonksiyon derhal işletim sisteminden saati ve tarihi
öğrenerek kendisini göreve çağıran işleme bildirir. Daha sonra VBScript’in kullanılmaya hazır
diğer bir çok fonksiyonunu kullanacağız ve kendi fonksiyonlarımızı yazacağız. Ne zaman bir
fonksiyona bir noktada atıf yaparsak, o noktaya fonksiyon tarafından bir değer getirileceğini
bimemiz gerekir.
////////////////KUTU BİTTİ////////
Eğer bu ilk sınamanın sonucu doğru değilse, VBScript If satırından sonraki birinci deyimi
atlayacak ve ikinci deyimi icra edecektir. Yani eğer saat 12’den küçük değilse, ElseIf satırı icra
edilecektir. ElseIf de tıpkı If gibi işlediği için bu kez yeni bir sınav yapılacak ve saatin 18’e eşit
veya büyük olup olmadığı sınanacaktır. Eğer saat 18’e eşit veya büyükse, (sınav sonucu doğru
ise) ilk satır icra edilecek ve ziyaretçinin Browser penceresine “İyi akşamlar!” yazdırılacaktır.
Eğer bu sınavın sonucu da doğru değilse, ElseIf’in ikinci satırı icra edilecektir. Bu satırda ise
Else bulunuyor. Else, If ve ElseIf gibi sınav yapmaz; ne olursa olsun, kendisinden sonra gelen
deyimi yerine getirir. Yani saat 12’den küçük değilse, 18’den küçük veya 18’e eşit değilse,
yani 12 ile 17 arasında ise, ekrana “Tünaydın” yazılacaktır.
Select Case
VBScript’in bir diğer duruma bakarak karar verme ifadesi, Select Case (Durum Seç) yapısıdır.
Bu kontrol öğesinin nasıl çalıştığını şöyle özetleyebiliriz:
Durum Seç (Durumların listesi veya durumları belirten bir değişken)
Durum 1 : Yapılacak işler
Durum 2: Yapılacak işler
Durum 3: Yapılacak işler
Durum n: Yapılacak işler
Seçmeyi Bitir
VBScript, verdiğiniz durum listesine veya içinde çeşitli değerler bulunan değişkene bakarak,
bu değişkenin her bir değerini bir “durum” sayacak ve verdiğiniz durumlardan hangisini
tutuyorsa, ona ait komut dizisini icra edecektir. Yukarıdaki sayfamızı bu kez bu yapıyı
kullanarak yazalım (hosgeldiniz02.asp):
<HTML>
<HEAD>
<TITLE>ASP ILE SAATE GÖRE SELAM</TITLE>
<META http-equiv="content-type" content="text/html; charset=ISO-8859-9">
<META http-equiv="Content-Type" content="text/html; charset=windows-1254">
</HEAD>
<BODY>
<H2>
<CENTER>
<%
Select Case Hour(Now)
Case 0,1,2,3,4,5,6,7,8,9,10,11
Response.Write "Günaydın!"
Case 12,13,14,15,16,17
Response.Write "Tünaydın"
Case Else
Response.Write "İyi Akşamlar!"
End Select
Response.Write "<BR>"
Response.Write "Site Onarım Sitesine Hoşgeldiniz"
%>
</CENTER>
</H2>
</BODY>
</HTML>
Select Case komutuna, içindeki değerleri “durum” sayacağı dizi veya değişken olarak
VBScript’in kullanılmaya hazır fonksiyonlarından Hour(Now)’ı veriyoruz. Bu fonksiyondan, 0
ile 24 arasında bir değer dönecektir. Bu değer Select Case için bir durum demektir. Select
Case, bu değer ile altta sıralanan Case’leri karşılaştıracak ve elindeki değer hangi Case’i
tutuyorsa ona ait komutları icra edecektir. Sonuncu Case’e lütfen dikkat edin: Burada Case
olarak Else (başka) veriliyor. Bu bizi, 17’den 23’e kadar olan saatleri sıralamaktan kurtarır.
0’dan 11’e kadar olan saatlerle 12’den 17’ye kadar olan saatleri sıraladığımıza göre başka
hangi saat olursa olsun, ziyaretçimize “İyi akşamlar!” dileyebiliriz. Eğer 24’den sonra ve
04’den önce ziyaretçinize “İyi geceler!” dilemek isterseniz, bu programı nasıl değiştirirdiniz?
Döngüler
Sınama bir programın akışını kontrol için kullanacağımız birinci en önemli unsur ise, döngü de
ikinci en önemli unsur sayılır. Hatta programcının tembellik katsayısına göre, belki de birinci
en önemli unsuru bile sayılabilir! Çünkü Döngü (Loop) programa, bir işi biteviye yaptırmaya
yarar. Tabiî bu iş sonsuza kadar sürecek olursa, buna Endless Loop (Sonsuz Döngü) denir; en
iyi program ve Windows dondurma yöntemidir! VBScript’te kullanabileceğimiz döngü
yöntemleri şunlardır:
For..Next döngüsü
Programın bir işi belirli kere yapmasını istiyorsak, ona yapacağı işi bir sayaç değişkeniyle
birlikte, For döngüsüyle bildiririz:
For sayaç = başlangıç To son Step adım
yapılacak işler
Next
Burada, “sayaç” yerine istediğiniz bir değişken adını, “başlangıç” yerine sayacın başlamasını
istediğiniz sayıyı, “son” yerine sayacın durmasını istediğiniz sayıyı, ve “adım” yerine, sayacın
kaçar-kaçar artmasını istediğinizi yazabilirsiniz. En sondaki Next deyimi ise döngünün bir
sonraki adıma geçmesini sağlar. Bu adımda sayaç, Step kelimesi varsa, karşısındaki değer
kadar arttırılır ve yapılacak işler yeniden yapılır. Bir örnek yapalım (gunler.asp):
<HTML>
<HEAD>
<TITLE>ASP ILE GÜNLERI SAYMA</TITLE>
<META http-equiv="content-type" content="text/html; charset=ISO-8859-9">
<META http-equiv="Content-Type" content="text/html; charset=windows-1254">
</HEAD>
<BODY>
<H2>
<CENTER>
<%
Dim Gunler
Gunler = Array("Pazartesi", "Salı", "Çarşamba", "Perşembe", "Cuma", "Cumartesi", "Pazar")
For sayac = 0 to 6
Response.Write Gunler(sayac)
Response.Write "<BR>"
Next
%>
</CENTER>
</H2>
</BODY>
</HTML>
Bu ASP kodunda, Gunler adıyla bir dizi-değişken oluşturuyoruz ve bu değişkenin yedi
hanesine, günlerin adlarını atıyoruz. Sonra, sayac adlı sayacı 0’dan 6’ya kadar arttırıyoruz (Bir
sayaç birer birer artsın istersek, Step bölümüne adım sayısı yazmayız). Şimdi kendimizi bir an
için VBScript’in yerine koyalım ve birinci adımda yapacağımız işi düşünelim: “Hmm..
Programcı bey, benim sayac’ı önce 0 yapmamı istiyor; peki sayac 0 olsun. Sonra, Gunler dizideğişkeninden
sayaç değeri ile aynı sayıyı taşıyan değişkeni alıp, bunu ziyaretçinin
Browser’ına yazmamı istiyor. Peki, Gunler(0) ne imiş, bakalım. Hmm Gunler(0) Pazartesi
imiş. o halde ziyaretçinin ekranına bir Pazartesi kelimesi yazalım. Sonra bir de <BR> kodu
yazmamı istiyor. Onu da yazalım.. Şimdi, sırada Next var. Yani bir sonraki adıma devam
edeceğiz. Step değeri olmadığına göre sayacı bir arttırayım. Sayaç böylece 1 oldu. ...”
Ve böylece VBScript, sayacın son değeri olan 6’ya ulaşıncaya kadar, biteviye Gunler dizideğişkeninden
sayacın değerine göre değer seçerek ve bunu ekrana yazdırarak, işini yapacaktır.
Bu bakımdan VBScript, güvenilir ve çalışkan bir arkadaştır!
While...Wend
Ne var ki, program mantığı bazen bize böyle açık ve seçik bir sayaç kurma imkanı vermez.
Sayaç olarak kullanacağımız değer, programın başka bir bölümü tarafından üretiliyor olabilir.
Veya bu değer ziyaretçi tarafından belirlenmiş olabilir. Özetle yapılmasını arzu ettiğimiz işin
ancak sayaç bir değerden azsa, çoksa veya eşitse yapılmasını, bu durum değişirse durmasını
isteyebiliriz. Bunu While (..iken) komutuyla yapabiliriz. While döngüsünü kullandığımız
zaman sayacı bizim arttırmamız gerekir.
Sözgelimi, yukarıdaki programın 7 günün tümünü ekrana yazmasını değil de, mesela gün
sayısı 5’den küçük ise yazmasını istiyor olabiliriz. Bu durumda kodumuzda For.. Next arasında
kalan bölümde şu değişikliği yapabiliriz:
While sayac <= 5
Response.Write Gunler(sayac)
Response.Write "<BR>"
sayac = sayac + 1
Wend
Burada While döngüsünün Wend kelimesiyle sonlandırıldığına dikkat edin. While satırındaki
sayacı değiştirdik, programın sayaç 5’den küçük veya 5’e eşit iken işlemesini sağladık. For’dan
farklı bir diğer ifade ise sayacı arttıran “sayac = sayac + 1” ifadesidir. Bu ifade, ilk bakışta
garip görünebilir. Fakat bilgisayar açısından bu “sayac’ın o andaki değerini al, 1 ile topla ve
bulduğun yeni değeri sayacın mevcut değerinin yerine yaz!” demektir. VBScript sayacı bir
arttırdıktan sonra önce While satırındaki şartın gerçekleşip gerçekleşmediğine bakar;
gerçekleşmiş ise Wend’i izleyen ilk satıra gider; gerçekleşmemişse While döngüsünün içindeki
işi yapmaya devam eder. Kendinizi VBScript’in yerine koyup, birinci ve ikinci adımda nasıl
düşündüğünüzü ve ne iş yaptığınızı söyleyebilir misiniz?
Do..Loop
Do (Yap) komutu ile kuracağımız döngüler iki ayrı türde olabilir: bu döngü ile bir dizi komutu,
bir koşul doğru iken veya doğru oluncaya kadar yaptırabiliriz. Bu yöntemlerden her biri iki ayrı
şekilde yazılabilir. Bir koşul doğru iken bazı işlerin biteviye yapılmasını istiyorsak, Do While
yöntemini kullanırız:
Do While koşul
koşul doğru iken yapılacak işler
Loop
Bu ifade ile VBScript koşul doğru olduğu sürece istediğimiz işi yapacaktır. Buradaki Loop
kelimesi, döngünün başa dönmesini sağlar. Bu yöntemden şu şekilde de yararlanabiliriz:
Do
koşul doğru iken yapılacak işler
Loop While koşul
Burada, Loop komutu şartın hâlâ doğru olup olmadığını sınar ve doğru ise verilen işleri yapar;
artık değilse bir sonraki satıra geçer.
Döngünün bir şart gerçekleşinceye kadar bir işi yapmasını ise Do Until yöntemiyle sağlarız. Bu
durumda döngü şöyle yazılır:
Do Until koşul
koşul gerçekleşinceye kadar yapılacak işler
Loop
Bu ifade ile VBScript koşul doğru oluncaya kadar istediğimiz işi yapacaktır. Buradaki Loop
kelimesi, döngünün başa dönmesini sağlar. Bu yöntemden şu şekilde de yararlanabiliriz:
koşul gerçekleşinceye kadar yapılacak işler
Loop Until koşul
Burada, Loop komutu şartın henüz gerçekleşip gerçekleşmediğini sınar ve henüz
gerçekleşmemişse verilen işleri yapar; gerçekleşmişse bir sonraki satıra geçer.
Visual Basic metinlerinde bu döngüye verilen klasik örnek, bilgisayara yazı-tura attırmaktır!
Biz de ASP sayfamıza yazı-tura attırabiliriz. Bunun için şu kodu yazın ve yazi-tura.asp adıyla
kaydedin:
<% Option Explicit %>
<HTML>
<HEAD>
<TITLE>ASP ILE YAZI-TURA</TITLE>
<META http-equiv="content-type" content="text/html; charset=ISO-8859-9">
<META http-equiv="Content-Type" content="text/html; charset=windows-1254">
</HEAD>
<BODY>
<H2>
<CENTER>
<%
Dim ParaAt, Yazi, Tura, Atis
Randomize
Yazi = 0
Tura = 0
Atis = 0
Do While Tura < 3
atis = Atis + 1
ParaAt = Int(Rnd * 2) + 1
If ParaAt = 1 Then
%>
Yazı!<P>
<%
Yazi = Yazi + 1
Else
%>
Tura!<P>
<%
Tura = Tura + 1
End If
ACTIVE
Loop
%>
3 Tura getirebilmek için parayı <%=Atis%> kere atmak gerekti!
</HTML>
Bu kodda şu ana kadar karşımıza çıkmamış olan Randomize (Tesadüfî sayı bulma)
Fonksiyonu’nun kullanıldığını görüyoruz.
////////////////////KUTU///////////////////
Tesadüfî Sayı
Bilgisayarın matematik işlemlerde, özellikle istatistik hesaplamalarla kullanılması tesadüfî
(rastlantısal) sayı üretmeyi gerekli kılmıştı. Fakat daha sonra bilgisayar oyunları bu işlemi
adeta zorunla hale getirdi. Rastlantısal sayı, bir dizide tekrar etmesi belirli bir düzene tabi
olmayan sayı demektir. Bilgisayar yokken, tesadüfî sayı tabloları matematikçiler tarafından
uzun uğraşlarla üretilirdi.
VBScript, bu amaçla Visual Basic’in Randomize ve Rnd komutlarını almıştır. Randomize,
tesadüfî sayı üretme sürecini başlatır; Rnd da bu sayıyı size verir. Kodunuzda bir yerde Rnd
kullanacaksınız, ondan önce bir yerlerde mutlaka Randomize komutunun yer alması gerekir.
Bunun bir uygulaması şu olabilir:
<% OPTION EXPLICIT %>
<HTML>
<%
Dim TesadufiSayi
Randomize
TesadufiSayi = Rnd
%>
<%=TesadufiSayi%>
</HTML>
Bu dosyayı tesaduf.asp adıyla kaydedip çalıştırın; Browser’ın Yenile düğmesini her
tıkladığınızda ekranda yeni bir sayı göreceksiniz. Bu sayıların rastlantısal olması, bir kere daha
gelmeleri için hiç bir kural (örneğin her rakamın 123 kerede bir gelmesi veya 1 milyon 245 bin
kerede bir gelmesi gibi) bulunmamasıdır. İşin tekniğini bilmek isterseniz, VBScript, her Rnd
komutu icra edildiğinde bilgisayarın saatini öğrenir; içinden seçeceği bir rakamı son derece
karmaşık bir formülden geçirerek size bir rakam verir. bu rakam daima 0 ile 1 arasında olur.
“(Rnd*6)+1” formülü bize 1 ile 6 arasında (yani bir zarın değerlerinden her hangi biri),
“(Rnd*13)+1” formülü ise 1 ile 13 arasında (yani bir iskambil destesindeki kağıt değerlerinden
herhangi biri) bir değer verir. Fakat dikkat: bu değerler tam sayı değildir!
/////////////////KUTU BİTTİ/////////////
Programımızın bütün işlemi Do döngüsü bölümünde yapılıyor ve bilgisayarın bir tesadüfî sayı
üretmesi esasına dayanıyor. Bunu Randomize ve Rnd fonksiyonları ile yapıyoruz. Rnd’un
verdiği tesadüfî rakamı, iki ile çarpıyor ve çıkan sayıyı 1 ile topluyoruz; böylece ortaya 1’den
büyük 3’den küçük bir kesirli rakam çıkmış oluyor (Neden?). Bu rakamı Int() fonksiyonundan
geçirerek, kesirinden kurtarıyoruz.
Tam Sayı Elde Etmek için: Int ve Round
Rnd fonksiyonu ile ilgili yukarıdaki örneği yaptıysanız, dönen sayının 0 ile 1 arasında, yani
daima kesirli olduğunu görmüş olmalısınız. Bazen bizim sayfalarımızdaki hesaplamalar veya
veritabanından alınan değerler de kesirli olabilir. Örneğin öğrencilerin not ortalamalarını
hesaplattırırken VBScript size sonu gelmez kesirler verecektir. Oysa çoğu zaman bu
rakamların ya yukarı “yuvarlanması”, ya da sadece tam sayı bölümü gerekir.
VBScript’te Int() fonksiyonu, bize bir sayının tam sayı bölümünü verir. Diyelim ki elimizdeki
KesirliSayi değişkeninin değeri 123,234567 olsun.
Tamsayi = Int(KesirliSayi)
işleminden sonra Tamsayi değişkenin değeri 123 olur.
Fakat kimi zaman bir sayının kesirli bölümünü böyle bıçakla kesip atmak işimize gelmeyebilir.
Round() fonksiyonu, kesirli bir sayıyı yukarı veya aşağı “yuvarlayarak” tam sayı haline getirir.
Bu kez ki elimizdeki KesirliSayi değişkeninin değeri 5,6 olsun.
Tamsayi = Int(KesirliSayi)
işleminden sonra Tamsayi değişkenin değeri 6 olur. Kesirli sayı 56,2 ise, Round() fonksiyonu
bize 56 değerini verir.
//////////////////////////////KUTU BİTTİ///////////////
Programımız, elde ettiği ve Paraat değişkenine kaydettiği bu sayı 1 ise, Yazı gelmiş sayıyor; ve
Browser Penceresine “Yazı!” yazıyor. Bu arada yapılan atış sayısını kaydettiğimiz Atis ve
gelen tura sayısını tuttuğumuz Tura değişkenlerinin değeri bir arttırılıyor. ParaAt değişkeninin
değeri başka bir şeyse (ne olabilir?), programımız bu kez tura geldiğine hükmediyor ve
Browser penceresine “Tura!” yazıyor. Do döngüsü, Tura gelen atışların sayısı 3 oluncaya kadar
devam ediyor. Çünkü Do döngüsünü While Tura < 3 (Tura 3’den az iken) deyimi ile
çalıştırıyoruz. Ve program sonunda 3 tura gelinceye kadar kaç atış yaptığını yazıyor.
<asp0008.tif>
Bu ASP sayfası görüntülenirken Browser’ın Yenile düğmesini tıklarsanız, her seferinde Tura
getirmek için farklı sayıda atış yapmak gerektiğini; aynı sayıda atış yapılsa bile turalarla
yazıların yerinin değiştiğini göreceksiniz.
Dizi değişkenler için döngü: For Each..Next
For..Next gibi çalışan bu özel döngü, sayaç değeri kullanmaz, fakat bir dizi değişkenin bütün
değerleri için bir kere icra edilir. Dizi-değişkenler, VBScript ile yapacağımız işlemlerde önemli
bir yer tutar. Örneğin bir sınıftaki öğrencilerin veya müşterilerimizin listesi bir dizi değişkenin
elemanları olabilirler. Yapmak istediğimiz işlem, dizi-değişkenin bütün elemanları için tekrar
edilecekse, For Each..Next döngüsü daha elverişli olabilir. Bir dizi-değişkenin eleman sayısı
ilerde değişirse ve siz döngüyü For..Next ile kurmuşsanız döngünün sayacı için verdiğiniz için
alt ve üst sınırı değiştirmek zorunda kalırsınız. Oysa For Each, kaç kere tekrar edeceğine ilişkin
değeri her zaman dizi-değişkenin elemanların sayısından alır. Örneğin, bütün öğrencilerin
listesini tutan Ögrenciler dizi-değişkeninin bütün elemanlarının değerini ekrana yazdıralım:
For Each Ogrenci In Ogrenciler
Response.Write Ogrenci
Next
değerini tutar. For Each döngüsü tarafından “okunmakta olan” dizi-değişkenin her bir değeri
sırayla bu değişkene yazılacaktır. Bunu bir tür endeks değişken olarak düşünebilirsiniz.
Döngüyü durdurmak isterseniz
Bir döngüden belirlediğiniz koşul gerçekleşsin-gerçekleşmesin çıkmanız gerekebilir. Bunu bir
başka değişkendeki değişiklik zorunlu kılabilir. Bir döngüden çıkmak için Exit (çık) ifadesini
kullanabilirsiniz. Bu ifade, döngünün yaptığı işler arasında, genellikle bir If deyimi ile birlikte
yer alır. Örneğin:
For sayac = 1 to 10
[..bir takım işler yap..]
If Degisken1 > Degisken 2 Then Exit For
[..bir takım işlere devam et..]
Next
Bu durumda For..Next döngüsü, Degisken1’in değerinin Degisken2’den yüksek olduğunu
belirlerse, derhal döngüyü durdurarak, Next’ten sonraki satıra gidecektir.
Do döngüsünden ise Exit Do ile çıkababiliriz. Bu ifadenin kullanımı da Exit For gibi olur.
Süreçler (Prosedürler)
VBScript’te programın akış kontrolünde kullanacağınız bir diğer grup araç ise örneğin
Javascript veya Perl’de fonksiyon dediğimiz gruplandırılmış ve isimlendirilmiş işlem
kümeleridir. Bu kümeler programın bir yerinde topluca dururlar ve programın başka bir
yerinden isimleriyle çağrılırlar; veya bu kümelere isimleriyle referans yapılır.
VBScript’te bu kümelenmiş kod gruplarına Prosedür (Süreç) denir. iki türlü olur: fonksiyon
(Function) ve Subroutine (sab-rutin okunur; kısaca Sub diye yazılır ve sab diye okunur). Bu iki
süreç arasındaki başlıca fark, fonksiyondan kendisini çağıran komuta daima bir değer döner;
Sub’dan dönmeyebilir. Sub, yapacağı işi yapar ve programın kontrolünü kendine atıf yapılan
noktaya devreder. VBScript’de bir programa farklı yerlerde sık sık aynı işi yaptırıyorsak, bunu
bir Sub ile yaptırırız; fakat programımıza bir değer gerekiyorsa, bu değeri bir fonksiyona
hesaplattırırız. Her ikisi de kendilerine atıfta bulunan veya kendilerini göreve çağıran satırdan
(komuttan, deyimden) verilebilecek değerleri kabul edebilirler.
Biraz karışık oldu; ama bunu ilerde gerçek ASP uygulamaları yazarken daha iyi anlayacağız.
Şimdilik bir iki noktayı öylece öğrenmeye bakalım. Bir fonksiyonun adı, tıpkı bir değişken adı
gibi, fonksiyonun ürettiği değeri tutar; ve bu değer kendisini çağıran komuta verilir. Diyelim
ki, programımızın çeşitli noktalarında yazı-tura atıp, elde edilecek sonuca göre bir iş yapmak
zorundayız. Bu ihtiyacın doğduğu yerde, yazı-tura komutlarını yazabiliriz. Ancak bu ortaya
çok uzun bir programın çıkmasına sebep olur. Oysa yazı-tura işlemlerini bir fonksiyonda toplar
ve ihtiyaç halinde sadece bu fonksiyonu çağırırsak ve fonksiyon bize o anda yazı mı geldiğini,
yoksa tura mı geldiğini bildirirse, işimiz çok kolaylaşmış olur.
Böyle bir fonksiyon, yukarıdaki örnekten hareketle, şöyle olabilir:
<%
Function YaziTura
Dim ParaAt
Randomize
ParaAt = Int(Rnd * 2) + 1
If ParaAt = 1 Then
YaziTura = “Yazı”
Else
YaziTura = “Tura”
End If
End Function
%>
Bu fonksiyonu, ASP programının herhangi bir yerinden, şöyle bir yöntemle çağırabilir; ve
vereceği sonucu programın akışına uygun şekilde kullanabilirsiniz:
<%
NeGeldi = YaziTura
Response.Write NeGeldi
%>
Fonksiyonun sonunda End Function ifadesinin bulunduğuna ve fonksiyonun elde ettiği sonucu
kendi adına atadığımıza dikkat edin. DIM ifadesiyle böyle bir değişken tanımlamadığımız
halde VBScript, fonksiyonu çağırdığınız anda bunu kendiliğinden yapacaktır.
Aynı işlemi Subroutine (Sub) olarak yazabiliriz. Fakat bu kez Sub, elde edeceği değeri kendisi
kullanacak ve bittiği anda kontrol programa geri dönecektir:
<%
Sub YaziTura()
Dim ParaAt
Randomize
ParaAt = Int(Rnd * 2) + 1
If ParaAt = 1 Then
Response.Write “Yazı”
Else
Response.Write “Tura”
End If
End Sub
%>
Fonksiyon adlarının sonuna, bizden beklediği değer varsa onları belirleyen değişken adlarını
parantez içinde yazarız. Fonksiyon bizden bir değer beklemiyorsa açılan kapanan (boş)
parantezlere ihtiyaç yoktur. ancak bir çok VBScript programcısı bunu adet edinmiştir.
Sub’ların çağrılması, fonksiyondan farklıdır. Sub’ın icra edilmesini istediğiniz noktaya sadece
adını yazarız. Sub’lar işleyebilmek için bizden değer bekliyorsa, bu değerleri Sub adının
yanına, parantez içine almadan ve virgülle ayırarak, yazarız. Örneğin, Hesapla isimli ve bizden
iki değer bekleyen bir Sub şöyle çağrılır:
Bu Sub işini bitirdiği anda programın akışı, Sub’a atıf yaptığımız noktada devam eder.
Sık Kullanacağımız Hazır Fonksiyonlar
VBScript’te kullanabileceğimiz bir iki hazır-fonksiyona yukarıda değindik. Tesadüfî sayı
üreten Rnd() fonksiyonu bunlardan biriydi; ayrıca Int() fonksiyonu ile kesirli bir sayının tam
bölümünü alabildiğimizi gördük. VBScript’in kullanılmaya hazır daha bir çok fonksiyonu
vardır; ancak ASP uygulamalarında sık kullanacağımız ve özellikle metin düzenlemeye ait olan
bir kaçını burada sıralayalım.
Tarih ve saat
Belki de Web’in zamana çok bağlı oluşu dolayısıyla, Visual Basic’in hemen hemen bütün
zaman-tarih fonksiyonları VBScript’te de kullanılır.
Date: Bugün tarihini verir. (25.03.2000 gibi)
Time: O andaki saati verir. (22:24:40 gibi)
Now: O andaki tarih ve saati birlikte verir. (25.03.2000 22:24:40 gibi)
VBScript’in buna ek olarak Weekday (haftanın günü), WeekdayName (günün adı) ve
Monthname (ayın adı) fonksiyonları da vardır. Bu fonksiyonlar değerlerini Date fonksiyonuna
göre alırlar. Örneğin,
<%= WeekdayName(Weekday(Date))%>
komutu bize bugün Cumartesi ise “Cumartesi” değerini verir.
<%= MonthName(Month(Date))%>
komutu bize bu ay Mart ise “Mart” değerini verir. VBScript’in bunlara ek olarak Day (gün),
Month (ay) ve Year (yıl) fonksiyonları da değerlerini Date fonksiyonundan alarak, size bir
rakam verirler. Eğer tarih 25 Mart 2000 ise:
<%= Day(Date)%>... 25
<%= Month(Date)%>... 3
<%= Year(Date)%>... 2000
değerini verir. VBScript, bu değerleri doğruca işletim sisteminden alır. Dolayısıyla işletim
sisteminin bölgesel ayarları Türkiye için yapılmışsa, gün adları Türkçe olarak dönecektir.
Ayrıca, tarih ve saat biçimleri de bölgesel ayarlara bağlı olarak, ay önde, gün arkada veya tersi,
saat de 12 saat veya 24 saat esasına göre döner. ASP programlarınızı kişisel Web Server’da
denerken kendi bilgisayarınızın tarih ve saatini; gerçek Internet’te çalıştırırken Server’ın tarih
ve saatini alırsınız. Sayfalarınızda ay ve gün adlarını Türkçe görüntülemek için, önce Server’ın
bölgesel ayarlarını sınamanız ve eğer isimler Türkçe gelmiyorsa, bunları çeviren Sub’lar veya
fonksiyonlar yazmanız gerekebilir.
Karakter-dizisi Düzenleme
Karakter-dizisi veya String, VBScript için herşey olabilir. “Sana Sevdanın Yolları Bana
Kurşunlar” bir String’dir. “Bugün 7 Ağustos 2000” bir String’dir. “Doğum Günün Kutlu
Olsun!” bir String’dir. Web sitemizi ziyaret eden kişinin formlarımıza yazacağı ve Gönder
tuşunu tıklayarak Server’a göndereceği bilgiler String’dir. Fakat bunların hepsi olduğu şekliyle
işimize yaramaz. Bunları yeniden düzenlemek, içinden seçmeler yapmak veya biçimlerini
değiştirmek gerekebilir. VBScript bu amaçla kullanılmaya hazır bir dizi fonksiyon verir:
InStr Uzun bir String’in içinde vereceğiniz daha kısa bir String’in bulunup
bulunmadığını arar; bulursa bu kısa String’in başlama noktasının değerini verir.
Diyelim ki, “Sana Sevdanın Yolları Bana Kurşunlar” String’ini Kayahan
değişkenine, “Sevda” kelimesini de Ara değişkenine atadınız. InStr fonksiyonu ile
Ara’nın değerinin yerini Kayahan’ın değerinin içinde bulabilirsiniz:
Yer = InStr(Kayahan, Ara)
Yer’in değeri 6 olacaktır; çünkü “Sevda” kelimesi, uzun String’de 6’ncı
karakterden başlamaktatır.
Len Bir String’in uzunluğunu belirler. Yukarıdaki örnekte yer alan Kayahan değişkenin
uzunluğunu şöyle belirleyebiliriz:
Uzunluk = Len(Kayahan)
Uzunluk değişkeninin değeri 36 olacaktır.
UCase Vereceğiniz bir String’in tüm karakterlerini büyük harfe çevirir.
YeniString = UCase(Kayahan)
Yeni String’in değeri: “SANA SEVDANIN YOLLARI BANA KURŞUNLAR”
olacaktır.
LCase Vereceğiniz bir String’in tüm karakterlerini küçük harfe çevirir.
YeniString = LCase(Kayahan)
Yeni String’in değeri: “sana sevdanın yolları bana kurşunlar” olacaktır.
LTrim, RTrim, Trim Verdiğiniz String’in (sırasıyla) solunda yani baş tarafında; sağında yani
sonunda ve hem başında ve hem de sonundaki boşlukları temizler.
Space İçinde, vereceğiniz sayı kadar boşluk olan boş bir String oluşturur. Örneğin
Bosluk = Space(20)
Bosluk değişkenin değeri “ “ (20 boşluk) olacaktır.
String İstediğiniz sayıda ve istediğiniz bir karakterle bir String oluşturur.
YeniString = String(3, “*”)
YeniString değişkeninin değeri “***” olacaktır.
Left, Right Bir String’in içinde soldan (baştan) veya sağdan (sondan) verdiğiniz sayıya kadar
olan karakterleri verir. Örneğin, yine yukarıdaki Kayahan değişkenini kullanırsak:
Solda = Left(Kayahan, 4)
Solda değişkeninin değeri “Sana” olacaktır; çünkü Kayahan değişkeninin soldan
itibaren dört harfi “Sana“ kelimesine denk geliyor.
Mid Bir String’in içinde başlangıç noktasını ve karakter olarak boyunu verdiğiniz
alanda yer alan String’i verir.
Ortada = Mid(Kayahan, 5, 8)
Ortada değişkeninin değeri “Sevdanı” olacaktır; çünkü Kayahan değişkeninin
soldan 5’nci değişkeninden itibaren 8 karakterlik alanda “Sevdanı” karakterleri yer
alıyor.
Dizi-Değişken (Array) Fonksiyonu
VBScript’in dizi-değişken oluşturmada Array() fonksiyonu ile sağladığı kolaylıklara kısaca
değindik. Fakat Array ile daha bir çok iş yapabiliriz; ve dizi değişken oluşturmakta
VBScript’in diğer bazı kolaylıklarından yararlanabiliriz. Dizi-değişkenler, özellikle Web
ziyaretçilerimizden gelecek bilgilerin kaydedilmesinde; veritabanından çekeceğimiz verilerin
kullanılır hale getirilmesinde yararlı bir araçtır. Dolayısıyla ASP sayfalarınızda sık sık çokboyutlu
dizi değişkenlerden yararlanacaksınız. Bunun için gerekli araçları kısaca ve topluca ele
almamız yerinde olur.
Bir dizi değişken oluştururken, değişkenin eleman sayısını belirtmezsek, VBScript, kendi
kendine “Anlaşılan bu diziyi dinamik yapmamı istiyorlar!” der; ve daha sonra elemanlarının
değerleri sonradan belirtilebilecek ve eleman sayısı sonradan arttırılabilecek bir dinamik dizideğişken
oluşturur. (“VBScript iyi huyludur,” demiş miydim?) Örnek:
Dim Ogrenciler()
Bu komutla, Ogrenciler dizi-değişkeni oluşturulur; ancak eleman sayısı belirtilmediği için dizi
dinamiktir; yani daha sonra bu dizinin eleman sayını belirleyebilirsiniz. Bunu:
ReDim Ogrenciler(15)
gibi bir komutla yapabiliriz. Şimdi aklınıza şu soru gelebilir: Peki neden Ogrenciler dizisini
baştan eleman sayısını belirterek tanımlamıyoruz? Güzel soru! Cevabı şu olabilir mi? Dizideğişkenimizin
eleman sayısını henüz bilmiyoruz; ve programın akışı içinde bu sayı, başka bir
fonksiyonun, Sub’ın veya kullanıcı girdisinin sonucu olarak belirlenebilir. Fakat hemen
belirtmek gereken bir nokta var: ReDim komutu, mevcut bir dizi-değişkenin içindeki herşeyi
siler! Mevcut dizinin elemanlarını ve onların değerlerini korumak istiyorsak:
ReDim Preserve Ogrenciler(20)
yazmamız gerekir. Buradaki Preserve (koru) komutu, VBScript’e mevcut dizi içindeki
elemanları korumasını, ve eleman sayısını 20’ye çıkartmasını bildirir. Buna neden gerek
olabilir? Ziyaretçinin tercihleri değişebilir; örneğin bir elektronik alışveriş sitesinde
ziyaretçiniz yeni şeyler alabilir; daha önceki alışverişlerine ilişkin verileri tuttuğunuz dizideğişkenin
eleman sayısını, daha önceki bilgileri silmeden arttırmanız gerekir.
VBScript’in dizi-değişkenlerini tümü aynı adı taşıyan bir liste olarak düşünebilirsiniz; sadece
değişken adının yanında dizinin kaçıncı elemanı olduğunu belirten sayı bulunur:
Ogrenciler(1): Necip
Ogrenciler(2): Serap
Ogrenciler(3): Neslihan
Fakat VBScript çok boyutlu dizi değişken de oluşturabilir. İki boyutlu dizi-değişkeni tablo gibi
düşünün; dizinin elemanları aynı adı taşıyan değişkenler fakat bu kez sadece tek sayı değil sıra
ve sütun numaraları ile belirleniyorlar:
Ogrenciler(1,1): Necip
Ogrenciler(1,2): Serap
Ogrenciler(1,3): Neslihan
Ogrenciler(2,1): Selim
Ogrenciler(2,2): Murat
Ogrenciler(2,3): Merve
Ogrenciler(3,1): Elif
Ogrenciler(3,2); Hande
Ogrenciler(3,3): Leyla
Şimdi, burada üç sıralı, üç sütunlu bir tablo getirebilirsiniz gözünüzün önüne. Bu dizideğişkeni
şu komutla oluşturabiliriz:
Dim Ogrenciler(3,3)
Böyle bir değişkende sözgelimi birinci sıra (numarası 1,x olanlar) çalışkanları, ikinci
sıradakiler (2,x’ler) daha az çalışkanları vs., belirtebilir. VBScript, üç, dört ve hatta beş boyutlu
dizi-değişken oluşturur. Ama bunu nerede kullanacağınızı siz kararlaştırabilirsiniz.
değiştirebilirsiniz:
Ogrenciler(3,2) = “Caner”
komutu, Hande’nin adını siler ve yerine Caner’in adını yazar.
Dizi-değişkenlerimizin eleman sayısını bilmek isteyebiliriz. Kimi zaman dizideğişkenlerimizin
eleman sayısı biz belirlemeyiz; bu bilgi bir formdan gelebilir; bir
veritabanından alınabilir; fakat mesela bir döngü için bu değişkenin kaç elemanı olduğunu
bilmek gerekir. Örneğin elimizde 35 elemanı olan Ogrenciler dizi-değişkeni varsa, bu sayıyı
ElemanSayisi = UBound(Ogrenciler)
komutu ile ElemanSayisi değişkenine yazdırırız. ElemanSayisi’nin değeri bu durumda 35
olacaktır.
Test Fonksiyonları
VBScript’te kullandığımız bazı değişkenlerin o andaki durumu, programımızın akışını
kontrolde kullanacağımız bilgiyi sağlayabilir. Sözgelimi bir değişkenin değeri boş ise,
ziyaretçimizin formu tam olarak doldurmadığını düşünebiliriz. VBScript, bize değişkenlerin
durumunu sınamamız için bazı özel fonksiyonlar sağlar. Bu özel fonksiyonlardan dönen değer
True (doğru) veya False (yanlış) olur; doğru sonucun değeri –1, yanlış sonucun değeri ise
0’dır:
IsArray Bir değişkenin dizi-değişken (Array) olup olmadığını sınar.
IsDate Bir değişkenin değerinin tarihe (Date) çevrilip çevrilemeyeceğini sınar.
IsEmpty Bir değişkenin tanımlanıp değer atanmış olup olmadığını sınar.
IsNull Bir değişkenin geçerli bir değer tutup tutmadığını sınar.
IsNumeric Bir değişkenin sayı olarak işleme tabi tutup tutulamayacağını sınar
I sObject Bir ifadenin geçerli bir ActiveX veya OLE nesnesine referansta bulunup
bulunmadığını sınar.
TypeName Bir değişkenin türünü belirtir.
VarType Bir değişkenin türünü belirten sayıyı verir.
***
Şimdi ASP için gerekli VBScript bilgisi bu kadar değil tabiî. Ama bu, işe başlamamız için
yeter. İlerde yeni VBScript komutları, veya fonksiyonları ile karşılaşırsak (ki size garanti
ederim, karşılaşacağınızı!) onları orada kısaca ele alırız. Ama yukarıdaki VBScript bilgisi, her
zaman lazım!

Açık bilgi paylsım alanı

VBScript’de Program Kontrolü

Yorum Gönder

Popüler Filmler

Blog Arşivi

Etiketler

Kötüye Kullanım Bildir

Hakkımda