Orta Seviye LUA Dersi

Mucotoo

Little Mouse

Değişkenler

Değişkenler veri saklayabilmemizi/tutabilmemizi sağlayan araçlardır.
Değişkenlerde bazı kısıtlamalarımız vardır. Eşittirden önceki kısımda (değişken) sadece ingilizce karakterler ve sayıları kullanabilirsiniz. Veri kısmında ise özgürsünüz, her türlü veriyi değişkende saklayabilirsiniz.
yaziDegiskeni = "bilgimiz" -- geçerli
sayiDegiskeni = 1 -- geçerli
"yazı" = "Sunucuma hoşgeldin" -- geçersiz (değişken yazı olamaz)
15 = "Yaşın kaç?" -- geçersiz (değişken sayı olamaz)
1yazi = "Merhaba LUA" -- geçersiz (değişken sayı ile başlayamaz)
öğrenci = "Ders çalışmalıyım" -- geçersiz (değişken türkçe harf içeremez)
yazi*1 = "Muzu severim" -- geçersiz (değişken matematiksel işlemler içeremez)

Yerel Değişkenler

Yerel bir değişken oluşturmak için değişkenin başına local eklemeniz yeterlidir. Bulunduğu fonksiyon, kontrol, döngü vb. içerisinde kullanılabilir. Alanı dışında kullanılırsa daha önceden verilmiş değer veya nil olur.
function mesajVer() -- mesajVer adlı bir fonksiyon oluşturduk
local mesaj = "mesajı veriyorum" -- yerel mesaj değişkenine "mesajı veriyorum" değerini verdik
print(mesaj) -- mesaj değişkenini yazdırdık
end
mesajVer() -- mesajVer fonksiyonunu tetikledik/başlattık
--> mesajı veriyorum
print(mesaj) -- mesaj değişkenini mesajVer fonksiyonu dışında yazdırmaya çalıştık
--> nil
if true then
local mesaj = "naber"
print(mesaj)
print--> naber
end
print(mesaj)
--> nil
for i=1,1 do
local sayi = i
print(sayi)
--> 1
end
print(sayi)
--> nil
Eğer bir değişkene fonksiyon dışında ve içinde ayrı değer verilirse ve fonksiyon(bu kontrol vs.de olabilir) içerisinde yerel değişken ise aşağıdaki gibi olur;
mesaj = "dışarda"
if true then
local mesaj = "içerde" -- burada yerel olarak değer verdik
print(mesaj)
--> içerde
end
print(mesaj)
--> dışarda
-- bu durum fonksiyon ve döngüler için de geçerlidir

[p=center]Veri Türleri[/p]

Sayı ( number , integer , float )
Kesirli sayılar ondalık kesir biçimine çevrilip, ondalık sayı olarak kullanılır.
print(1/10)
--> 0.1
LUA matematiksel işlemleri yapmamıza olanak verir.
print(2+2)
--> 4
print(2-7)
--> -5
print(7*8)
--> 56
print(7/8)
--> 0.875
Sayısal değeri bir değişkene atayıp, daha sonradan tekrar kullanabiliriz.
x = 7 -- x değişkenine 7 değerini verdik
print(x)
--> 7
Değer atadığımız değişkenin değerini daha sonradan değiştirebiliriz.
x = 7
x = x * 9 -- daha önceden 7 değerini verdiğimiz x i 9 ile çarptık
print(x)
--> 63
print(x*2) -- x in 2 katını yazdırdığımızda x in değeri değişmez çünkü x değişkenine yeni değer atamıyoruz, sadece kullanıyoruz
--> 126
print(x) -- değişmediğini kanıtlamak amacıyla
--> 63
Yazı (string)
LUA'da yazıları oluşturmak için "çift tırnak" veya 'tek tırnak' kullanabilirsiniz.
print("naber")
--> naber
Yazıyı bir değişkene atayıp daha sonradan kullanabiliriz.
hg = "hoşgeldin"
print(hg)
--> hoşgeldin
İki yazıyı birbirine iki nokta yani .. ile bağlayabiliriz.
hg = "hoşgeldin"
print("merhaba "..hg)
--> merhaba hoşgeldin
print("merhaba "..hg..", nasılsın?")
--> merhaba hoşgeldin, nasılsın?
İki yazıyı birbirine bağlamak için toplama işlemini kullanamazsınız, çünkü yazılar toplanamaz xD
naber = "Merhaba" + "Nasılsın?" -- geçersiz
Boolean (true , false)
Boolean değerler true veya false değerlerdir. Kontroller ve bazı döngüler için olmazsa olmazdır.
x = true
print(x)
--> true
Tablo (table)
İçerisine bilgi depolamak için kullanılır. Şimdi boş bir tablo oluşturalım.
x = {}
print(x)
--> table: 0035C910
-- boş bir tablo oluşturup print yaptığınızda table: 0035C910 geri dönüşünü almamanız normaldir, her tablonun başka bir değeri vardır.
Fonksiyon (function)
LUA'da fonksiyonlar, sayı ve yazılar gibi değişkenlere atanır. Fonksiyonların bir adı olmalıdır. Ufak bir örnek ile daha iyi anlayacağınızı düşünüyorum;
mrb = function() print("merhaba kardeşim") end -- mrb değişkenimize bir fonksiyon atadık
mrb() -- mrb fonksiyonunu tetikledik/başlattık
--> merhaba kardeşim
Fonksiyonların ismini function teriminden sonra da yazabilirsiniz, bu durumda bu fonksiyonu bir değişkene atayamazsınız, bir fonksiyona iki kere isim vermek gibi bir durum olur bu da saçma bir durum. Ufak bir örnek;
function napıyorsun() print("nabıyon len burda") end -- napıyorsun fonksiyonunu oluşturduk
napıyorsun() -- napıyorsun fonksiyonunu tetikledik/başlattık
--> nabıyon len burda
Fonksiyon içerisinde yazı yazmak ile fonksiyonu print fonksiyonuyla yazdırmak aynı şeyler değildir.
mesaj = function() print("yazı yazıyorum") end -- mesaj değişkenine fonksiyon atadık
mesaj() -- mesaj fonksiyonunu tetikledik/başlattık
--> yazı yazıyorum
print(mesaj) -- mesaj değişkenini print ile yazdık
--> function: 0035EA20
Fonksiyonlar, bir tablonun parçası olabilir.
sayi = 155 -- değişkene sayı değeri atadık
yazi = "kulak" -- değişkene yazı değeri atadık
fonksiyon = function() print("ben bir fonksiyonum") end -- değişkene fonksiyon atadık
tablomuz = {sayi,yazi,fonksiyon} -- bir tablo oluşturup içerisine değişkenlerimizi koyduk
for index,deger in pairs(tablomuz) do -- bir döngü ile tablomuzun tüm elemanlarını döndürdük
print(index.." | "..type(deger)) -- indexi ve indexin tablodaki değerini yazdık
end
--> 1 | number
--> 2 | string
--> 3 | function
nil
Var olmayan anlamına gelir. Var olmayan bir değişkeni kullanmaya çalışırsanız nil döndürür.
print(x)
--> nil
-- x değişkenine bir değer vermediğimiz için yazdırmaya çalıştığmızda nil (var olmayan) ile karşılaşırız
x = "artık benimde bir değerim var" -- x değişkenine değer atadık
print(x)
--> artık benimde bir değerim var
Dinamik Kodlama (Dynamic typing)
LUA'da değişkenlerin türünü istediğiniz gibi değiştirebilirsiniz. Bu özellik LUA'nın en büyük kolaylıklarından biridir.
wtff = 1 -- burada number değişken
wtff = "a" -- burada string değişkene dönüştü
wtff = {} -- burada ise bir tablo oldu
-- hiç bir sorun olmayacaktır
Sorgulama (type())
Bu fonksiyon verilen değişkenin türünü döndürür.
x = "111" -- yazı tipinde bir x değişkeni
print(x.." | "..type(x))
--> 111 | string
x = x + 7 -- değişkenimize 7 ekledik (matematiksel işlem kullandığımız için değişkenimiz artık sayı değişkeni oldu)
print(x.." | "..type(x))
--> 118 | number

[p=center]Operatörler[/p]

Aritmetik (Matematiksel) Operatörler
Bu operatörler şunlardır: +, -, *, /, %, ^
+
(artı): toplama operatörüdür, iki tarafındaki sayı değerlerini toplar.
x = 5 + 7.2
print(x)
--> 12.2
-(eksi): çıkartma operatörüdür, sol tarafıncaki sayı değerinden sağ tarafındaki sayı değerini çıkartır.
x = 2 - 5
print(x)
--> -3
*(çarpım): çarpma operatörüdür, iki tarafındaki sayı değerlerini çarpar.
x = 2.5 * 4
print(x)
--> 10
/(bölü): bölme operatörüdür, sol tarafındaki sayı değerini sağ tarafındaki sayı değerine böler.
x = 1 / 10
print(x)
--> 0.1
%(kalan): solundaki sayının sağındaki sayıya bölümünden kalanı verir.
print((15%7).." , "..(-4%3).." , "..(5.5%1))
-->1 , 2 , 0.5
^(üst): solundaki sayıyının sağındaki üssünü verir.
print((7^2).." , "..(107^0).." , "..(2^8))
--> 49 , 1 , 256
Karşılaştırma (Kontrol) Operatörleri
Bu operatörler genelde kontroller(if) için kullanılır.
Bu operatörler şunlardır: >, <, >=, <=, ==, ~=
(büyüktür): sol tarafındaki değer sağ tarafındaki değerden büyük ise true, küçük ise false döndürür.
x = 5 > 7
print(x)
--> false
x = "def" > "abc" -- alfabetik sırada sonra gelen daha büyüktür
print(x)
--> true
<(küçüktür): sol tarafındaki değer sağ tarafındaki değerden küçük ise true, büyük ise false döndürür.
x = "abb" < "baa"
print(x)
--> true
x = -3 < -6
print(x)
--> false
>=(büyük eşit): sol tarafındaki değer sağ tarafındaki değerden büyük veya eşit ise true, küçük ise false döndürür.
print( 3 >= 7, 4 >= 3.99, -6 >= -3, "a" >= "b")
--> false true false false
<=(küçük eşit): sol tarafındaki değer sağ tarafındaki değerden küçük veya eşit ise true, büyük ise false döndürür.
print( 3 <= 7, 7 <= 7, 8 <= 7)
--> true true false
==(eşit): sol tarafındaki değer ile sağ tarafındaki değer birbiriyle aynı ise true, farklı ise false döndürür. Burdaki değer sadece sayı olmak zorunda değildir, her şey olabilir.
print("abc" == "abc")
--> true
print("abc" == "a".."bc")
--> true
print({} == "table")
--> false
print({} == {}) -- ne kadar görünüş olarak aynı olsalarda iki farklı tablo oluşturulmuş ve bu tablolar aynı değildir
--> false
tablo1 = {}
tablo2 = tablo1
print(tablo1 == tablo2)
--> true
print("10" == 10) -- lua matematiksel işlemler yaparken yazı türünü sayı türü olarak algılasa da yazı türündeki bir ifade sayı türüne eşit olamaz, çünkü türleri farklıdır
--> false
print(tonumber("10") == 10) -- eğer yazı türündeki bir ifadeyi sayıya dönüştürürsek sayı değerine eşit olur
--> true
~=(eşit değil): sol tarafındaki değer ile sağ tarafındaki değer birbirinden farklı ise true, aynı ise false döndürür. Burada var-yok gibi tam bir zıtlık var mı diye bakılmaz, operatörün iki tarafının aynı olup olmamasına bakılır. Aynı ise false farklı ise true döndürür.
print(1 ~= 0)
--> true
print("1" ~= 1)
--> true
Mantıksal Operatörler
Bu operatörler şunlardır: not, and, or
not
Operatörü: Bu operatör sağ tarafındaki boolean ifadenin zıttını size döndürür. Eğer sağ tarafındaki ifade bir değer ise false, nil ise true döndürür. Ufak bir örnek;
print(not true,not false)
--> false true
x = "gündüz"
print(not x)
--> false
print(not y) -- y değersiz bir değişken, yani nil
--> true
and Operatörü: Solundaki ifade nil veya false ise solundaki değeri döndürür.
print(false and true)
--> false
print(nil and true)
--> nil
print(nil and false)
--> nil
print(nil and "naber",false and "nasılsın")
--> nil false
print(false and print("iyiyim"))
--> false
Solundaki ifade false veya nil değil ise sağındaki ifadeyi döndürür.
print(true and false)
--> false
print(true and true)
--> true
print(1 and "LUA")
--> LUA
print("meyve" and "sebze")
--> sebze
print(true and print("LUA çok kullanışlı bir dil"))
--> LUA çok kullanışlı bir dil
--> nil
or Operatörü: Solundaki iafe false veya nil değil ise solundaki ifadeyi döndürür.
print(true or false)
--> true
print(true or nil)
--> true
print("merhaba" or "kardeşim")
--> merhaba
print(1 or 2)
--> 1
print(true or print("selam"))
--> selam (parantezin içindeki print'in yazdığı)
--> true (en dıştaki print'in yazdığı)
Solundaki ifade false veya nil ise sağındaki ifadeyi döndürür.
print(false or true)
--> true
print(nil or true)
--> true
print(nil or "sa")
--> sa
print(false or print("ertrldtcu"))
--> ertrldtcu
--> nil (parantez içindeki print fonksiyonu bize geri dönüş yapmadığı için nil döndürülür)
or operatörü genelde fonksiyon içinde varsayılan değişkeni ayarlamak için kullanılır. Örneğin;
function mesajVer(mesaj)
local verilecekMesaj = mesaj or "mesaj giriniz"
print(verilecekMesaj,mesaj)
end
mesajVer()
--> mesaj giriniz nil
mesajVer("boş yapma")
--> boş yapma boş yapma
mesajVer(true)
--> true true
mesajVer(false)
--> mesaj giriniz false
Üçlü Operatörler
LUA'da üçlü operatörler bulunmasada and ve or kullanarak siz bunu yapabilirsiniz.
deger = bool1 and bool2 or bool3
--> bool1 false veya nil ise bool3 döndürülür
--> bool1 true(veya tanımlı bir değişken) ise bool2 döndürülür, bool2 true ise true döndürülür
--> bool1 true(veya tanımlı bir değişken) ise bool2 döndürülür, bool2 false veya nil ise bool3 döndürülür

[p=center]Kontrol Yapısı ( if , elseif , else )[/p]

Kontrol yapıları, seçim yapmanızı ve bir kodun sadece istediğiniz kısmını çalıştırmanızı sağlar.
if (Eğer, şart, koşul) Terimi
if terimi, koşula bağlı olarak farklı kodları çalıştırmanızı sağlar. else ve elseif terimlerini eklemek size kalmıştır.
if kosul1 then -- eğer kosul1 sağlanırsa
-- buradaki kodlar çalıştırılır
elseif kosul2 then -- eğer kosul2 sağlanırsa
-- buradaki kodlar çalıştırılır
elseif kosul3 then -- eğer kosul3 sağlanırsa
-- buradaki kodlar çalıştırılır
else -- eğer hiç bir koşul sağlanamazsa
-- buradaki kodlar çalıştırılır
end -- her if için bir end koyulmalıdır, ancak else ve elseifler için koymanıza gerek yoktur
-- ayrıca if eklemeden direk elseif veya else kullanamazsınız
if ve elseif'ler sırasıyla kontrol edilir, koşullardan biri true olduğunda altındaki kodları çalıştırılır ve ardından diğer tüm koşulları göz ardı ederek sonuna kadar atlanır. Kontrollerden hiçbiri eşleşmezse, eğer eklediyseniz else'den sonraki kodlar çalışır.
x = 12
sart1 = x > 15 -- false
sart2 = x > 10 -- true
sart3 = x > 5 -- true
if sart1 then -- false olduğu için altındaki kodlar çalıştırılmaz, var ise diğer kontrole(elseif) geçilir
print("x 15'ten büyük")
elseif sart2 then -- true olduğu için altındaki kodlar çalıştırılır, altındaki kontroller(elseifler) göz ardı edilir, atlanır
print("x 10'dan büyük")
elseif sart3 then -- sart2 true olduğu için bu kontrol göz ardı edildi
print("x 5'ten büyük")
else -- sart2 true olduğu için bu else göz ardı edildi
print("x 5'ten küçük")
end
--> x 10'dan büyük
Yukarıdaki kod uzun ve karmaşık olduğu için genelde aşağıdaki gibi yazılır:
x = 12
if x > 15 then -- x 15'ten büyük olmadığı için diğer kontrole(elseif'e) geçilir
print("x 15'ten büyük")
elseif x > 10 then -- x 10'dan büyük olduğu için bu kontrolün altındaki kodlar çalıştırılır, diğer kontroller(elseif'ler) göz ardı edilir, atlanır
print("x 10'dan büyük")
elseif x > 5 then -- üstteki kontrol(elseif) sağlandığı için bu kontrol göz ardı edildi
print("x 5'ten büyük")
end
--> x 10'dan büyük

[p=center]Döngüler ( while , repeat , for , break )[/p]

Döngüler aynı kodu birçok kez çalıştırmanızı sağlar.
while Döngüsü
Şart sağlandıkça döngü sürdürülür. Kodlar çalıştırılmadan önce kontrol yapılır. Şart sağlanıyorsa kodlar çalıştırılır, şart sağlanmıyorsa döngü kırılır.
while kontrol do
--kod
end
Ufak bir örnek;
sayi = 1 -- değişkenimize değer verdik
while sayi < 8 do -- eğer değişken 8'den küçükse
print(sayi) -- değişkeni yazdırdık
sayi = sayi + 1 -- değişkenin değerini 1 arttırdık
end -- değişkenimiz 8 oluncaya kadar döngü gerçekleştirilecektir, değişkenimiz 8 olunca şart sağlanmayacağı için döngü kırılacak ve kalan kodlar devam edecektir.
print("şart sağlanmadı, döngü sona erdi") -- şart sağlanmadığı zaman kodlar buradan devam edecek
--> 1
--> 2
--> 3
--> 4
--> 5
--> 6
--> 7
--> şart sağlanmadı, döngü sona erdi
repeat Döngüsü
Bu döngü belirlenen şart sağlanana kadar döndürülür, şart sağlanınca döngüyü kırar. Kodlar çalıştırılmadan önce kontrol yapılır. Şart her zaman sağlanırsa, döngü asla çalışmaz.
repeat
--kod
until kontrol
Ufak bir örnek;
sayi = 5 -- değişkenimize değer verdik
repeat
print(sayi) -- değişkeni yazdırdık
sayi = sayi - 1 -- değişkenin değerini 1 azalttık
until sayi == 0 -- değişken 0 olduğunda döngü sona ericek çünkü kontrol sağlanacak
print("şart sağlandı, döngü sona erdi") -- şart sağlandığı zaman kodlar burdan devam edecek
--> 5
--> 4
--> 3
--> 2
--> 1
--> şart sağlandı, döngü sona erdi
Sayısal for Döngüsü (numeric for loop)
for degisken = baslangic,bitis,adim do -- buradaki üç değerde sayı olmalıdır
-- kod
end
Kodlar verilen değişken değerinde çalıştırılmaya başlanıp, her seferinde adim değeri kadar arttırılarak bitis değerini geçene kadar çalıştırılır. adim değerini girmek zorunlu değildir, girmezseniz 1 yazılmış gibi davranılır. degisken döngü her gerçekleştiğinde güncellenir ve döngü kodları içerisinde kullanılabilir.
Ufak bir örnek;
for i=1,4 do
print(i)
end
--> 1
--> 2
--> 3
--> 4
for sira=1,35,10 do -- bu sefer bir adım genişliği girelim
print(sira)
end
--> 1
--> 11
--> 21
--> 31
for index=0.5, 1.5, 0.3 do -- sayılar tamsayı olmak zorunda değildir
print(index)
end
--> 0.5
--> 0.8
--> 1.1
--> 1.4
for i=5,3 do
print(i)
end
-- kodlar asla çalışmaz çünkü for döngüsü büyük sayıdan küçük sayıya doğru ilerlemez
-- ancak siz adımı negatif bir sayı yaparsanız geriye gidebilirsiniz
-- örneğin;
for i=5,3,-1 do
print(i)
end
--> 5
--> 4
--> 3
Tablolar için for Döngüsü (iterator for loop)
for anahtar,deger in ipairs(tablo) do
-- kod
end
Tablolar için for döngüsü, verilen tablonun tüm elemanlarını döndürür ve size her eleman için anahtar ve deger karşılıklarını verir.
Ufak bir örnek;
tablo = {"a", "b", "c"}
for anahtar,deger in ipairs(tablo) do -- tabloyu döndürdük (bize her elemanın sırasını ve değerini değişken olarak verir)
print(anahtar.." | "..deger) -- verilen anahtarı ve değeri yazdırdık
end
--> 1 | a
--> 2 | b
--> 3 | c
break Terimi
break terimi, döngüleri kırmamızı/atlamamızı sağlar.
i = 3
while true do -- şart her zaman sağlanmış olacağı için bu döngü sonsuzdur, bir yerde kırmamız gerekir aksi takdirde kasmaya neden olabilir
print(i) -- i'yi yazdırdık
i = i + 1 -- i'ye 1 ekledik
if i > 6 then -- eğer i 6'dan büyükse
break -- döngüyü kırdık
end
end
--> 3
--> 4
--> 5
--> 6
sayi = 4
repeat
print(sayi) -- sayi'yi yazdırdık
sayi = sayi-1 -- sayi'dan 1 çıkardık
if sayi == 0 then -- eğer sayi 0'a eşitse
break -- döngüyü kırdık
end
until false -- şart asla sağlanmayacağı için bu döngü sonsuzdur, bir yerde kırmamız gerekir aksi takdirde kasmaya neden olabilir
--> 4
--> 3
--> 2
--> 1
İç içe geçmiş döngülerde break terimi sadece en içteki döngüyü kırar, ufak bir örnek;
for i=1,3 do
while true do -- şart her zaman sağlandığı için bu döngü sonsuzdur
break -- buradaki break sadece while döngüsünü kırar
end
print(i)
end
--> 1
--> 2
--> 3

[p=center]Tablolar[/p]

Daha önceden ufaktan değindiğimiz bu değişken türü, içinde bilgi depolamamızı sağlar. Bilgiler anahtar = değer şeklinde saklanır ve daha sonra anahtarı kullanarak değeri elde edebilirsiniz. İçinde sakladıklarımız bilgiler bir nevi değişkendir.
Tablo Oluşturma;
tablo = {} -- tablo değişkenimize boş bir tablo oluşturduk
print(tablo) -- tabloyu yazdırdık
--> table: 0035AE18
Bir tabloyu yazdırmaya çalıştığınızda türü ve benzersiz kimliği yazdırılır. Eğer tablonun bir elemanını yazdırmak istiyorsak; bunu ilerde göreceğiz :)
Tabloları Kullanma;
Tablodaki anahtara değer vermek için tablo[anahtar] söz dizimini kullanabilirsiniz. Örneğin;
tablo = {} -- boş bir tablo oluşturduk
tablo["naber"] = "iyi koc" -- "naber" anahtarına "iyi koc" değerini atadık
tablo[3] = "üç" -- 3 anahtarına "üç" değerini atadık
print(tablo["naber"]) -- tablomuzun "naber" anahtarını yazdırdık
--> iyi koc
print(tablo[3]) -- tablomuzun 3 anahtarını yazdırdık
--> üç
Tabloda değeri olmayan bir anahtarı kullanmaya çalışırsanız nil ile karşılaşırsınız. Ufak bir örnek;
t = {} -- tablomuzu oluşturduk
print(t[1]) -- tablomuzun 1 anahtarını yazdırdık
--> nil (1 anahtarına değer atanmadığı için nil verdi)
Tablodan bir anahtar/değer çiftini silmek istiyorsanız, anahtarın değerini nil yapmanız yeterli. Ufak bir örnek;
t = {}
t[1] = "bir" -- anahtara değer verdik
print(t[1])
--> bir
t[1] = nil -- anahtarı nil yaptık (hiçlik,yokluk)
print(t[1])
--> nil
Tablodaki anahtar boolean( true , false ), nil veya NaN(yani 0/0) olamaz. Ufak bir örnek;
cool = {}
cool[nil] = "balta"
print(cool[nil])
stdin:1: table index is nil
stack traceback:
stdin:1: in main chunk
[C]: in ?
-- yani hata verir :)
tbl = {}
tbl[0/0] = 15 -- sıfırın sıfıra bölümü NaN'dır
stdin:1: table index is NaN
stack traceback:
stdin:1: in main chunk
[C]: in ?
-- yine hata verdi
Tablodaki anahtarlar sadece köşeli parantez içerisinde sayı ve yazı olmak zorunda değildir. Değişkende olabilir. Tablodaki değişkene oluşturulduktan sonra değer verilecekse tablo.degiskenIsmi söz dizimi kullanılır, getirilirken de aynı söz dizimi kullanılır. Ufak bir örnek;
t = {}
t.bilgi = 15 -- t["bilgi"] ile aynıdır, hangisi kolayınıza geliyorsa onu kullanabilirsiniz. buraya dikkat edin! t[bilgi] ve t["bilgi"] aynı değerlere karşılık gelmezler, farklı değerlerdir.
print(t.bilgi)
--> 15
print(t["bilgi"])
--> 15
Değişken ve anahtarlarınızı direk tablo oluştururkende ekleyebilirsiniz. Örneğin;
t = {bilgi1 = "ben bir bilgiyim",[12] = "şeftali"}
print(t.bilgi1)
--> ben bir bilgiyim
print(t[12])
--> şeftali
Eğer bir tablodaki tüm anahtar/değer çiftlerini kullanmak istiyorsanız for döngüsünü kullanabilirsiniz. Örnek;
t = {[1] = "iyi",["nabıyon"] = "boş boş oturuyom"}
for anahtar,deger in pairs(t) do
print(anahtar.." | "..deger)
end
--> 1 | iyi
--> nabıyon | boş boş oturuyom
Diziler Olarak Tablolar
Tablolardaki bilgilerin anahtar/değer olduğunu unutmayın. Ancak anahtar belirtmeden de değer girebilirsiniz. Bu durumda karşımıza dizeler çıkıyor. Anahtarı girilmeyen bir değer tabloya eklenirse, anahtarı index olur(yani sayı). Bu index tablodaki diğer indexlerin sayısından 1 fazladır. Örnek;
t = {"a","b","c"}
print(t[1])
--> a
print(t[3])
--> c
Gördüğünüz gibi hala anahtar/değer şeklinde kullanılıyor.
Ayrıca dizi ve anahtar/değer şeklindeki elemanları aynı tablo içine ekleyebilir ve kullanabilirsiniz. Örnek;
tablo = {"a","b","c",[155] = "polis","d",berkecan = "dede"}
for anahtar,deger in pairs(tablo) do print(anahtar.." | "..deger) end
--> 1 | a
--> 2 | b
--> 3 | c
--> 4 | d
--> 155 | polis
--> berkecan | dede
# operatörünü kullanarak bir tablonun uzunluğunu öğrenebilirsiniz. Örnek;
t = {"a", "b", "c"}
print(#t)
--> 3
# operatörü tablodaki tüm elemanların sayısını vermez! Sadece son tamsayı anahtarı verir. Eğer tamsayı anahtarlar ardışık değilse sonuç tanımsızdır. Bu yüzden aralıklı diziler için kullanılmamalıdır. Örnek;
t = {"a",[123] = "b"}
print(#t)
--> 1
t = {"a",[123] = "b","c"}
print(#t)
--> 2
t = {[3] = "a",[4] = "c",[123] = "b"}
print(#t) -- ardışık diziler var ancak 1'den başlamadığı için 0 verir
--> 0
Bir dizinin sonuna eleman eklemenin iki yolu vardır, örnek üzerinden anlatacağım;
t = {} -- boş bir tablo
table.insert(t, 123) -- bu fonksiyon dizenin sonuna eleman ekler
t[#t+1] = 456 -- burda ise ardışık dizelerin sayısına 1 ekleyip bu anahtara değer verdik, aynı sonuca çıkmış oluyolar
print(t[1])
--> 123
print(t[2])
--> 456
table.insert fonksiyonu ile diziye eleman eklerken sıra belirtmezseniz dizinin en sonuna eklenir(yukarıdaki koddaki gibi), ancak sıra belirtirseniz o sıraya(indexe) eklenir. Eğer eklendiği sıra(index)'da eleman varsa o eleman 1 index kaydırılır. Her kaydırma işleminden önce kaydırılacak indexe bakılır, index doluysa bir sonraki indexe kaydırılarak dizi tekrar sıralanır. Örnek üzerinden daha rahat anlayacağınızı umuyorum;
t = {"a","c","d"}
table.insert(t,2,"b") -- index 2'ye "b" değerini atadık, index 2'deki "c" index 3'e, index 3'teki "d" index 4'e kaydı
print(t[1].." | "..t[2].." | "..t[3].." | "..t[4])
--> a | b | c | d
table.remove fonksiyonu ise belirtilen indexteki elemanı kaldırır ve diğer indexteki elemanları bu boşluğu dolduracak şekilde kaydırır. Örneğin;
t = {"a","b","c","d"}
table.remove(t,2) -- index 2'yi sildik, index 3'teki "c" index 2'ye, index 4'teki "d" index 3'e kaydı
print(t[1].." | "..t[2].." | "..t[3])
--> a | c | d
Bir tabloyu fonksiyona, değişkene vb. geçirdiğinizde tablonun bir kopyası oluşmaz. Değişken veya fonksiyon orjinal tablo ile iletişime geçer. Örneğin;
t1 = {} -- boş bir tablo oluşturduk
t2 = t1 -- t2 değişkenine t1 değişkenini atadık, t2 artık bir tablo oldu. Burada dikkat edilmesi gereken; t2 değişkenine boş bir tablo oluşturulmadı, t2 değişkenine tablo değişkeni atandı. Yani t2 ve t1 tabloları artık bir çalışır. Birine anahtar eklenir/çıkartılır ise diğerinde de o anahtar eklenir/çıkarılır.
t2["elma"] = "meyve" -- t2 tablosunun "elma" anahtarına "meyve" değerini verdik
print(t1["elma"]) -- t1 tablosunun "elma" anahtarını yazdırdık
--> meyve
function f(x) x[1] = 2 end -- f fonksiyonu içerisinde, verilen tablonun 1 anahtarını "sebze" yapacağız
f(t1) -- f fonksiyonunu tetikleyip t1 tablosunu verdik
print(t2[1]) -- t2 tablosunun 1 anahtarını yazdırdık
--> 2
 

Mucotoo

Little Mouse
NOT!: Bu yazı normalde MTA Serverleri için hazırlanmıştı fakat Transformice'da lua kullanılabilir olduğu için burada da paylaştım.
 

Shadiii

Little Mouse
Keşke kendin uğraşıp bir şeyler yapsaydın, bu konu gibi, lag yapmak yerine düzgün bir modül yapmak gibi
 
Top
"Dev-TR" theme by Soulzone