Kontrol yapıları

Kontrol yapıları, Luau kodu yürütme akışını yöneten ifadelerdir. Dört ana kontrol yapısı türü vardır:

• Bir if then else ifadesi, yalnızca belirtilen bir koşul doğru olduğunda kodu yürütür. Kod yürütme tekrar etmez.
• Bir while döngüsü, yalnızca belirtilen bir koşul doğru olduğunda kodu yürütür ve koşul doğru kaldığı sürece yürütmeyi tekrarlar.
• Bir repeat döngüsü, kodu yürütür ve koşul doğru olduğunda yürütmeyi tekrarlar.
• Bir for döngüsü, belirtilen girdilere bağlı olarak belirli sayıda kodu yürütür.

if ifadeleri, while döngüleri ve repeat döngüleri için koşul, herhangi bir Luau ifadesi veya değer olabilir. Eğer bir değer false veya nil değilse, Luau bunu koşullu ifadelere doğru olarak değerlendirir. Diğer komut dosyası dillerinin aksine, Luau hem sıfırı hem de boş dizeyi doğru olarak kabul eder.

If ifadeleri

Temel if ifadesi, koşulunu test eder. Koşul doğruysa, Luau then ve end arasında yer alan kodu yürütür.

Eğer if koşulu yanlışsa, ek koşulları test etmek için bir elseif ifadesi kullanabilirsiniz. Tüm if ve elseif koşulları başarısız olursa kodu yürütmek için bir else ifadesi kullanabilirsiniz. elseif ve else bölümleri isteğe bağlıdır, ancak başlangıçta bir if ifadesi olmadan kullanılamazlar.

Bir dizi if, elseif ve else koşulunda, Luau koşulları yukarıdan aşağıya doğru test eder, ilk doğru koşulda durur ve ardından onu takip eden kodu yürütür.

if 2 + 2 == 5 then
	print("İki artı iki beştir") -- Koşul yanlış olduğu için basılmaz
elseif 2 + 3 == 5 then
	print("İki artı üç beştir") -- İki artı üç beştir
else
	print("Tüm koşullar başarısız oldu") -- Önceki koşul doğru olduğu için basılmaz
end

While döngüleri

Bir while—do döngüsü, belirli bir koşulun doğru veya yanlış olup olmadığını değerlendirir. Eğer koşul yanlış veya nil ise, döngü sona erer ve Luau döngüdeki kodu atlar. Eğer koşul doğru ise, Luau döngüdeki kodu yürütür ve süreci tekrarlar.

local timeRemaining = 10

while timeRemaining > 0 do
	print("Kalan saniyeler: " .. timeRemaining)
	task.wait(1)
	timeRemaining -= 1
end

print("Zamanlayıcı sıfıra ulaştı!")
--[[ Sonuç çıktısı:
Kalan saniyeler: 10
Kalan saniyeler: 9
Kalan saniyeler: 8
Kalan saniyeler: 7
Kalan saniyeler: 6
Kalan saniyeler: 5
Kalan saniyeler: 4
Kalan saniyeler: 3
Kalan saniyeler: 2
Kalan saniyeler: 1
Zamanlayıcı sıfıra ulaştı!
]]

Sonsuz döngüler

while—do döngüsünü, koşulu doğru olarak ayarlayarak sonsuz oyun döngüleri yazmak için kullanabilirsiniz.

while true do
	print("Dönüyor...")
	task.wait(0.5)
end

--[[ Sonuç çıktısı:
Dönüyor...
Dönüyor...
Dönüyor...
Dönüyor...
...
]]

Repeat döngüleri

repeat—until döngüsü bir koşul doğru olana kadar tekrar eder. Koşullu test, kod bloğu çalıştıktan sonra değerlendirilir, bu nedenle kod bloğu her zaman en az bir kez çalıştırılır. Diğer dillerden farklı olarak, repeat—until döngüsünde tanımlanan yerel bir değişkenin kapsamı koşulu içerir.

local currentGoblinCount = 18

-- Oyun içinde maksimum 25 goblin oluştur
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Mevcut goblin sayısı: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblinler tekrar çoğaldı!")

--[[ Sonuç çıktısı:
Mevcut goblin sayısı: 19
Mevcut goblin sayısı: 20
Mevcut goblin sayısı: 21
Mevcut goblin sayısı: 22
Mevcut goblin sayısı: 23
Mevcut goblin sayısı: 24
Mevcut goblin sayısı: 25
Goblinler tekrar çoğaldı!
]]

For döngüleri

For döngüsü, ya bir sayısal sayaca ya da bir koleksiyonun içindeki öğelerin sayısına bağlı olarak, belirli sayıda kodu yürütür.

Sayısal for döngüleri

Bir for—do döngüsü, döngüyü kaç kez çalıştıracağını bir sayaç kullanarak belirler. Döngü, başlangıç değeri, bitiş değeri ve isteğe bağlı artış ile tanımlanır.

Luau, sayacı başlangıç değerine eşitler, for döngüsündeki kod bloğunu çalıştırır ve ardından sayaca artışı ekler. Eğer artış pozitifse, süreç sonunda sayacın bitiş değerine eşit veya büyük olana kadar tekrarlar. Eğer artış negatife ise, süreç sonunda sayacın bitiş değerine eşit veya küçük olana kadar tekrarlar.

İsteğe bağlı artış varsayılan olarak 1'dir. Tam sayı olması gerekmez.

for counter = 1, 3 do
	print(counter)
end

--[[ Sonuç çıktısı:
1
2
3
]]

for counter = 1, 6, 2 do
	print(counter)
end

--[[ Sonuç çıktısı:
1
3
5
]]

for counter = 2, 0, -0.5 do
	print(counter)
end

--[[ Sonuç çıktısı:
2
1.5
1
0.5
0
]]

Genel for döngüleri

Genel for döngüsü, bir dizi yerine koleksiyondaki öğeler üzerinde iterasyon yapar. Genel for döngüleriyle, koleksiyondaki her bir öğe için kodu çalıştırabilirsiniz ve kod içinde her öğeyi kolayca kullanabilirsiniz.

For döngülerinin, farklı türde koleksiyonlar üzerinde iterasyon yapmak için bir işlev veya iteratora ihtiyacı vardır. Küresel ipairs() diziler için bir iterator dönerken, küresel pairs() sözlükler için bir iterator döner. string kütüphanesi, dizeler üzerinde iterasyon yapmak için string.gmatch() sağlar.

Genel yineleme

Luau'da, in anahtar kelimesini doğrudan tablo üzerinde kullanarak bir tablo üzerinde yineleme yapabilirsiniz; ipairs() gibi bir iterator işlevi kullanmak yerine:

for i, v in {1, 2, 3, 4, 5} do
	print(i, v)
end

Genel yineleme, özel bir iterator işlevi oluşturmak için __iter metametodunu kullanmanıza da izin verir. Bu karmaşık örnek, bir diziyi ters sırayla, son elemanından ilk elemanına kadar yinelemekte:

local myTable = {1, 2, 3, 4, 5}

myMetatable = {
	__iter = function(t)
		local i = #t + 1

		return function()
			i -= 1

			if i > 0 then
				return i, t[i]
			end
		end
	end,
}

setmetatable(myTable, myMetatable)

for i, v in myTable do
	print(i, v)
end

--[[ Sonuç çıktısı:
5 5
4 4
3 3
2 2
1 1
]]

Diziler

ipairs() işlevi, bir tablodaki sayısal dizinler üzerinden iterasyon yapan bir iterator döner ve her bir öğe için bir index ve value döner. Bu, tüm dizinlerin sayısal olduğu diziler için uygundur.

local array = {"a", "b", "c", "d", "e"}
for index, value in ipairs(array) do
	print(index, value)
end

--[[ Sonuç çıktısı:
1 a
2 b
3 c
4 d
5 e
]]

Sözlükler

pairs() işlevi, bir tablodaki tüm dizinler (sayısal dizinler dahil) üzerinden iterasyon yapan bir iterator döner ve her bir sözlük girdisi için bir key ve value döner. Sözlük tablosundaki öğeleri geçerken sıranın keyfi olduğunu unutmayın. Bu, öğelerin sırasız saklandığı sözlükler üzerinde iterasyon yapmak için uygundur.

local dictionary = {
	[1] = "a",
	["Hello"] = "b",
	[5] = "c",
	[true] = "d",
	["World"] = "f",
	[false] = "e"
}
for key, value in pairs(dictionary) do
	print(key, value)
end

--[[ Sonuç çıktısı:
Hello b
true d
false e
World f
5 c
1 a
]]

Döngüleri kırmak

Bir döngüyü sona erdirmek için break anahtar kelimesini kullanın. Aşağıdaki kod örneği, sonsuz bir while—do döngüsünü kırmanın nasıl yapılacağını göstermektedir.

local secondsElapsed = 0
local timeout = 5

while true do
	task.wait(1)
	secondsElapsed += 1
	print("Geçen saniyeler:", secondsElapsed)

	if secondsElapsed == timeout then
		break
	end
end

print("Beş saniye geçti. İlerleme zamanı!")

--[[ Sonuç çıktısı:
1
2
3
4
5
Beş saniye geçti. İlerleme zamanı!
]]

Döngülerde devam et

Bir döngüyü yinelemeye zorlamak ve tekrar başlatmak için continue anahtar kelimesini kullanın. Bir for döngüsü sayaç üzerinde iterasyon yapacaktır; while ve repeat—until döngüleri, devam etmeden önce döngü koşulunu kontrol eder. Aşağıdaki kod örneği, belirli bir ClassName olan bir Instance'nin tüm alt öğelerini alır.

local function GetChildrenOfClass(parent: Instance, className: string): {Instance}
	local children = {}
	for _, child in parent:GetChildren() do
		if child.ClassName ~= className then continue end  -- Döngüyü yinelemeye devam et
		table.insert(children, child)
	end

	return children
end