Kontrol yapıları

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

Bir if then else ifadesi, belirtilen bir koşul true olduğunda sadece kodu yürütür. Kod yeniden yürütülmez.
Bir while döngüsü belirlenen bir koşul true olduğunda sadece kodu yürütür ve koşul kalırken yürütmeyi tekrarlar true.
Bir tekrarlayan döngü kodu yürütür ve koşul true.
Döngü için bir kodu belirtilen girişlere bağlı olarak bir kez çalıştırır. çalıştırır. bir kez çalıştırır.

if ifadeleri, while döngüleri ve repeat döngüleri herhangi bir Luau ifadesi veya değeri olabilir.Bir değer false veya nil değilse, Luau koşullu ifadelerde bunu true olarak değerlendirir.Diğer senaryo dillerinden farklı olarak, Luau hem sıfırı hem de boş dizeyi true olarak görür.

Eğer ifadeler

Temel if ifadesi koşulunu test eder. Koşul doğruysa, Luau then ve end arasındaki kodu çalar.

elseif ifadesini kullanarak ek koşullar için test yapabilirsiniz, eğer if koşulu yanlışsa.Tüm if ve elseif koşulları başarısız olduğunda kodu çalıştırmak için bir else ifadesi kullanabilirsiniz.The elseif ve else bölümleri her ikisi de isteğe bağlıdır, ancak her ikisini de başlangıç if ifadesi olmadan kullanamazsınız.

Bir if , elseif ve else koşulları zincirinde, Luau koşulları en üstten en aşağıya test eder, ilk true koşulda durur ve ardından gelen kodu uygular.


if 2 + 2 == 5 then
	print("Two plus two is five") -- Koşul sahte olduğundan basmaz çünkü
elseif 2 + 3 == 5 then
	print("Two plus three is five") -- İki artı üç beştir
else
	print("All conditions failed") -- Önceki koşul doğru olduğundan basmaz
end

Döngüler sırasında

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


local timeRemaining = 10

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

print("Timer reached zero!")
--[[ Sonuç çıkışı:
Seconds remaining: 10
Seconds remaining: 9
Seconds remaining: 8
Seconds remaining: 7
Seconds remaining: 6
Seconds remaining: 5
Seconds remaining: 4
Seconds remaining: 3
Seconds remaining: 2
Seconds remaining: 1
Timer reached zero!
]]

Sonsuz döngüler

Koşul olarak while — do döngüsünü ayarlayarak sonsuz oyun döngüleri yazmak için bir true döngüsü kullanabilirsiniz.


while true do
	print("Looping...")
	task.wait(0.5)
end

--[[ Sonuç çıkışı:
Looping...
Looping...
Looping...
Looping...
...
]]

Sonsuz bir döngüde daima bir gecikme, örneğin task.wait() dahil edin. Onu atlamak deneyimi dondurur ve Studio'yu çöker.

Döngüleri tekrarla

The repeat — until döngüsü bir koşul doğru olana kadar tekrarlanır.Koşullu test, kod bloğu çalıştıktan sonra değerlendirir, bu nedenle kod bloğu daima en az bir kez çalışır.Diğer dillerden farklı olarak, yerel bir değişkenin içinde repeat - until döngüsünde belirtilen Luau özelliği koşulu içerir.


local currentGoblinCount = 18

-- oyunmaksimum 25'e kadar goblin oluştur
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Current goblin count: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins repopulated!")

--[[ Sonuç çıkışı:
Current goblin count: 19
Current goblin count: 20
Current goblin count: 21
Current goblin count: 22
Current goblin count: 23
Current goblin count: 24
Current goblin count: 25
Goblins repopulated!
]]

Döngüler için

Bir döngü döngüsü kodu bir sayıda kez çalar, örneğin bir sayısal sayaç veya bir koleksiyonun öğelerinin sayısına dayanarak.

Döngüler için sayısal Numeric for loops

Bir for — do döngüsü, bir sayaç kullanarak döngüyü karşı teklifsayısını belirler.Döngü bir başlangıç değeri, bitiş değeri ve opcional artış değeri ile ilan edilir.

Luau, sayacıyı başlangıç değerine eşit olarak ayarlar, for döngüsünde kod bloğunu yürütür ve ardından sayacağa artış ekler.Eğer artış pozitifse, süreç sayıcı son değere eşit veya daha büyük olana kadar tekrarlanır.Eğer artış negatifse, süreç sayıcı son değerden eşit veya daha az olana kadar tekrarlanır.

Opsiyonel artış, varsayılan olarak 1 'ye ayarlanır. Tüm bir sayı olması gerekmez.


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

--[[ Sonuç çıkışı:
1
2
3
]]

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

--[[ Sonuç çıkışı:
1
3
5
]]

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

--[[ Sonuç çıkışı:
2
1.5
1
0.5
0
]]

Döngüler için genel

Genel for döngüsü, bir koleksiyondaki öğeler üzerinde bir sayı dizisi yerine döngü yapar.Genel for döngüleriyle, koleksiyondaki her öğe için kodu çalabilir ve kodda her öğeyi kolayca kullanabilirsiniz.

Döngülerin farklı koleksiyon türleri üzerinde dolaşması için bir işlev veya döngü geziciye ihtiyacı vardır.Küresel ipairs() bir dizi için bir döngü döndürür ve küresel pairs() bir sözlük için bir döngü döndürür.The kütüphanesi, dize üzerinde döngü yapmak için sağlar .

Genelleştirilmiş döngü

Luau'da, bir tablo üzerinde in anahtar kelime kullanarak doğrudan tablo üzerinde döngü yapabilirsiniz, örneğin ipairs() gibi bir döngü işlevi kullanmak yerine:


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

Genelleştirilmiş döngü ayrıca özel bir döngü işlevi oluşturmak için __iter metodunu kullanmanıza izin verir.Bu yapay örnek, son elemanından ilkiye ters sırayla bir dizi üzerinde döngü yapar:


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ç çıkışı:
5 5
4 4
3 3
2 2
1 1
]]

Diziler

The ipairs() işlevi, bir tabloda sayısal indekslerden dolaşan bir döngü döndürür ve her bir eleman için bir index ve value döndürür.Bu, tüm indeksler sayısal olan dizilere uygun hale getirir.


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

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

Sözlükler

The pairs() fonksiyonu, bir tabloda tüm indekslerden (sayısal indeksler dahil) dönen bir döngü döndürür ve sözlükteki her giriş için bir key ve value döndürür.Sözlük tablosundaki öğelerin gezilme sırası rastgeledir.Bu, sözlüklere döngü yapmak için uygun hale getirir, where items are stored out of order with non-numeric indices.


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ç çıkışı:
Hello b
true d
false e
World f
5 c
1 a
]]

Döngüleri kır

Bir döngüyü bitirmek için, break anahtar kelimesini kullanın. Aşağıdaki kod örneği, sonsuz bir while — do döngüsünü nasıl kıracağınızı gösterir.


local secondsElapsed = 0
local timeout = 5

while true do
	task.wait(1)
	secondsElapsed += 1
	print("Seconds elapsed:", secondsElapsed)

	if secondsElapsed == timeout then
		break
	end
end

print("Five seconds elapsed. Time to move on!")

--[[ Sonuç çıkışı:
1
2
3
4
5
Five seconds elapsed. Time to move on!
]]

Döngüleri devam ettir

Bir döngüyü tekrar etmesini ve yeniden başlatmasını zorlamak için continue anahtar kelimesini kullanın.Bir for döngü sayacı gezinecek; while ve repeat — until döngü koşulu devam etmeden önce kontrol edecek.Aşağıdaki kod örneği, belirli bir 'in tüm çocuklarını 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ü tekrarlar
		table.insert(children, child)
	end

	return children
end

Bu sayfadakiler