MTA için LUA Eğitimi #5 (Kapsamlı Ders)

Durum
Üzgünüz bu konu cevaplar için kapatılmıştır...

xcagrihd

Onaylı Üye
Katılım
2 May 2017
Mesajlar
66
Beğeni Puanı
16
Puanları
208
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.
Kod: Lua

Lua:
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 = "Seviyorum seniii" -- 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.
Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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
Veri Türleri


Sayı ( number , integer , float )

Kesirli sayılar ondalık kesir biçimine çevrilip, ondalık sayı olarak kullanılır.

Lua:
print(1/10)
--> 0.1
LUA matematiksel işlemleri yapmamıza olanak verir.

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
print("naber")
--> naber
Yazıyı bir değişkene atayıp daha sonradan kullanabiliriz.

Kod: Lua

Lua:
hg = "hoşgeldin"
print(hg)
--> hoşgeldin
İki yazıyı birbirine iki nokta yani .. ile bağlayabiliriz.

Kod: Lua

Lua:
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

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
x = true
print(x)
--> true
Tablo ( table )

İçerisine bilgi depolamak için kullanılır. Şimdi boş bir tablo oluşturalım.

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
function as() print("sa") end -- sa fonksiyonunu oluşturduk
as() -- asfonksiyonunu tetikledik/başlattık
--> sa
Fonksiyon içerisinde yazı yazmak ile fonksiyonu print fonksiyonuyla yazdırmak aynı şeyler değildir.

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
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 Fonksiyonu ( type() )

Bu fonksiyon verilen değişkenin türünü döndürür.

Kod: Lua

Lua:
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
Kontrol Yapısı ( if , elseif , else )​


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.
Kod: Lua

Lua:
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.

Kod: Lua

Lua:
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:

Kod: Lua

Lua:
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
Döngüler ( while , repeat , for , break )​

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.
Kod: Lua

Lua:
while kontrol do
        --kod
end
Ufak bir örnek;

Kod: Lua

Lua:
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.

Kod: Lua

Lua:
repeat
        --kod
until kontrol
Ufak bir örnek;

Kod: Lua

Lua:
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)


Kod: Lua

Lua:
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;
Kod: Lua

Lua:
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)

Kod: Lua

Lua:
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;
Kod: Lua

Lua:
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.

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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

Tablolar


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;
Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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. Örnek;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
t = {[1] = "sa",["as"] = "napıyosun"}
for anahtar,deger in pairs(t) do
        print(anahtar.." | "..deger)
end
--> 1 | sa
--> as | napıyosun
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;
Kod: Lua

Lua:
t = {"a","b","c"}
print(t[1])
--> a
print(t[3])
--> c

# 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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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;

Kod: Lua

Lua:
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
Operatör hakkında zaten konum var gerek duymadım yazmaya kolay gelsin.
 
Moderatör tarafında düzenlendi:

Youti

橱 Game Đeveloper 設
Onaylı Üye
Katılım
1 Eyl 2018
Mesajlar
275
Beğeni Puanı
105
Puanları
43
eyvallah kardeşim teşekkür ederim eline sağlık baya yazmışsın zorlanmadın mı :thinkie:
 

The Originals

Herkesin menfaatince kankisin bu hayatta.
Ultra Üye
Katılım
22 Ara 2017
Mesajlar
1,470
Beğeni Puanı
613
Puanları
213
güzel ve yararlı konu için teşekkürler eğitici bir kodlama bilgisi
 
Katılım
15 Haz 2018
Mesajlar
7
Beğeni Puanı
0
Puanları
1
Yaş
20
teşekkürler kodlama bilgin büyük ihtimalle üst seviyede :D neyse
 

xcagrihd

Onaylı Üye
Katılım
2 May 2017
Mesajlar
66
Beğeni Puanı
16
Puanları
208
eyvallah kardeşim teşekkür ederim eline sağlık baya yazmışsın zorlanmadın mı :thinkie:
Biraz sabaha karşı yazdığım için zorlandım ve yoruldum.

bu 1.5.5 içinmi 1.5.6 içinmi ?
Farketmiyor sürüm arasında sadece yeni fonksiyonlar gelir herhangi bir fark olmaz.

güzel ve yararlı konu için teşekkürler eğitici bir kodlama bilgisi
Teşekkür ederim :)

teşekkürler kodlama bilgin büyük ihtimalle üst seviyede :D neyse
Rica ederim, LUA konusunda evet bilgim fazla.
 
Durum
Üzgünüz bu konu cevaplar için kapatılmıştır...

Üst Alt