Gönderen Konu: BASİC-256  (Okunma sayısı 4335 defa)

0 Üye ve 1 Ziyaretçi konuyu incelemekte.

« : »
                                                                                 


                                     BASİC 256

Basic 256 kurulumu :

Yazılım Merkezi'ni başlatalım ve arama çubuğuna basic yazalım. Karşımıza çıkan seçenekler arasında ilk sırada BASİC-256 uygulamasını bulacağız.
Kurulum için seçelim ve şifre sorulduğunda, kurulumu onaylamak için, kullanıcı şifremizi girelim. İndirme ve kurulum süreçleri en fazla bir kaç dakika sürecektir.

Basic 256 yı çalıştıralım :

Masaüstümüzün yan simge panelindeki en üstte bulunan Ubuntu simgesini tıklayalım ve açılan seçim alanından, en altta bulunan seçeneklerden Uygulama ara seçeneğini tıklayalım. Karşımıza çıkan simgeler arasından, BASİC-256 yı seçelim.

Basic 256 ne işe yarar ?

Basic 256, Basic programlama dili (Kodlama dili) için bir güvenli programlama ortamıdır. İşlemlerimiz sadece Basic 256 arayüzü içinde gerçekleşeceğinden, her hangi bir kötü olay ile karşılaşma durumumuz olmayacaktır.

Programlamaya yeni başlayacaklar için uygun bir durum.

Basic 256 nasıl çalışır ?

Basic 256 yı başlattığımızda, karşımıza, üst bölümünde bir kaç simge bulunan ve gerisi ise üçe bölünmüş bir boş landan oluşan bir yapı çıkar.
Belki ilk karşılaşmada gözünüze biraz ürkütücü gelebilir, ve siz bu yapı ile ne yapacağınızı bilmeyebilirsiniz. Ama ilk işlemlerimizi beraber yapacağımızdan,
her hangi bir endişeniz olmasın.

Basic 256, geleneksel Basic ve ilave edilmiş bazı kolaylıklardan ibarettir.

Basic 256 nın sol tarafındaki büyük boyutlu boş alanının adı editör'dür. Biz bu alana kod'larımızı yazacağız ve diğer iki alanda ise, işlemlerimizi takip edeceğiz.

İlk işlemimiz :

Her yeni işin en zor yönü, başlangıçtır. Her zaman, bilinmeyene atılan ilk adım, heyecan verir, hatta, birazda ürkütebilir.
Basic 256 nın editörüne ilk kod'larımızı yazalım.

print "Merhaba"

Şimdi üst sıradaki simgelerden, yeşil renkli ok işaretinini tıklayalım. Simgenin adı "Run"
Sağ üst boş alanda Merhaba yazısı belirecektir. İşlemimizin beklenen sonucuda budur zaten.
Yazdığımız kod'ların, editörde renklendiğini fark edeceğiz. Bu renk verme olayı, bize, kod'larımızı yazarken dahi,
henüz çalıştırmamışken, doğru yazmış olduğumuzu gösterir. İsterseniz bir hata yaparak bunu deneyebilirsiniz.
Meselâ : prind yazabilirsiniz. Bu şekilde çalıştırdığınızda, bir de hata mesajı alırsınız.

Devam edelim

say "Merhaba"

Bu satırı, bir önceki satırımızın altına eklediğimizde, hem Merhaba yazısını, sağ üst boş alanımızda okuyabileceğiz,
hem de sesli olarak mörhabe kelimesini duyabileceğiz. Tabii bilgisayarınızın sesinin açık olması gerekiyor.
Basic 256 yazılanları İngilizce okuyor. O halde, yazdığımız ile duyduğumuz aynı olsun istiyorsak, biraz hile yapmamız gerekecek.
İkinci satır aşağıdaki gibi değiştirip, tekrar deneyelim.

say "Meerhabaa"

Bu hali ile kod'larımızı yeniden çalıştırdığımızda, Basic 256 yı Türkçe konuşturmuş olacağız. Şimdi kod'larımızı kayıt edelim.
"Save" isimli simgeyi tıkladığımızda, açılan bir pencere bize, klasör'lerimizin bulunduğu alanı gösterecektir. İsterseniz, Basic 256
işlemlerinizi, yeni bir klasör açarak, ayrı bir yere kayıt edebilirsiniz. Ben, bulunması kolay olsun diye, klasör'lerimin bulunduğu yere kayıt ettim.
Kod'larımız kayıt edebilmek için, önce bir isim vermemiz gerekiyor ve bu isimi, açılan pencerenin üst kısmındaki adres çubuğuna yazmamız gerekiyor.
Ben dosyamın adına merhaba verdim. Klasör'lerimin bulunduğu alana baktığımda da, orada "merhaba.kbs" isimli bir dosya buldum.
Basic 256 dosya uzantısını kendisi yazıyor. Bize sadece bir isim bulmak düşüyor.

Yeni işlem başlatalım :

Yeni bir işleme geçmek için, simgelerden "New" isimli olanı seçiyoruz.

print "Naber"

Yeni işlemimizi başlattığımızda,eski çıktı silinecektir. Herhangi bir işlem yapmadan, yazılı çıktı aldığımız alanı temizlemek istersek, sadece

cls

Kod'unu yazarak, "Run" simgesine basıyoruz. Ve çıktılarımız temizleniyor.
Kayıt ettiğimiz bir dosyamızı tekrar açmak istediğimzde, "Open" isimli simgeyi tıklıyoruz, .kbs uzantılı dosyamızı seçiyoruz ve çıkan sorguya "Yes" tıklıyoruz, ve editör alanımızda kayıtlı başka bir şeyler vardıysa, siliniyorlar ve .kbs uzantılı dosyamızdaki kod'lar yükleniyor.

« Son Düzenleme: 23 Mayıs 2013 - 10:24:14 Gönderen: ekremsenturk »

« Yanıtla #1 : »
Basic 256 ile hayatımıza biraz renk katalım

Basic 256 ile nasıl sesli ve yazılı sonuçlar alabildiğimizi gördük. Şimdi birazda görüntülü sonuçlar üzerinde çalışalım.

color blue
rect 10,10,40,40


Bu kod'ları çalıştırdığımızda, sağ alt boş alanımızın sol üst köşesinde bir mavi kare belirecek.
İlk satırdaki kod'umuz renk ve rengin türünü belirler. İkinci satırdaki kod'udmuz ise şekil ve şekilin konumunu belirler.
10,10 ve 40,40 rakamları piksel boyutunda 10 piksel sağa ve 10 piksel aşağıya, başlangiç köşesi, ve başlangıç köşesinden itibaren + 40 piksel sağa ve + 40 piksel aşağıya, kare'nin boyutunu belirtir. Daha açıklayıcı olarak, ilk iki rakam, kare'nin konumunu ve ikinci iki rakam, kare'nin boyutunu belirler diyebilirim.

Bir başka benzer örnek ile bir kıyaslama yapabilme olasılığımız olsun.

color red
rect 0,0,300,300


Bu örneğimizde tüm boş alan kırmızı renge boyanmış oldu. Yine bu örnekten öğrenebildiğimiz, sağ alt boş alanın varsayılan
boyutu, 300 x 300 piksel oluyor. Yine sağ bölümdeki boş alanların birer isimleri var. Üst alanın adı, üstünde yazdığı gibi,"Text Output"
Sağ alt alanın adıda "Graphics Output".
Basic 256 da bir editörümüz var, bir metin çıktısı veren alanımız var ve bir de görüntülü çıktı veren alanımız var. Ve tabii bir de sesli sonuçlar alabiliyoruz.

color yellow
circle100,100,200


Bu örneğimiz ise bir sarı küre çiziyor. Ancak küremizin boyutu, görüntü alanımızın boyutunu aşıyor. Daha küçük bir küre çizelim.

clg
color green
circle 200,100,50


Daha önceki küre'miz kırmızı alanın üzerine çizilmişti. Şimdi daha küçük ve sağa kaymış bir yeşil küremiz var ve arka alanı temizlenmiş durumda.
cls
nasıl metin çıktılarını temizliyorsa,
clg
de görüntü alanını temizliyor. Kare'mizde olduğu gibi, küre'mizde de ilk iki rakam, sağa ve aşağıya kaydırlan piksel boyutlarını temsil ediyorlar.
Üçüncü rakam ise, kaydırılan nokta merkez alınarak, küremizin yarı çapını (yani boyutunu) tanımlıyor.

Bir de bu örneği deneyelim.

clg
color yellow
circle 150,150,100
color red
circle 110,110,15
circle 190,110,15
line 150,120,150,170
line 100,170,200,170


Bu örneğimizde, son iki satırdaki rakamlar, kare'de olduğu gibi, ilk iki rakam, başlangıç noktasını ve son iki rakam da bitiş noktasını belirler.

color renkleri seçer
rect kare çizer
circle küre çizer
line bir çizgi çizer

ve renkler isimleri ile yazılırken, şekillerin görüntü alanı içinde bulunacakları yer, piksel boyutunda belirtilir.




« Son Düzenleme: 25 Şubat 2014 - 22:12:48 Gönderen: ekremsenturk »

« Yanıtla #2 : »
Renk'leri tanıyalım

Basic 256 renkleri isimleri ile tanır. Bu isimler İngiliz'ceden alınmadır. Basic 256 nın tanıdığı renk'lerin listesi ve Türkçe karşılıklarını aşağıdaki listede bulabilirsiniz.

black          Siyah
white          Beyaz
red            Kırmızı
darkred        Bordo
green          Yeşil
darkgreen      Zeytin yeşili
blue           Lacivert
darkblue       Koyu Lacivert
cyan           Mavi
darkcyan       Türkiz
purple         Pembe
darkpurple     Mor
yellow         Sarı
darkyellow     Zehir yeşili
orange         Turuncu
darkorange     Kahverengi
gray           Külrengi
dark gray      Koyu külrengi

Renk'leri denemek için şöyle bir örnek kullanabilirsiniz:

clg
color green
rect 0,0,50,50


İkinci satırdaki "green" kelimesini denemek istediğiniz renk ile değiştirebilirsiniz ve yeni yaptığınız değişiklik ile kodlarınızı çelıştırabilirsiniz.

Veya bu örneği deneyebilirsiniz:

# Bazı renkleri tanıtır
clg
color yellow
rect 0,0,300,300
pause 1
color red
rect 0,0,300,300
pause 1
color blue
rect 0,0,300,300
pause 1
color green
rect 0,0,300,300
pause 1
color orange
rect 0,0,300,300
pause 1
color purple
rect 0,0,300,300
pause 1
color white
rect 0,0,300,300
pause 1
color darkyellow
rect 0,0,300,300
pause 1
color black
rect 0,0,300,300
pause 1
color darkred
rect 0,0,300,300
pause 1
color cyan
rect 0,0,300,300
pause 1
color darkcyan
rect 0,0,300,300
pause 1
clg


Bu örneğimizde iki yenilik kullanıyoruz. Birincisi "#" işareti oluyor. Bu (#) işaret ile kod'larınızın arasına açıklamalar ekleyebilirsiniz ve # ile işaretlenen satırlar, işlemler esnasında Basic 256 tarafından görünmezler. Kısaca yok sayılırlar.

İkinci yenilik ise
pause
isimli kod. "pause" ile işlemler arasında saniye boyutunda kısa molalar verilebiliyor. Bizim bu örneğimizde, her renk değişiminde 1 saniyelik bir bekleme gerçekleşiyor ve biz böylelikle görüntülenen rengi görebiliyoruz.Biz bu kısa molaları kullanmasaydık, işlemler o kadar hızlı gerçekleşirdiki, biz hiç bir şey anlayamazdık. İsterseniz "pause" satırlarını silip, işlemi yeniden başlatabilirsiniz ve programın hangi hız ile ilerlediğini görebilirsiniz. (veya göremezsiniz)



« Son Düzenleme: 05 Mayıs 2013 - 20:28:27 Gönderen: ekremsenturk »

« Yanıtla #3 : »
Daha fazla renk kullanalım

Basic 256 da sabit renkler dışında isimsiz renklerde var. Bu renkler farklı renk ton'larının karışımı ile elde edilir ve varsayım olarak 16 Milyon renk destekler. Toplam üç ana renk var ve bu renklerin her birinin 256 farklı ton'u var. Kısaltılmış olarak "RGB" olarak bilinen bu renkler, Kırmızı, Yeşil, Mavi tonlarından oluşur. (Fizik'tede üç renk vardır ve bunlar Kırmızı, Sarı ve Mavi'dir. Yeşil ise Mavi ve Sarı'nın karışımıdır)

Şimdi bazı renk karışımlarını deneyelim.

clg
color 0,0,0
rect 100,100,100,100


Bu örnekte uç renk olan siyah elde ettik

clg
color 255,255,255
rect 100,100,100,100


Bu örnekte ise diğer uç renk olan beyaz'ı keşf ettik. Görsel alanımızın zeminide zaten beyaz olduğundan, hiç bir değişiklik olmamış gibi bir durum oldu bizim için.

clg
color 0,100,100
rect 100,100,100,100


Şimdi Türkiz elde ettik.

clg
color 100,0,0
rect 100,100,100,100


Ve bordo'yuda keşf ettik. Böyle bu şekilde istediğiniz kadar denemeler yapabilirsiniz ve yeni renk ton'ları keşf edebilirsiniz. Kullanabileceğiniz rakamlar 0 dan başlar ve 255 e kadar çıkabilirler. Toplam olarak ise 256 eder.

Matematik :

print 20 * 5

print 20 + 5

print 20 - 5

print 20 / 5


Çarpma, Toplama, Çıkartma ve Bölme işlemlerinden birer örnek gördük.

Değişkenler :

Değişkenler, programlarımızda bir değer için yer ayırırlar. Bir değişkenin var olabilmesi için,önce bir isminin olması gerekir. Değeri ise sonra da atanabilir veya gerekliliğe göre değişebilir.

sayi = 10
print sayi


Değişkenlerin isminde Türkçe karakter kullanamıyoruz, ancak isim seçmekte özgürüz.

a = 12
b = 24
print a + b


veya

a = 12
b = 24
c = a + b
print c


Değişkenlere kelimelerde atayabiliriz. Ancak değişkenleri bir "$" işareti ile tanımlamalıyız ve kelimeler hesaplanamazlar.

isim$ = "Ayşe"
print isim$


Kelimeleri " " içinde yazmalıyız ki, Basic 256 bu kelimenin bir bütünlük olduğunu algılayabilsin.

isim$ = "Ayşe"
soyad$ = "Avcı"
print isim$ + soyad$


Rakam'larda " " içinde yazıldığında, kelime olarak geçerler ve değişkenide "$" ile tanımlı olması gerekiyor.

Rastgele rakam seçimi :

Basic 256 bizim için, verilen bir aralık içinden, rastgele rakamlar da seçip işleyebilir. Hemen bu özelliğini deneyelim.

print rand * 100

Bu örneğimiz bizim için, her çalıştırdığımızda, 0 ile 100 arası bir rakam gösterekcektir. ancak bu rakam virgüllü (Basic'te noktalı) bir rakam olacaktır.

cls
clg
r = rand*100
g = rand*100
b = rand*100
color r,g,b
rect 20,20,100,100
print r
print g
print b


Bu örnekte hem rekler her program çalıştırıldığında rastgele seçliyorlar, hem seçilmiş rakamlar yazılıyor. Rakamlarımızın virvüllü (noktalı) çıkmaması için, rakamları tam sayılara çevirmeliyiz

int

ile tanımlanan rakamlar sadece bütün rakam olarak çıkarlar. Bu kural hesap sonuçları için de geçerli olacaktır. Yanlış yerde kullanıldığında, hatalı sonuçlar elde edebiliriz.

print int(rand*100)

Şimdi işlemi her çalıştırdığımızda, 0 ile 100 arası, rast geletam rakamlar elde ederiz.

cls
clg
r = int(rand*255)
g = int(rand*255)
b = int(rand*255)
color r,g,b
rect 20,20,100,100
print r
print g
print b
say r
say g
say b


Bu örneğimizde ise rastgele seçilen renklerin "RGB" rakamlarını hem tam sayı olarak okuyabiliriz ve de ingilizce olarak duyabiliriz.

« Son Düzenleme: 07 Mayıs 2013 - 19:07:45 Gönderen: ekremsenturk »

« Yanıtla #4 : »
Döngüler

Döngüler ile bir işlemi tekrarlayarak uygulayabiliriz. Basic 256 da üç farklı dögü biliniyor

do - until döngüsü :

cls
a = 1
do
print "Merhaba"
a = a + 1
until a = 8


Bu döngüden önce bir değişken atamalıyız ve bu değişkenimizin değerini artırarak döngümüz içinde kullanmalıyız. Dögümüzün işleyişi, a eğişkeninn değeri sekize yükselene kadar Merhaba yazdırmaktan ibaret.

while - end while döngüsü :

cls
a = 5
while a < 8
print "Merhaba"
a = a + 1
end while


Bu döngümüzün işleyişide neredeyse aynı.Önce döngü dışında bir değişken atamalıyız ve değişkenin değerini döngü içinde artırmalıyız. Tek farkı ise, değişkenin değeri sekize çınkıncaya kadar değilde, değişkenin değerinin sekiz altında kaldığı sürece, işlemimiz Merhaba yazdıracaktır. değişkenimizin başlangıç değerinin, bu örneğimizde 5 olmasından dolayı, toplam üç kez Merhaba çıktısını alacağız. "<" işareti bu örnekte, büyük ve küçük tarafı tanımlamak için kullanılır.

for - next döngüsü :

En işlevsel ve en sık kullanılan döngüdür.

cls
for rakam = 0 to 100
   print rakam
next rakam


Bu döngüde değişken döngü içinde atanır ve de değeride iki farlı değer arasında belirlenir. Bu örneğimiz 0 dan 100 e kadar yazacaktır.

cls
for rakam = 0 to 100 step 10
   print rakam
next rakam


Aynı örneğimize bu sefer ek olarak, kaçar haneli sayacağını ekledik ve bu hali ile 0 dan 100 e kadar onar rakamlar ile yazacaktır.

cls
for rakam = 1 to 5
   print "Merhaba"
   pause 1
next rakam


for - next döngüsünün nasıl çalıştığını görebilmek için, işlemler arasına birer saniyelik bir bekletme ekledik.

Örnekler :

Şimdi bir de döngüler ile, ve de şimdiye kadar öğrendiklerimiz ile neler başarabileceğimizin bazı örneklerini görelim.


# rastgele renk seçimi
r = int(rand*255)
g = int(rand*255)
b = int(rand*255)
color r,g,b
rect 0,0,300,300



# Renkli kutucuklar çizer
clg
for x = 0 to 250 step 20
   for y = 0 to 250 step 20
      color x,y,x
      rect x,y,x,y
   next y
next x



# Değişen renkler
clg
for i = 1 to 255
   color i, i, 0
   rect 0,0,300,300
   color i, 0, 0
   line 10,20,290,20
   color 0, 0, i
   line 10,100,290,100
   color 0, i, 0
   line 10,180,290,180
   color i, 0, i
   line 10,260,290,260
next i



# Büyüyen Kare
clg
for i = 1 to 100
   color red
   rect 140-i,140-i,20+i*2,20+i*2
next i



# Balon
clg
r=int(rand*255)
g=int(rand*255)
b=int(rand*255)
for balon = 1 to 150
   color r,g,b
   circle 150,150,balon
next balon



# Balonlar
clg
for top = 10 to 300 step 5
   r=int(rand*255)
   g=int(rand*255)
   b=int(rand*255)
   color r,g,b
   circle int(rand*top),int(rand*top),50
next top



# Renkli çizimler yapar
clg
for x = 0 to 255 step 15
   for y = 0 to 255 step 15
      color x,y,0
      line 10,10,x,y
   next y
next x



# Rastgele çizimler
clg
r=int(rand*255)
g=int(rand*255)
b=int(rand*255)
for i = 1 to 300 step 20
   for j = 1 to 300 step 20
      color r,g,b
      line int(rand*i),int(rand*j),int(rand*i),int(rand*j)
   next j
next i



# Hareketli Kare
for i = 1 to 300
   color blue
   rect i,10,40,40
   clg
next i



# Hareketli toplar
clg
for tekrar = 1 to 10
   r=int(rand*255)
   g=int(rand*255)
   b=int(rand*255)
   k=int(rand*300)
      for top = 1 to 300
         color r,g,b
         circle top,k,20
         clg
   next top
next tekrar



# Rastgele noktalama
clg
r=int(rand*255)
g=int(rand*255)
b=int(rand*255)
for i = 1 to 300 step 5
   for j = 1 to 300 step 5
      color r,g,b
      plot int(rand*i),int(rand*j)
   next j
next i


Son örneğimizde kullandığımız bir yenilik ise

plot

"plot" ile yatay ve dikey koordinatların birleştiği noktada, sadece tek bir piksel'lik nokta yazar.




« Son Düzenleme: 07 Mayıs 2013 - 23:45:04 Gönderen: ekremsenturk »

« Yanıtla #5 : »
Müzik

Basic 256 ile Müzik bestelemek te mümkün. Nota'lardan anlıyor ve bir de iyi bir besteci olmanız yeterli.

sound 200,100

Bu satır çalıştırıldığında, bize bir dıt sesi verir.

sound 200,1000

Bu satır ise (sadece ikinci rakama bir sıfır daha ekledik) bize uzun bir dıııt sesi verir. İkinci rakam burada ses uzunluğunu temsil eder.

sound 600,1000

Satırın ilk sayısının ilk rakamını değiştirdiğimizde bize daha tiz bir ses verir.

sound 650,1000

Bu değişiklikten sonra, ses dahada tiz oluyor. Şimdi bir de biraz daha uzun bir örnek deneyelim.

# Müzik
sound 200,1000
sound 300,1000
sound 400,1000
sound 500,1000
sound 600,1000
sound 700,1000
sound 800,1000
sound 900,1000
sound 1000,1000
sound 900,500
sound 800,500
sound 700,500
sound 600,500
sound 500,500
sound 400,500
sound 300,500
sound 200,500


Bu örneğimizde, seslerin uzunluğunu ve de Frekansını nasıl değiştirebileceğimizi görüyoruz. Aynı seslseri farklı yazma olanağımızda var ve diğer yazım şeklinide biraz daha kısa bir örnek ile görelim.

# Müzik 2
sound {200, 1000, 300, 1000, 400, 1000, 300, 500, 200, 500 }


Bu yazım şekli ile daha az alan kullanıyoruz, ancak hangi rakamın hangi işlevi temsil ettiğini anlayabilmek zorlaşıyor ve hata gidermemiz gerektiğinde biraz zorlanabiliriz.


Söz ve Müzik birlikte kullanalım


# Büyük beste
sound 300,100
pause 0.4
sound 300,100
pause 0.4
sound 300,100
sound 290,200
pause 0.4
sound 300,150

pause 0.5
sound 300,100
pause 0.4
sound 300,100
pause 0.4
sound 300,100
sound 290,200
pause 0.4
sound 300,150

pause 0.5
sound 290,150
sound 300,200
pause 0.3
sound 300,100

pause 0.5
sound 300,100
pause 0.4
sound 300,100

pause 0.5
sound 290,150
sound 300,200
pause 0.4
sound 300,100

pause 0.5
sound 300,100
pause 0.3
sound 300,100

pause 0.5
sound 290,600

say "botsyn bou dunyyaaaaaaaaaaaaa"
pause 0.5
say "betsyn bou ruyaaaaaaaaaa"
pause 0.5
say "seewwwwwwmeejyyyyptaaaaa aaalldoootaaaaaaaanlaaaaarnnnnn"
pause 0.1
say "goooooesue koer olsoooooouuunn"





Mesaj tekrarı yüzünden mesajınız birleştirildi. Bu mesajın gönderim tarihi : 11 Mayıs 2013 - 22:24:12
Görüntü alanımıza yazı ekleyelim

Basic 256 ile görüntü alanınada yazı karakterleri aktarabiliriz.

text 10,10,"Merhaba"

Bu işlem için "text" kod'unu kullanıyoruz, ve yazmak istediğiiz kelime veua cümlenin önünede önce yazıyı yazmak istediğimiz konumu belirtiyoruz. İstersek rekli olarakta yazabiliriz.

color green
text 20,20,"Merhaba"


İstersek yazı tipi ve yazı boyutunuda seçebiliriz.

clg
color red
font "Ubuntu",20,60
text 40,40,"Merhaba"


Bu örneğimizde "font" kod'u ile yazı tipini seçtik. Sisteminizde hangi yazı tiplerini seçebileceğimizi, LibreOffice Writer'i çalıştırıp, yazı şeklinin belirtildiği çubuğun ok işaretini tıklayarak, çıkan seçeneklerden bulabiliriz. Bu örnekte ise "Ubuntu" varsayılan font'u seçmiş olduk. Farklı bir işletim sistemi kullanıyorsanız, bu seçim sadece standart bir yazı tipi yazdıracaktır. Yazı tipinin ardındaki rakamlar ise, ilk rakam yazı boyutunu, ve ikinci rakam da, yazı kalınlığını belirler. Yazının kalınlığı tabii boyutuna orantılı olacaktır. Mantısal olarak, hem çok küçük ve de hem çok kalın aolamayacktır.

clg
color red
font "Rachana",20,60
text 40,40,"Merhaba"
font "Arial",20,60
text 40,100,"Merhaba"
font "Arial",20,40
text 40,150,"Merhaba"
font "Arial",20,60
text 40,200,"Merhaba"
font "Arial",15,60
text 40,250,"Merhaba"


Bu örneğimizde yazı tipi farkı ile yazı boyutu ve yazı kalınlığı farklarını görebiliyoruz.


clg
color red
font "Norasi",20,60
text 40,40,"Merhaba"
font "Arial",20,60
text 40,100,"Merhaba"
font "URW Chancery L",20,60
text 40,150,"Merhaba"


Bu örneğimizde ise daha çok yazı tipleri arasındaki farkları görebiliyoruz.


clg
color red
rect 0,0,300,300
color blue
font "Purisa",20,60
text 80,120,"Merhaba"


Burada biraz daha farklı bir yazı tipini denemiş olduk.


« Son Düzenleme: 11 Mayıs 2013 - 22:24:12 Gönderen: ekremsenturk »

« Yanıtla #6 : »
Görüntü alanımızın boyutunu değiştirelim

Görüntü alanımızın boyutunu değiştirmekte mümkün. Bunu yine kod yazarak yapabiliriz. İstersek fare (mouse) imlecini kullanarakta alanları kaydırabiliriz, ancak görsel alan, kod'larımız ile belirlediğimiz boyutta, biz yeni bir kod yazana kadar sabit kalıyor. Ve biz küçültme işlemini, el ile kaydırarak, veya Basic 256 yı yeniden başlatarak düzeltmeliyiz.

# Görsel alanı büyütür
clg
graphsize 800,800
color yellow
rect 0,0,800,800
color cyan
rect 200,200,400,400


Bu örneğimizde görüntü alanımız 800 x 800 piksel boyutunda ve Basic 256 nını varsayılan boyutunun üstünde bir görünüme sahip. Görüntü alanını ve metin alanını, sağ üst köşelerindeki minik simgelerine tıklayarak, Basic 256 çalışma alanından ayırabiliyoruz ve tabii tekrar yine aynı simgeyi kullanarak birleştirebiliyoruz.

# Görsel alanı küçültür
clg
graphsize 200,200
color green
rect 50,0,600,600


Bu örneğimizde, görüntü alanınımzı küçültmüş olduk. Ancak görüntü alanımaıza eklediğimiz rekli kare'nin boyutu, küçülttüğümüz alanın üstünde. Bu durumda sadece görüntü alanımızın içinde kalan kısmını görebiliyoruz.

# Görsel alanı büyütür
clg
graphsize 500,500
color yellow
rect 0,0,500,500
for x = 400 to 100 step -50
   for y = 400 to 100 step -50
      color green
      circle rand*x,rand*y,10
   next y
next x
     


Bu örneğimizde, görüntü alanınımızı tekrar büyütmüş olduk. Görüntü alanı büyüdüğünde, düğer alanlar küçülmüş olurlar.


« Yanıtla #7 : »
Kaynakların daha verimli kullanımı

Görsel alanımızda çalıştırdığımız işlemler Bilgisayar'ımızın kaynaklarını daha fazla tüketiyorlar. Bunu biraz daha azaltmak için, Basic 256 da bir hızlandırıcı yöntemi mevcut. Önce normal işleyen bir örnek deneyelim.

# Kayan sarı top
clg
for top = 1 to 300
   color yellow
   circle top,150,40
   clg
 next top


Bu örneğimizde bir sarı küre'yi görsel alanımızda kaydırıyoruz.

# Kayan sarı top
clg
for top = 1 to 300
   color red
   rect 0,0,300,300
   color yellow
   circle top,150,40
   clg
next top



Şimdi sarı küre'yi kırmızı bir alanda kaydırıyoruz. Bu işlemler gerçekleşirken, her seferinde alan yeniden kırmızıya boyanıyor ve her seferinde yeni bir sarı küre, ayrı bir yerde yeniden çiziliyor. İşlemlerin görüntüsü de donanımınızın gücüne göre fazle net olmayabilir.

Aslında Bilgisayar'larımızın ekranlerıda aynı şekilde çalışmakta. buna görüntü yenileme deniyor. Ekranlarımız, gözümüzün fark edemeyeceği bir hız ile sürekli kendisini yenilemekte. Bunun anlamıda, ne kadar görsellik, o kadar güç tüketimi. Basic 256 da güç tüketimini azaltmak için yapılan işlem ise, her iki yenileme işleminin gerçekleşmesini, görsel alanımız içinde, sadece bir yenileme işlemi ile sınırlamaktan ibaret.

Aynı örneğimizin bir düzeltilmiş halini deneyelim.

# Çok hızlı kayan sarı top
clg
fastgraphics
for top = 1 to 300
   clg
   color red
   rect 0,0,300,300
   color yellow
   circle top,150,40
next top
refresh



Örneğimizi bu yeni hali ile çalıştırdığımızda, sadece son halini görebileceğiz. Kayma olayını göremeyeceğiz. Bunun nedeni ise, yaptığımız değişiklikten kaynaklanıyor. Yaptığımız değişiklikleri kısaca bir gözden geçirelim. İlk olarak, üçüncü satıra "fastgraphics" kod'unu ekledik. Bu kod, ekranın kendini yenileme işlemini, görsel alanımız içinde durduruyuor ve son satırdaki "refresh" kod'u okunum işleme alınana kadar bu durdurma işlemi sürüyor. Biz bu sebepten dolayı aradaki işlemi göremiyoruz. Diğer değişiklik ise "clg" kod'unun yerini değiştirdik.Bunun nedenide, son işlenen işlem "clg" olsaydı, işlemimizin son halinide hiç göremeyecektik. Çünkü "clg" kodunun temsil ettiği işlem, görsel alanı temizlemek.

Örneğimizi tekrar düzeltelim, ve son hali ile yeniden deneyelim.

# hızlı kayan sarı top
clg
fastgraphics
for top = 1 to 300
   clg
   color red
   rect 0,0,300,300
   color yellow
   circle top,150,40
   refresh
next top



Örneğimizi bu hali ile yeniden çalıştırdığımızda, işlem çok daha düzgün gerçekleşecektir. Bu düzeltmede "refresh" kod'unu "for" döngüsü içine aldık ve ekran yenileme artık her görsel alanımızın yenilemesi ile birlikte gerçekleşiyor. Bu da bize daha düzgün bir görüm ile birlikte, daha az kaynak tüketimi sağlıyor.


Şekiller

Basic 256 ile "line", "rect" ve "circle" kod'ları dışında, daha farklı şekilleri daha kolay çizebilmemizi sağlayan bir kod daha destekler.

clg
poly { 100,100,  200,200,  100,300 }


"poly" ile, içi dolu ve kapalı şekiller çizebiliriz. Bu işlemi "line" ile yapmış olsaydık, çizimi kapatabilmek için son iki rakam daha ekleme zorunda olurduk ve ayrıyetten içini ayrı boyamamız gerekirdi. "rect" ve "circle"de olduğu gibi, "poly" seçilen seçlin içini dolduruyor. İsterseniz son parametreler olarak 100,100 rakamlarınıda ekleyeblirdiniz ve üçgeni yazılı olarakta tamamlayabilirdiniz. Ancak "poly" ile çirdirdiğimiz şekillerde, Basic 256 bizim zaten kapalı bir şekil çizmek istediğimizi hesaplıyor ve son parametreleri kendisi otomatik olarak hafızada ekliyor. "poly"  ile çizeceğimiz şekillerin parametreleri, en az üç çift rakamdan oluşması gerekiyor. Ve tabii bütün rakamların bir x ve bir y çiftinden oluşması gerekiyor.

Diğer örnekler:

clg
color red
poly { 50,50,  200,50,  200,200,  50,200 }


clg
color green
poly { 50,100,  100,50,  150,100,  150,200,  100,250,  50,200 }







« Son Düzenleme: 13 Mayıs 2013 - 16:40:50 Gönderen: ekremsenturk »

« Yanıtla #8 : »
Resim içe aktarma

Basic 256 görüntülü dosyaların işlenmesinide destekler. Bu gün İnternet'ten bir dosya indirdim ve Resimler klasörüne kayıt ettim. Dosyanın adı, cicek.jpg ve boyutu 600 x 600 piksel. Şimdi bu dosyayı Basic 256 ile açalım.

clg
imgload 150,150,"Resimler/cicek.jpg"


Siz kendi Bilgisayarınızdan bir resim bulup "cicek.jpg" yerine kendi resminizin adını yazabilirsiniz, veya uygun boyutlu bir resimin adını "cicek.jpg" olarak değiştirebilirsiniz. Ben, aynı resimin sizinde Bilgisayar'ınızda var olduğunu varsayıyorum ve ona göre devam ediyorum.

"imgload" ile resimimizi "Resimler" klasörünün içinden, içe aktardık. Klasör yolu ve resim isminden önce gelen rakamların temsil ettikleri ise, görüntü alanımızın orta kısmı oluyor. Aynı anda resimimizin de ortası bu alana yerleştirilmiş oluyor. (Sol üst köşesi değil)

Resimimizin geçek boyutu, görüntü alanımızın boyutunu aştığından dolayı, biz im resimimizin sadece alanın içine sığan kısmı görüntülenebiliyor. Tamamını görmek istiyorsak, resimin boyutunu küçültebiliriz (veya büyütebiliriz) yada görünttü alanımzın boyutunu nasıl büyütebildiğimizi zaten daha önce işlemiştik.

clg
imgload 150,  150,  0.5,  "Resimler/cicek.jpg"


Burada yaptığımız tek değişiklik, resimimizin isim ve dosya yolunun önüne yeni bir rakam daha eklemek oldu. Ben aradaki fark daha iyi anlaşılabilsin diye, aralıkları biraz daha açtım, ama bu gerekli bir işlem değil. "0.5" rakamı burada görüntülenecek resmin boyutunu temsil ediyor. İstersek resimin boyutunu aynı şekilde büyütebiliriz. Meselâ "0.5" yerine "2" yazabiliriz ve resimimzin boyutunu 2 kat fazla görünümde gösterebiliriz.

clg
imgload 150,  150,  0.5,  pi,  "Resimler/cicek.jpg"


Burada yeni bir ilave daha yaptık. "pi" nin anlamı, Matematik'te, bir küre'nin çapı ile çemberi arasındaki sabit oran'ın adı. Yani 3.14 sabit oranını adı. Basic 256 yı bu kod'lar ile çalıştırdığımızda, resimimiz tersten görünüyor. "pi" yerine "pi*0.5" ekleseydik, resimimiz yan yatmış olarak görünürdü.

Kısaca öğrendiklerimizi bir toparlayalım. İlk iki rakam, x ve y parametreleridir (Yatay ve Dikey çizgilerin buluştuğu nokta) İkinci parametre (üçüncü rakam)  ise, görüntülenecek resimin boyutlandırma oranını temsil eder ve resim ismi ve dosya yolu öncesindeki son parametre (kullanıldığında) resimi dönürerek gösterir. Resimimiz, Resimler klasöründe değilde, kullanıcı dizinimizde bulunuyorsa, sadece "cicek.jpg" yazmamız gerekiyor.

clg
graphsize 600,600
imgload 300,300,"Resimler/cicek.jpg"


Şimdi resimimizi tam boyut ve tam görünümde görebiliyoruz. Bir de ilk parametreleri değiştirerek, reimimizi köşeye kaydırılmış olarak görüntüleyelim.

clg
graphsize 600,600
imgload 500,500,"Resimler/cicek.jpg"


Resimimizin merkezini 500x, 500y koordinatına kaydırmış olduk (Yani sağ alt köşeye) ve şimdi sadece bir ucunu görebiliyoruz. Tabiisizin kullandığınız resimin boyutları farklı olabilir ve kullanacağınız koordinatları da, isterseniz farklı yazabilirsiniz.



« Yanıtla #9 : »
Hareketli resimler

İnternet'ten yeni bir resim ndirdim. Adı "mozilla-firefox-1.png", boyutu ise 48 x 48 piksel. Bu resimi yine, Resimler klasörüne kopyaladım.

spritedim 1
spriteload 0 ,"Resimler/mozilla-firefox-1.png"
spriteshow 0


Bu kod'ları çalıştırdığımızda, resimimizin sadece bir kısmı, görüntü alanımızın sol üst kısmında görülecektir. Önce kod'larımızın anlamlarını öğrenelim.

İlk satırdaki "spritedim" ile görüntü alanımıza kaç resim ekleyeceğimizi belirttik. Sadece bir resim kullanılacak. İkinci satırda ise kullanılacak toplam bir resimden, ilk olanının ve adını (ve dosya yolunu) belirtiyoruz ve de yüklüyoruz. Burada rakam olarak "1" değilde "0" kullanmamızın nedeni ise, Basic 256 nın saymaya bir'den değil de sıfır'dan başlıyor olması. Üçüncü satırda ise yüklediğimiz toplam bir resimden ilk'i olan "0" nolu resimi görüntülüyoruz. Neden yüklenen resim, aynı anda görüntülenemiyor ? sorusu aklınıza takılabilir. Bunun nedeni ise, yüklü ve işlem gören bir resimin görünür olmamasını tercih ettiğimiz durumlar olabilir. Birazdan olacağı gibi.

clg
spritedim 1
spriteload 0 ,"Resimler/mozilla-firefox-1.png"
spriteplace 0, 100,100
spriteshow 0


Şimdi kod'larımıza bir ilave yaptık (ilk satırdaki clg dışında) "spriteplace" ile "0" numaralı resimizi "x 100, y 100" kordinatına yerleştirdik. Ve kod'larıızı çalıştırdığımızda, Firefox simgemiz, tam görüntülenebilir bir şekilde, görüntü alanımızın ortaya yakın bir kısmına yerleşmiş oldu. x ve y koordinatlarına, daha önveki resimli işlemimizde olduğu gibi, resimin ortası yerleşiyor. Sol üst kısmı değil.

clg
spritedim 1
spriteload 0 ,"Resimler/mozilla-firefox-1.png"
spriteplace 0, 100,100
for x = 0 to 20
   spriteshow 0
   spritemove 0, x, 0
   pause 0.1
next x


Şimdi bir kaç kod satırı daha ekledik ve Firefox simgemizi hareketlendirdik. Simgemiz "spritemove" ile belirlenmiş yöne doğru hareket ediyor ve de hareket ederken, ardında iz bırakıyor. Biz bu izden, Simgemizin her hareketinin bir piksel boyutunda değilde, simgenin yarı çapı boyutunda olduğunu algılayabiliyoruz. Bu durmda 48x48 yarısı olan 24 piksel. "spritmove" koordinatını 0, x, 0" yerine "0, x, 5" ile değiştirelim ve bu sefer nasıl hareket ediyor bir görelim. Bu sefer simgemiz kendi yarı çapının 5 katı aşağıya doğru ve bir kavis çizerek ilerliyor.

clg
spritedim 1
spriteload 0 ,"Resimler/mozilla-firefox-1.png"
spriteplace 0, 100,100
for x = 0 to 20
   clg
   spriteshow 0
   spritemove 0, x, 5
   pause 0.1
next x



Şimdi yeni bir "clg" satırı ile, iz bırakmasını önleyelim. Artık görüntü alanımızda bir iz bırakmıyor. Ancak, .png formatlı resimle, diğer bildiğimiz resimler gibi dört köşelidirler. Diğer resimerden farklı olarak, boş alanlar görünmüyorlar. Ama bu örneğimizde, önceki resim silinmiş olsa bile, .png resmi inçinde kalan bir önceki Firefox simgesinin izi görüntüleniyor. Şimdi o izi de kaldıralım.

clg
spritedim 1
spriteload 0 ,"Resimler/mozilla-firefox-1.png"
spriteplace 0, 100,100
for x = 0 to 20
   clg
   spriteshow 0
   spritehide 0
   spritemove 0, x, 5
   pause 0.1
next x


"spritehide" kod'u ile o iz de artık görünmüyor. Sprite olarak adlandırılan resimlerden aynı anda bir'den fazlası, görüntü alanında bulunabilirler. Bunlar farklı resiler olabileceği gibi, farklı numaralar taşıyan aynı resim de olabilirler.


« Son Düzenleme: 16 Mayıs 2013 - 14:54:02 Gönderen: ekremsenturk »

« Yanıtla #10 : »
Kullanıcı girişlerinin işlenmesi

Basic 256 programlarımız klavyeden yapılan girişleride işleyebilirler. Bu şekilde, Program akışını kullanıcı tarafından yönlendirmesi sağlanabilir.

input a
print a


Bu kodları çalıştırdığımızda, Basic 256 bizden bir seyler yazmamızı bekler. Biz de adımızı yazalım ve alt satıra inelim. Göreceğimiz sonuç ise "0" olacaktır. bunun nedeni ise "input" kod'unun ardına eklediğimiz "a" değişkeni sadece rakamları temsil eder ve adımızın rakam olarak değeri de "0"dır. İşlemimizi tekrar başlatıp, bu sefer bir rakam girelim, ve göreceğiz ki, bu sefer girdiğimiz rakam, bir alt satıra tekrar yazılmış.

input a$
print a$


Şimdi kod'larımızı biraz değiştirdik ve "a" değişkenine "$" simgesini ekledik. Şimdi ismimizi yazalım ve bir alt satıra inelim. Gördüğümüz gibi, artık ismimizi veya yazdığımız her hangi bir kelimeyi yada rakamı, bir alt satırda, ikinci kez yazılmış görebiliriz. Ancak rakamlar bu durumda bir sayısal değeri olan rakamlar değil, bir harf gibi işlenirler.

print "Lütfen ad ve soyad girin"
input "adınız :",a$
input "soyadınız :", b$
print a$ + " " + b$


Bir de bu örneği deneyelim ve kullanıcı girişleri nasıl işleniyor görelim. Burada iki kullanıcı girişi "print" kod'unun sonuna birlikte ilave ettiğimizde, tek satırda görünürler. Her iki giriş, normalinde birleşik görüntüleneceğinden, bia aray bir boşluk ilave ettik.


İşlemler arası seçimi

Basic 256 işlemler arasında seçim yapabilmeyide sağlar. Bunu yapabilmek için yine kullanıcı girişlerinen yaralanıyoruz ve bu girişlleri, önceden belirlenmiş şartlara göre değerlendiriyoruz.

print "1 ve 10 arası bir rakam girin"
input a
if a = 1 then print "bir"
if a = 2 then print "iki"
if a = 3 then print "üç"
if a = 4 then print "dört"
if a = 5 then print "beş"
if a = 6 then print "altı"
if a = 7 then print "yedi"
if a = 8 then print "sekiz"
if a = 9 then print "dokuz"
if a = 10 then print "on"


Bu örneğimizde "a" değişkenine, kullanıcı girişi ile atanan rakamlar arasından, 1 ve 10 arasında olanları bir koşul olarak tanımlayıp, bir işleme yönlendiriyoruz. Bu örneğimizdeki işlemler, rakamın yazılmasından ibaret.

print "lütfen bir ve 10 arası bir rakam giriniz"
input a
if a = 1 then
    print "Bir yazdınız"
else
print "Bir'den yüksek bir rakam yazdınız"
endif


Önceki örneğin biraz farklı olanı bu örnekte ise sadece bir rakamı girildiğinde, rakamın adı yazılıyor, farklı bir rakam girildiğinde ise, bir rakamında daha yüksek bir rakam girildiğini yazacaktır.

İki örnek arasında, iki önemli fark var. Birincisi ise, "if" ile başlayan satır bölünmüş ve yönlendirilen işlem bir alt satıra eklenmiş. İkinci fark ise "else" kod'unun eklenmiş olması. "else" kod'u sadece if satırı bölünmüş ise kullanılabiliyor ve "else" satırı sadece "if" satırındaki (veya "if" satırlarındaki) koşul uygulanamadığında işleme geçiyor. Ve "else" ile sonuçlanan "if" işlemlerinin sonlanmasını sağlamak için, işlelerin bittiği satıra bir "endif" satırı eklenmesi gerekiyor.

input "Muz, Elma, Armut, Hangisi ? ", a$
if a$ = "Muz" then
   print "Sarı kabuklu bir meyve çeişidi"
else
if a$ = "Elma" then 
   print "Kırmızısı, yeşili ve sarısı olan bir meyve"
else
if a$ = "Armut" then
   print "Ampule benzer bir meyve çeşidi"
else
   print a$ + " ? Bunu seçemezsiniz"
endif
endif
endif


Bir'den fazla "if" satırı kullanıldığında, "if" satırları kadar "endif" kullanılması gerekiyor. Ve bölünmüş "if" (çok satırlı) satırlarının her bir sonrakinin başına bir "else" eklenmesi gerekiyor. "if" satırları, her biri tek satırdan oluşuyorsa, önceki örneklerde gördüğümüz gibi, "else" kod'unu kullanmamıza gerek kalmıyor.


Program içinde tekrar kullanılabilir bölümler

Basic programlarının en bilinen özelliklerinden birisi, aynı program içinde bir işlem bir den fazla kez kullanılacak ise, her seferinde bu işlemin kod'larını yeniden yazmak yerine, sadece bir kere yazıp, o kod'ları programın farklı bölümlerinden kullanılabilmesidir. Aynı şekilde, kullanıcıya bir dizi işlemler arasında seçim yapabilmeside bu şekilde sağlanabiliyor. Bunu yapılabilmesi için, tekrar kullanılabilecek kod'ların bulunduğu alanın tanımlanması ve sınırlanması gerekiyor.

print "İki rakamı hesaplama için bir seçim yapınız"
print "Toplama için        t"
print "Çarpma için        ç"
print "Bölme için           b"
print "çıkartma için       e"

input a$

if a$ = "t" then goto toplama
if a$ = "ç" then goto carpma
if a$ = "b" then goto bolme
if a$ = "e" then goto cikarma

toplama:
input "ilk rakam :", a
input "ikinci rakam :", b
print  "Toplam = " + (a+b)
end

carpma:
input "ilk rakam :", a
input "ikinci rakam :", b
print "Toplam = " + (a*b)
end

bolme:
input "ilk rakam :", a
input "ikinci rakam :", b
print "Toplam = " + (a/b)
end

cikarma:
input "ilk rakam :", a
input "ikinci rakam :", b
print "Toplam = " + (a-b)
end


Bu örneğimizde, kullanıcıya, birinci bölümde önce, seçenekler hakkında bilgi veriyoruz ve ardından bir kullanıcı girişi bekleniyor. Kullanıcının girişine göre işlemler, adı ile belirlenmiş bölümlere yönlendiriliyor. Belirlenen isimlerin içinde Türkçe karakterler bulunmaması gerekiyor ve isimlerin sonuna ":" (çift nokta) ekleniyor. Bu şekilde Basic 256 bu bölümlerin adreslanabilir (çağrılabilir) bir bütün olduklarını anlayabilir. Bölümlerin son bulduğu satırları ise bir "end" kod'u belirler. Tanımlanmış bölümlere ulaşmak için ise "goto" veya "gosub" kod'ları ile ulaşılır. "gosub" ile ulaşılan bölümlerin sonu "return" ile sonlanması gerekiyor ve "gosub" ile ulaşılan bölümlerden, bölümün çağrıldığı satıra dağilde, bir sonraki satıra geri dönülür ve program kalıdığı yerden devam eder. "goto" ile çağrılan bölümler, işlem bittikten sonra, programı sonlandırırlar.

print "Lütfen kimlik bilgilerinizi giriniz"

input "Ad ve Soyad :", a$
gosub islem

input "Dğum tarihi :", a$
gosub islem

input "Adresiniz :", a$
gosub islem

input "Mesleğiniz :", a$
gosub islem

print "Kimlik bilgileriniz işleme alınmıştır"

islem:
print a$
return


Bu öernekte ise bir "gosub" işlemimin nasıl çalıştığını görebiliriz ve anlayabiliriz.


« Son Düzenleme: 24 Mayıs 2013 - 16:44:56 Gönderen: ekremsenturk »

« Yanıtla #11 : »
Diziler

Bir dizi aynı türden veriyi işleyebilmek için, bunları bir ortak değişkene atayabiliriz. Dizi içindeki verilerin ayırt edilebilmesi için ise, dizi içindeki konumu ile çağrılabilirler. Basic saymaya "0"dan başlar ve dizi içindeki veilerin sayısı "5" ise, dizi içindeki son verinin konum numarasıda bu durumda "4" oluyor.



dim a(5)
a[0] = 12
a[1] = 0
a[2] = 23
a[3] = 32
a[4] = 7
print a[0]
print a[1]
print a[2]
print a[3]
print a[4]



Bu örnekte a değişkenine "dim" kod'u ile "5" adet değer atanmış. "dim" değişkene bir değer atamaz, sadece boyutunu değiştirir ve hafızada alan ayırır. "dim" ile tanımlanan değişken isimleri bir ikinci kez programın başka bir yerinde bşka bir değişken için kullanılamazlar. Örneğimizde "a" değişkeni içi beş değer atıyoruz ve ardından bu değerleri "print" kod'u ile yazdırıyoruz.



dim a$(5)
a$[0] = "12"
a$[1] = "Merhaba"
a$[2] = "Günaydın"
a$[3] = "5 + 5 = 10"
a$[4] = "Naber ?"
print a$[0]
print a$[1]
print a$[2]
print a$[3]
print a$[4]



İkinci örneğimiz, ilk örneğin biraz farklı olanı. Bu örnekte, rakamlar yerine kelimeler kullandık.



dim meyve$(5)
meyve$ = {"Armut","Elma","Kiraz","Ayva","Muz"}
print meyve$[3]



Üçüncü örneğimizde ise  "dim" ile tanımladığımız değişkenimize, yine beş farklı değer atadık, ancak bu sefer biraz daha az zahmet ile, değerleri süslü parantezler içinde atadık ve "print" kod'u ile sadece "3" numaralı değeri yardırıyoruz. Basic 256 saymaya "0" dan başladığından dolayı ise "3" numaralı değer, sıradaki üçüncü değer değilde, dördüncü değer oluyor.

Kod: [Seç]
dim meyve$(5)
meyve$ = {"Armut","Elma","Kiraz","Ayva","Muz"}
for x = 0 to 4
   print meyve$[x]
next x


Bu sefer tüm değerleri bir for dögüsü ile alt alta yazdırıyoruz.

dim a(10)
a = {12, 16, 17, 23, 0, 1, 6, 9, 8, 123}
print a[0] + a[5]




Bu örneğimizde ise "a" değişkenine atanan rakamlardan iki değeri topluyor ve toplamlarının sonucunu yazdırıyoruz.

Kod: [Seç]
dim meyve$(5)
dim fiyat(5)
meyve$ = {"Armut","Elma","Kiraz","Ayva","Muz"}
fiyat = {12, 5, 3, 98, 3}
for x = 0 to 4
      print meyve$[x] + " ";
      print "Fiyat : " + fiyat[x] + " TL"
next x


Şimdi iki farklı dizimiz var ve bir bu dzi içindeki verileri, her bir diziden aynı sırada olanları, birinci diziden olanı önce olmak üzere, yanyana yazdırıyoruz. Bunu yapabilmek için "print meyve$" den sonraki eklediğimiz boşluk yanında ilave ettiğimiz ";" (noktalı virgül) kullanıyoruz. Basic'te noktalı virgül, satır sonun, alt satıra geçişi engelliyor. Bu örnek daha çok Manav'ların işine yarar.

« Son Düzenleme: 24 Mayıs 2013 - 11:58:06 Gönderen: ekremsenturk »

« Yanıtla #12 : »
Dosya'ya yazmak ve dosya'dan okumak

Basic 256, dosyalara sadece programlarımızın kod'larını, daha sonra tekrar kullanabilmek amacı ile, kayıt edebilmek ile sınırlandırılmış değil. Dosyalara, programlarımız içinden de erişebiliriz ve kayıtlı verileri okuyabiliriz, veya veri kayıt edebiliriz. Okumak ve kayıt etmek, iki farklı işlem olarak gerçekleşirler. İlk olarak veri kayıt etmeyi (yazdırmayı) ele alalım.

open "selam.txt"
writeline "Merhaba"
close


İlk örneğimizin kod'ları: "open" ve dosya adı ile bir dosya açıyoruz. Belirtilen isimde bir dosya yoksa, önce aynı ismi taşıyan bir boş dosya oluşturulur. İkinci satırdaki "writeline" kod'u ile belirtinen kelimeyi veya cümleyi bir satıra yazar. Son satırdaki close kod'u ise, dosyayı, işlemler sonlandıktan sonra kullanımdan kapatır. Bu şekilde dosya, üzerine bir veri yazılmış olarak, disk'e kayıt edilmiş olur.
Programı her çalıştırdığımızda, aynı dosyaya yeni bir satıra aynı kelime (veya cümle) yazılır. Bu örneğimizde ise her seferinde, yeni bir satıra "Merhaba" yazılacaktır.

open "hatir.txt"
write "Naber"
close


İkinci örneğimizde ise dosya adını değiştirdik. Bu örneğimizi çalıştırdığımızda, yeni bir dosya açılacak ve bu sefer kullandığımız kelime olan "Naber" yazılacaktır. İkinci örneğimizdakiikinci değişiklik ise, "writeline" yerine "write" kod'unu kullanmış olmamız. Bu programı her seferinde yeniden çalıştırdığımızda, "Naber" kelimesi her seferinde yeniden dosyamıza eklenecektir. Ancak bir fark ile. "Naber" kelimesi her seferinde yeni bir satıra değil, aynı satırda devam ederek, ard arda kayıt edilecektir.

open "selam.txt"
a$ = readline
print a$
close


Üçüncü örneğimizde ise ilk dosyamız olan "selam.txt"i önce programımız içinden okuyup, sonrada yazdırıyoruz ve kendimizde okuyabiliyoruz. İlk satır yine adı geçen dosyayı açıyor ve ikinci satırımızda, önce bir değişken tanımlıyoruz, ardından değişkenimize değer olarak "readline" kod'unu atıyoruz. Ve bir sonraki satırda da "print" ile değişkenimize "realine" kodu ile atanmış olan satırn tamamını yazdırıyoruz. Bu durumda satırda sadece bir kelime var. Ve son işlem olarak, dosyayı kapatıyoruz.

open "uzunhikaye.txt"
writeline "Bu hikâye uzayıp gider"
writeline "Hikâyenin konusu ise, uzun imce bir yol"
writeline "Bu yol neredeymiş sorusuna isteyenlere"
writeline "cevabım hazır"
writeline "Yol bizim köyde"
writeline "Hani şu, hiç gitmesekte, görmesekte"
writeline "bizim olan köy"
close


Şimdi uzun bir örneğimiz var ve örneğimizde, dosyaya yazılacak her bir satır için bir "writeline" kod'u yazıyoruz.

open "uzunhikaye.txt"
a$ = readline
b$ = readline
c$ = readline
d$ = readline
print a$
print b$
print c$
print d$
close


İkinci uzun örneğimizde ise, ilk uzun örneğimizin kayıt ettiği dosyayı okutup, yazdırıyoruz. Her okunacak satır için bir "readline" kod'u,ve yine her yazdırılacak, okunmuş satır için de yine, bir "print" kod'u (satırı) kullanıyoruz.

open "uzunhikaye.txt"
a$ = read
b$ = read
c$ = read
d$ = read
print a$
print b$
print c$
print d$
close


Bu sefer "readline" kod'unu "read" kod'u ile değiştirdik. Şimdi programımız sadece kelime, kelime okuyor. Ve tabii ki yazarken de sadece okunan kelimeliri yazabiliyor. "readline" ise tüm satırı okuyordu.

open "uzunhikaye.txt"
while not eof
   a$ = readline
   print a$
end while
close


Dosyamızı her seferinde satır, satır okutup, yazdıracağımıza, bir döngü ile de okutup, yazdırabiliriz. Dosyanın kaç satır olduğunu bilmiyorsak, bu örneğimizde olduğu gibi, bir "while" dögüsü kullanabiliriz. "while" satırına eklediğimiz "no" ve "eof" kod'larının işlevleri ise: "not" koşul sağlanmamışsa anlamına geliyor, "eof" dosya sonu, anlamına geliyor. Dosyanın sonuna ulaşılamadığı sürece, okutma ve yazdırma işlemleri devam etsin şartı ile başlatılmış bir döngü.

open "uzunhikaye.txt"
while not eof
   a$ = read
   print a$
end while
close


Aynı dögüyü bir de "readline" yerine "read" kullanarak deneyelim. Bu sefer satırlar yazdığımız gibi değilde, her bir kelime, ayrı bir satırda yazılmış olarak çıkacaktır.


« Yanıtla #13 : »
Çok güzel bir kaynak olmuş. Elinize sağlık :)
Sevdiklerine sevdiğini söyle çok geç olmadan.

« Yanıtla #14 : »
Ben de aslında gerçekten teşekkür edecektim oluşturulan kaynaktan dolayı, önceden de dikkat etmiştim verilen emeğe fakat teşekkür ederek seriyi bozmak istememiştim =)=) Hazır seri bozulmuşken yani farklı bir ileti de gelmişken ben de dile getireyim, elinize sağlık gerçekten. Yönetim tarafından bizim iletiler silinirse de çok hoş karşılarım =) 

Kolay gelsin.
".NET çemberinden geçen lirisist etkisi bir 'Volcano', bir yüzüm Java bir yüzüm Badalamenti Don Tano"
----------------------------------------------------------------------------------------------------------------------
"Her yer ölüm yine, burası dünya
 Derken ölüm bile bu nasıl dünya?
 Benden ölüm dile, batıyor gün yine
 Burası dünya?

« Yanıtla #15 : »
Ses dosyalarının işlenmesi

Basic 256 ile sesli, yazılı ve görüntülü çıktı aldık. Dosyaya yazdık ve dosyadan okuduk, Müzik besteledik ve görüntülü dosyalar (resimler) kullandık. Şimdi bir de ses kayıdı içeren dosyalar işleyelim. Ubuntu için uyarlanan sürüm .ogg uzantılı dosyaları destekliyor. İnternet'ten bir kısa süreli .mp3 uzantılı dosya indirdim ve bu ses dosyasını soundconverter programı ile .ogg uzantılı bir ses dosyasına dönüştürdüm.
Dosyamın yeni adı: "Demi_Lovato-Heart_Attack.ogg" Siz isterseniz kendi cep telefonunuzdan bir Melodiyi Bilgisayar'a aktarıp, dönüştürebilirsiniz, veya daha uzun süreli dosyalarda kullanabilirsiniz.

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"

Bu kod satırını çalıştırmak istediğimizde, hiç bir şey olmayacak. Çünkü Basic 256 sesli dosyaları, bir sonraki satırdaki işlem ile eşdeğer zamalı çalıştırıyor. (Font müziği olarak)

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
wavwait


Örneğimizi bu şekilde çalıştırdığımızda ise,ses dosyamız sonuna dek çalacaktır. "wavplay" ses dosyasını yükler, bir sonraki satırdaki kodların işlemleri ile birlikte, arka planda çalıştırır. "wavwait" ise ses dosyası ile diğer (takip eden) işlem arasındaki bağı (senkronizasyonu)
koparır ve sadece ses dosyası işlem görür (çalışır)

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
wavstop


Bu örneğimizde bu hali ile çalışmayacaktır. "wavstop" da yine ses dosyası ve ardından takip eden işlem arasındaki bağı koparır, ancak bu sefer ses dosyası işlenmeden, takip eden işlem devam eder. Yani Font müziği kesilir.

Şimdi Font müzikli işlemlerin nasıl çalıştığını, bir kaç örnek ile inceleyelim.

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
for a = 1 to 10
   print "Lay lay lom"
   pause 0.5
next a


Bu örneğimizde bir for döngüsü, yarım saniyelik gecikmeler ile on kez "Lay lay lom" yazdırıyor ve arka planda ise şarkımız çalıyor. Döngü sonlandığında, müzik'te duruyor.

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
for a = 1 to 100
   print "Lay lay lom"
   pause 0.5
next a


Aynı örnekte, for döngüsünü 100 sefer "Lay lay lom" yazdıracak şekilde değiştirdik. Şimdi, benim kullandığım ses dosyası kısa süreli olduğundan, (cep telefonu melodisi) şarkı bittikten sonra,döngü bir süre daha devam ediyor.

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
wavwait
for a = 1 to 10
   print "Lay lay lom"
   pause 0.5
next a


Bu örnekte ise önce şrkı çalıyor ve ardından döngü başlıyor.

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
wavstop
for a = 1 to 100
   print "Lay lay lom"
   pause 0.5
next a


Bu örnekte, şarkı atlanıyor ve sadece dögü çalışıyor.

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
for a = 1 to 10
   print "Lay lay lom"
   pause 0.5
   wavstop
next a


Bu düzeltme ile ise, şarkını kısa bir ilk kısmı çalıyor ve ardında dögü sessiz şkilde devam ediyor ve bitiyor

wavplay "Müzik/Demi_Lovato-Heart_Attack.ogg"
for a = 1 to 10
   print "Lay lay lom"
   pause 0.5
   wavwait
next a


Son düzeltmemizde ise ilk "Lay lay lom" satırından sonra, şarkımız sonuna kadar çalıyor ve ardında, sessiz olarak, diğer "Lay lay lom" satırları yazılıyor.


« Yanıtla #16 : »
Fare imlecinin denetimi ( Sürükleme )

Basic 256 ile fare imlecinin konumu, görüntü alanı içinde belirlenebiliyor ve bu özellikten yararlanılabiliyor. önce sürükleme mod'unu inceleyelim.

while mouseb <> 2
   while mouseb = 1
      line 10, 10, mousex, mousey
   end while
end while


Burada iç içe iki "while" dögüsü içinde bir "line" satırı kullanıyoruz. Parametre olarak kullandığımız "10, 10," rakamları, başlangıç noktasını temsil ederken, "mousex" ve "mousey" kod'ları, fare imlecimizin konumlarını temsil eder. Her ikisi birlikte kullanılmak zorunda, çünkü birisi yatay konumu, ve diğeri dikey konumu temsil ederler.

"while" kod'ları ile birlikte kullandığımız "mouseb" ise fare'mizin sağ ve sol tuşlarını temsil ederler. "1" sol tuş, ve "2" sağ tuş. ( "0" tuş basılı değil ve de fare'nizin modeline göre "4" orta tuşu temsil eder )

İlk satırımızdaki "while" döngüsü, "2" yani sağ tuş basılı olmadığı sürece, işlem devam eder anlamını taşır. İkinci "while" döngümüz ise "1" yani sol tuş basılı olduğundaki işlevi belirtir.

Programımız, sol tuş basılı olarak, imleci görüntü alanı üstünde gezdirdiğimizde, "10, 10," başlangıç notası ile imlecin bulunduğu nokta arasında bir çizgi çizer. Sağ tuşa basyığımızda, programımız kapanır.

clg
fastgraphics
while mouseb <> 2
   color red
   while mouseb = 1
      line 10, 10, mousex, mousey
     refresh
   end while
end while



Aynı programımızı, bu örnekte "fastgraphics" kodu ile birlikte kullanalım. Bir de renk ekleyelim, kırmızı olsun. "fastgraphics ile birlikte kullandığımızda, ekran kendini yenilemediği için, program sonlandığında, önce görüntü alanı dışında bir yere sol tıklamamız gerekiyor, işlem sonucunu görebilmek için. Yani göremeden çiziyoruz. bunu önlemek için, ilave olarak, bir de "refresh" kodunu, ikinci while dögüsü içine ekledik. "refresh" kodu, görüntü alanımızın yenilenmesini sağlıyor.

clg
x = mousex
y = mousey
while mouseb <> 2
   color red
   while mouseb = 1
      line x, y, mousex, mousey
   end while
end while


Bu örneğimizde ise sadece başlangıç noktası her yeni başlattığımızda aynı noktada olmuyor.

clg
x = mousex
y = mousey
while mouseb <> 2
   color red
   if mouseb = 1 then line x, y, mousex, mousey
end while


Şimdi ise ikinci "while" döngüsü yerine bir "if" koşul satırı kullandık. Program yine aynı şekilde işliyor.

clg
x = 20
y = 20
while mouseb <> 2
   color red
   while mouseb = 1
      clg
      line x, y, mousex, mousey
   end while
end while


Ve şimdi sabit bir başlangıcı olan programımızın ikinci "while" dögüsü içine bir "clg" kod'u ekleyerek, her bir önceki çizimi siliyoruz. Bu durumda sadece son çizim göründüğünden dolayı, sanki, başlangıç noktası ve imleç arasında bir ip varmış ve iki nokta arasında geziniyormuş, izlenimi veriyor.

while mouseb <> 2
   color green
   if mouseb = 1 then plot mousex, mousey
end while


Bu kısa örneğimizde "line" yerine "plot" kullanıyoruz. Ve bu programımız bize farenin sağ tuşuna basana kadar, görüntü alanımıza resimler çizebilmemizi sağlıyor.


« Yanıtla #17 : »
Fare imlecinin denetimi ( Tıklama )

Şimdi bir de tıklama modunda fare imlecinin denetlenebilirliğinden nasıl yararlanabiliriz, görelim.

clg
while clickb <> 4
   text clickx, clicky, clickb
end while


Tıklama modunda, "mousex" ve "mousey" yerlerine "clickx" ve "clicky" kullanıyoruz. İlk örneğimizde, faremizin orta tuşunu kullanmadığımız sürece, "clickb" ile temsil edilen tuş hangisi ise, "text" kod'u ile, o tuşun adını tıkladığımız noktaya yazdırıyoruz. "clickb" ise "mouseb" ile temsil edilen tuşları tıklama modunda temsil ediyor.

clg
while clickb <> 0
   text clickx, clicky, "x"
end while


Örneğimizin değiştirilmiş halinde, her tıkladığımız noktaya "x" harfini yazdırıyoruz. İlk örneğimizde, işlemi durdurmak için, faremizin bir orta tuşu olmasa bile, sağ ve sol tuşlarına aynı anda basarak, durdurabiliyorduk. Şimdiki hali ile ikinci satırda "while" ile şart koştuğumuz tuş "0" olduğundan, "stop" simgesine basmamız gerekiyor.

clickclear
clg
cls
color red
rect 20,20,20,20
color green
rect 20,100,20,20
color blue
rect 20,180,20,20
while clickb <> 2
   if clickx and clicky = 20 then
      print "Kırmızı seçtiniz"
      clickclear
   else
   if clickx = 20 and clicky = 100 then
      print "Yeşil seçtiniz"
      clickclear
   else
   if clickx = 20 and clicky = 180 then
      print "Mavi seçtiniz"
   clickclear
   end if
   endif
   endif
end while


Yeni örneğimizde yeni bir kod ile daha tanıştık. "clickclear" ile önceki tıklamalar temizlenmiş oluyorlar. Yeni örneğimizde kullanmamış olsaydık, çıktılar sürekli olarak kendisini tekrarlamış olurlardı. Örneğimizde, farklı noktalara tıklandığında, farklı çıktılar alıyoruz. Ancak tıklanacak noktalar bu örneğizde "if" kod satırları ile belirlenmiş olduklarından, isabet ettirilemediği durumda, her hangi bir işlem yapılmıyor.

Seçilecek noktalar, her bir renkli karenin sol üst köşesi. İmleç, burada doğru piksel'e isabet etmek zorunda.

Belirli bir noktyı bulabilmek, hiç de kolay bir işlem değil. Biz bu nedenle, bir noktaya değilde, bir bölgeye tıklayarak işlemlerimizi başlatmak istersek, ne yapabiliriz ?

clickclear
clg
cls
color red
rect 100,100,50,50
while clickb <> 2
   if clickx and clicky > 100 and clickx and clicky < 150 then
      print "Merhaba"
      clickclear
   end if
end while


Bu örneğimizde bir bölgeyi belirleyebilmek için Mantıksal Operatör olarak tanımlanan işaretlerden yararlanıyoruz. Bu operatörlerin yaptıkları tek şey aslında, Bir değerden büyük veya bir değerden küçük olarak, piksel'lere verilen değerleri (yerleri) tanımlamak oluyor.

"<" sol taraf daha küçük anlamına geliyor. ">" sol taraf (ağızın açık olduğu taraf) daha büyük anlamına geliyor. "=" eşittir ve "<>" eşit değildir anlamlarını taşıyorlar. "and" ve anlamında kullanılır ve "or" (burada kullanmadık) veya anlamındadır.

Biz bu örneğimizde, görüntü alanımız içinde bulunan kare'nin piksel ölçümündeki yerini "belirlenen rakamdan daha fazla" ve "belirlenen diğer rakamdan daha az" olarak yerini tıklanacak nokta olarak belirlemiş olduk ve bu belirlenen alan içine tıklandığında, işlem gerçekleşiyor.

Şimdi, önceki büyük örneğimizi bu yeni yöntemimize göre yeniden düzenleyelim ve deneyelim.

clickclear
clg
cls
color red
rect 20,20,20,20
color green
rect 20,100,20,20
color blue
rect 20,180,20,20
while clickb <> 2
   if clickx and clicky > 20 and clickx and clicky <40 then
      print "Kırmızı seçtiniz"
      clickclear
   else
   if clickx > 20 and clickx < 40 and clicky > 100 and clicky < 120 then
      print "Yeşil seçtiniz"
      clickclear
   else
   if clickx > 20 and clickx < 40 and clicky > 180 and clicky < 200 then
      print "Mavi seçtiniz"
   clickclear
   end if
   endif
   endif
end while


Programımız artık yeni düzenlenmiş hali ile, görüntü alanı içindeki kare'lerden hangisi (sol) tıklanırsa, o kare'nin rengini yazdırıyor. Sağ tıklandığında ise Program sonlanıyor.




« Yanıtla #18 : »
Satır işlemleri

Bu bölümde, bir metin üzerinde ne tür işlemler yapabileceğimizi göreceğiz. İlk olarak rakamların veri türü olarak, alfabetik karakterler gibi işleme alınabilmesini sağlayalım.

a$ = string(100)
print a$


Bu örnekte, 100 rakamı, bir numerik karakter den, "string()" kodu ile ve parantezler içine alınarak  bir alfabetik (hesaplanamayan) karaktere dönüştürüldü. Tabii yazılırken yine "100" olarak yazılacaktır. Tüm alfabetik karakterlerin rakam olarak değerleri sıfır dır.

a$ = string(100)
b$ = string(50)
print a$ + b$


Şimdi iki dönüştürülmüş rakamı hesaplayalım ve nasıl bir sonuç alacağımızı görelim. İki rakam bu durumda hesaplanıp, sonucu bir çıktı olarak yazılacağına, yan yana yazılmış oldular.

input "Bir rakam gir ", a
input "Bir rakam daha gir ", b
print a + b
a$ = string(a)
b$ = string(b)
print a$ + b$


Bu örneğimizde, sizden iki farklı raakam girmeniz istenecek. Girdiğiniz rakamların toplama olarak sonucu ise, iki kez bildirilecek. İlk sonuç, doğru hesaplanan sonuç olacak. İkinci sonuç ise, girdiğiniz rakamlar harf karakteri olarak değerlendirilerek hesaplanacaklar ve girdiğiniz rakamlar yan yana yazılacak.

input "Bir rakam gir ", a
input "Bir rakam daha gir ", b
print a + b
a$ = string(a)
b$ = string(b)
print a$ + " " +  b$


Önceki örneğimizi biraz daha düzelttik ki, sonuçlar daha iyi anlaşılabilsin. İkinci sonuç için rakamlar arasına bir boşluk ekledik sadece.

print length("Merhaba")

"length()" kod'u ile bir kelimenin veya bir satırın karakter sayısı biriminde (boşluklar dahil) kaç karaketerden oluştuğunun çıktısını alabiliyoruz.

print length("Merhaba")
print length(" ")
print length("")
print length("120")


Burada farklı kelime veya satırların boyutunu çıktı olarak alıyoruz.

a$ = "Benim bir köpeğim var, adı Karabaş"
print length (a$)


Bu da bir başka örnek. Burada satırı önce bir değişkene atadık ve değişkeni parantezler içine (tırnaksız olarak) aldık.

a$ = "Benim bir köpeğim var, adı Karabaş"
print left (a$,4)


"left()" kod'u ise bir satırın veya kelimenin sol başlangıcından başlayarak, belirtilen rakam kadar karakterleri çıktı olarak veriyor.

print left("Merhaba",4)

Bu şekilde de yazılabilir tabii ki.

a$ = "Benim bir köpeğim var, adı Karabaş"
print left (a$,4)
print left (a$,12)


Bu örnek belki biraz daha açıklayıcı olabilir.

a$ = "Benim bir köpeğim var, adı Karabaş"
print right (a$,4)


"right()" kodu ile de uine aynı şekilde, bir satırın veya kelimenin sağ sonundan başlayarak ve belirtilen rakam kara karakterin çıktısı alınabiliyor.

a$ = "Benim bir köpeğim var, adı Karabaş"
print right (a$,4)
print right (a$, 12)


Daha açıklayıcı bir örnek.

a$ = "Benim bir köpeğim var, adı Karabaş"
print mid (a$,4,3)


"mid()" kod'u ile satırın ortasından başlanıyor ve orta olarak tam nereden başlanılacağı ilk rakam ile belirtiliyor, ikinci rakam, karakter sayısını belirliyor. "mid()" ile bu nedenden dolayı,iki rakam girilmesi gerekiyor.

a$ = "Benim bir köpeğim var, adı Karabaş"
print mid (a$,4,3)
print mid (a$,6,12)


Yine biraz daha açıklayıcı bir örnek.

a$ = "Benim bir köpeğim var, adı Karabaş"
print a$
print upper (a$)


"upper()"kod'u tüm harfleri büyük karakterlere dönüştürüyor.

a$ = "Benim bir köpeğim var, adı Karabaş"
print a$
print lower (a$)


"lower()" ile ise tam tersine, tüm karakterler (harfler) küçük harflere dönüştürülüyor.

a$ = "Benim bir köpeğim var, adı Karabaş"
print instr (a$, "kö")


"instr()" ise bir sarır veya kelime içinde bulunan karakterlerin veya hecenin rakam olarak yerlerini gösteriyor. Aranan karakterler satır içinde mevcut değillerse, "0" rakamı bildiriliyor.

a$ = "Benim bir köpeğim var, adı Karabaş"
print instr (a$, "Kö")
print instr (a$, "Karabaş")
print instr (a$, "baş")


Bu örrneğimizde aranacak olan ilk hece yanlış yazılmış. İlk harf küçük olması gerekirken, büyük yazılmış. Bu nedenle ilk çıktımız "0". Diğer çıktılar ise, aradığımız kelime veya hecenin, satır içinde kaçıncı sırada başladıklarını, rakam olarak yerini bildiriyorlar.




« Yanıtla #19 : »
Verileri dönüştürmek

Önceki konumuzda gördüğümüz gibi "string()" kod'u ile rakamları yazı karakterleri olarak temsil edilecek şekilde dönüştürebiliyoruz. Benzer bir şekilde tersini nasıl yapabileceğimizide bu bölümde görelim.

a$ = "Merhaba"
print int(a$)
print a$


Bu örneğimizde, önce "a$" değişkenine bir kelime atadık ve ardından "int()" kod'u ile bu kelimeyi bir tamsayıya dönüştürdük. Bir tam sayı olarak, ardında noktalı (virgüllü) ek rakamlar olmayan sayılar tanımlanır. Bu örneğimiz, "a$" değişkenine atadığımız kelimeyi, önce tam sayıya dönüştürülmüş hali ile ve ardından gerçek hali ile yazdırıyor. Harflerin sayı olarak değerleri, kelimenin uzunluğundan bağımsız olarak sıfırdır.

a = 12.7
print int(a)
print a


Bu örneğimizde ise bir küsürlü rakamı (yani noktalı/virgüllü rakamı) tam sayıya dönüştürdük. "int()" rakamları dönüştürürken sadece tam sayı kısmını var sayar ve küsüratı hiç değerlendirmez. Gerçek rakam 12.999 da olsa, tam sayı olarak değeri 12 olacktır.

a = -12.7
print int(a)
print a


Aynı örneği bir de eksi (sıfırın altında)  rakamlarla deneyelim. Sonuç yine aynıdır. Ancak biz programlarımızda rakamları yuvarlamak, ama hep küsüratlardan dolayıda zarara girmemek isteyebiliriz. Programımızın bir Muhasebe programı olduğunu varsayalım ve hep bu tür küsüratları yok saymaktan dolayı zarar etmeye başladığımızı düşünelim. Basic'te çareler tükenmez.

a = 12.7
print ceil(a)
print a


"ceil()" ile de rakamlar tam sayı olrak dönüştürülürler. Ancak "ceil()" küsüratlı rakamları hep bir sonraki sayıya yükseltir. Rakamın değeri 12.01 olsa bile.

a = -12.7
print ceil(a)
print a


"ceil()" eksi rakamlardada hep yüksek sayıyı seçer. Tabii eksi rakamların değer olarak yüksek olanı, daha düşük olanıdır ve bu nedenle bu sefer "ceil()" ile döüştürdüğümüz rakam 13 değil 12 olacaktır.

a = 12.7
print floor(a)
print a


"floor()" kod'u ise "ceil()" kodunun tersini yapar ve küsüratlı rakamlarda hep düşük olan sayıyı seçerek tam sayıya çevirir. İşte Muhasebenin işine ödemeler söz konusu olduğunda gelecek çözüm bu.

a = -12.7
print floor(a)
print a


Eksi rakamlar hesaplanırkende, "floor()" yine (değer olarak) düşük olan sayıyı tercih eder.

a = 12.8
print a
print abs(a)


Bir de "abs()" var. "abs()" tam sayılarla ilgilenez. Bu örnekte hiç değişen bir şey yok.

a = -12.8
print a
print abs(a)


Eksi rakamlar ile kullanıldığında, "abs()" rakamı gerçek değerine değilde, gerçek sayıya dönüştürür. Yani, uygulamada, hep sayıları artı sayılar olarak gösterir.

a$ = "Naber"
print a$
print float(a$)


"float()" ise "int()" kod'unun tersine her veriyi küsüratlı (noktalı) rakamlara dönüştürür. Tam sayılar ile hesaplamalrda, küsüratlar yok sayılacağından dolayı, hatalı sonuçlar çıkabilir.


« Yanıtla #20 : »
Haberleşme

Bilgisayarlar arasında haberleşmeyi, bu bölümde, temsili olarak iki açık Basic-256 programı ile uygulayalım. İlk olarak sağ taraftaki Basic-256 programına aşağıdaki kodları ekleyelim.

print netaddress()
netlisten 9999
netwrite "Merhaba"
netclose


İlk satırdaki "print" ve "netaddress()" kodları, Bilgisayarımız İnternete bağlıysa, İP adresimizi yazdırıyor. İkinci satırdaki "netlisten" ve ardındaki rakam ise, belirtilen Port girişini dinliyor. Üçüncü satırda kullandıüımız "netwrite" ve eklediğimiz kelime ise, bir mesaj gönderiyor. Tam olarak, yazdığımız mesajı göndermek için, belirttiğimiz port girişine bağlanacak diğer bir cihazı dinliyor ve bir bağlantı sağnalabilene kadar bekliyor. "netclose" kod'u ise, bağlantı sağlanabilip ve mesajımız iletilebildiğinde, işlemi sonlandırıyor.

Şimdi diğer Basic-256 programıza (bu da sol tarafta olsun) aşağıdaki kod'ları girelim ve çalıştıralım.

netconnect "127.0.0.1", 9999
print netread
netclose


İlk satırdaki "netconnect" kod'unun ardındaki ilk rakam, karşı temsili cihazın İP adresidir. İnternete bağlı değilsek "127.0.0.1" adresini kullanabiliriz. Bu işlemi gerçekleştiriken İnternet'e bağlıysak, diğer (sol) Basic-256 programımız gerçek İP adresimizi yazmış olacaktır ve biz orada belirtilen adresi kullanmalıyız. İkinci rakam ise Port girişini temsil ediyor ve bu port girişi ile diğer (sol) Basic-256 programının dinlediği port girişi yine aynı olmalı.
"netread" kodunun yaptığı işlem ise gelen mesajı okumak, ve biz bu mesajı "print" kod'u ile yazdırıyoruz ve yin "netclose" kod'u ile işlemi sonlandırıyoruz.

İsterseniz, gönderilen mesajı biraz değiştirelim ve tekrar deneyelim.

print netaddress()
netlisten 9999
a$ = "Merhaba "
    for i = 1 to 10
        netwrite a$
    next i
netclose


Burada yine aynı işlem geçekleşiyor. Sadece biraz değiştirdik ve mesajımızı on kez tekrarlatıyoruz.

Bilgisayarımızın bir ev olduğunu varsayalım. Evimizin adresi, İP adresimiz oluyor ve evimizin kapısı ise port girişimiz oluyor. Evimizin tam olarak 65536 kapısı var ve 0 dan başlayıp 65535 ile sonlanan numaraları var. Çoğunlukla ilk kapılar, giriş/çıkış için en sık kullanılanlar. Bu nedenle bu işlem için, mümkün olduğu kadar kullanılıyor olması olasılığının en düşük olduğu bir portu (port'ları) kullanın.


« Yanıtla #21 : »
Veritabanı işlemleri

Basic-256 nın desteklediği veri tabanı sqlite3 ( Bilgisayarınızda kurulu olması gerekmiyor ) Bir veri tabanı verilerinizi güvenli olarak saklayabilmek ve istediğinizde verilerinizi aradığınız kategorilere göre arayıp bulabilmenizi sağlar. İlk olarak bir veri tabanı dosyasını oluşturalım ve bir kayıt yapalım.

dbopen "deneme.sqlite3"
dbexecute "create table kelime (text)"
dbexecute "insert into kelime values ('Merhaba')"
dbclose


İlk satırda kullandığımız kod "dbopen" ile, tırnaklar içinde belirttiğimiz bir veri tabanı dosyasını açar veya böyle bir dosya yoksa, dosyayı oluşturur.
İkinci satırda kullandığımız "dbexecute" kod'u ise açılan dosya içinde işlem yapar. Yapılacak işlemler ise tırnaklar içinde belirtilmiştir. Bu durumda önce "creat table" ile bizim verdiğimiz isimde, (bu durumda "kelime") bir tablo oluşturulur. Parantez içindeki bilgi ise, tablo içine ekleyeceğimiz veri'nin türünü belirler. (bu durumda "text", yani metin)
Üçüncü satırımızda yine veri tabanı dosyası içinde işlem yapmaya devam ediyoruz ve "insert into" ile "kelime" isimli tablomuza "values" ile değerler ekliyoruz. (Bu durumda "Merhaba" kelimesi.)
Son satırda kullandığımız "dbclose" kod'u ile veri tabanı dosyasını kapatıyoruz. Tırnaklar içinde kullandığımız kod'lar bu durumda "print" kod'unda olduğu gibi çıktısını alabileceğimiz yazı karakterleri değiller. Bu durumda kullandığımız kod'lar, yabancı kod oluyorlar. Yani sqlite3 kod'ları.

Bu kod'ları çalıştırdığımız zaman, işlem bitiğinde, kullanıcı (Ev) dizinimizde "deneme.sqlite3" isimli ve okunaksız (derlenmiş) simge görünümünü andıran yeni bir dosya bulacağız. Şimdi bu dosyanın içindeki verileri nasıl okuyabileceğimizi görelim.

dbopen "deneme.sqlite3"
dbopenset "select ('kelime')"
while dbrow()
   print dbstring(0)
end while
dbcloseset
dbclose


Verileri okuyabilmemiz için, yeni bir program yazmamız gerekiyor. Bu programımızın veri okumada başarılı olması için, öncelile veri tabanı içinde barındılan tablonun ismini biliyor olmalıyız.

İlk satırda yine "dpopen" ve dosya adı ile veri tabanı dosyasını açıyoruz.
İkinci satırdaki "dbopenset" kod'u ile veritabanı içinde bulunan tabloyu açıyoruz. Açacağımız tabloyu ise tırnaklar içinde kullandığımız "select" ve tablo adı ile belirliyoruz.
"dbrow" kodu ile, bir "while" döngüsü ile birlikte kullanarak, tabloyu, sonuna kadar programımıza okutuyoruz.
Döngünün sonundaki "dbcloseset" ile tabloyu ve "dbclose" ile de yine veritabanı dosyasını kapatıyoruz.

Biraz daha gelişmiş bir örnek deneyelim.

dbopen "deneme2.sqlite3"
dbexecute "create table manav (integer, text, decimal)"
dbexecute "insert into manav values (1, 'Çilek', 2.65)"
dbexecute "insert into manav values (2, 'Armut', 3.92)"
dbexecute "insert into manav values (3, 'Ayva', 7.54)"
dbclose


Bu örneğimizde ikinci satırda "manav" isimli tablomuza üç farklı veri tipi (türü) atayoruz. "integer" tam sayıları temsil eder, "text" metin'i temsil eder ve decimal ise ondalık (diğer adı ile küsüratlı) rakamları temsil eder.
Üçüncü, dördüncü ve beşinci satırlarda "manav" isimli tablomuza farlı değerler ekiyoruz. Yazı karakterlerini tek tırnak içine almak zorunda olmamızın nedeni ise, daha önce belirttiğim gibi, bu durumda çift tırnak içine alına kod'lar Basic kod'ları değiller ve her ikinci bir çift tırnak, daha önce açılmaış olan bir başka çifttırnağı kapatıyor.

Şimdi yeni veritabanımızı okuyalım.

dbopen "deneme2.sqlite3"
dbopenset "select * from manav"
while dbrow()
   print dbint(0) + " " + dbstring(1) + " " + dbfloat(2)
end while
dbcloseset
dbclose


İlk okuma programımız ile şimdiki arasındaki fark, sadece okunacak verilerin türlerininde "while" döngüsü içindeki "print" kod'una eklenmiş durumda, ve yazılış sırasına göre bir de parantezler içinde numaralandırılmışlar. "dbint()" tam satıları temsil ederken, "debstring" metin'i (yazıyı) temsil ediyor ve dbfloat küsüratlı rakamları temsil ediyor. "+" ve çift tırnakları ise, veriler arasına boşluklar (" ") eklemek için ekledim.