Kapsam

Scripting'de, bir kod bloğu, bir kontrol yapısı veya fonksiyonun gövdesidir. Bir değişkenin veya fonksiyonun kapsamı, ona erişebilen kod bloğudur ve bu küresel veya yerel olabilir. Tüm bloklar küresel değişkenlere ve fonksiyonlara erişebilir. Bir blok, üst bloğundaki yerel değişkenlere ve fonksiyonlara erişebilir, ancak alt bloklarındaki değişkenlere ve fonksiyonlara erişemez.

Değişkenler ve fonksiyonlar varsayılan olarak küresel kapsamda tanımlanır, ancak genellikle yerel kapsamda tanımlamak daha iyidir çünkü Luau, yerel değişkenlere ve fonksiyonlara küresel olanlardan daha hızlı erişir. Bir değişkenin veya fonksiyonun yerel kapsamda olmasını sağlamak için, onu tanımlarken adının önüne local anahtar kelimesini koyun.

Scriptler, diğer scriptlerdeki küresel ve yerel değişkenlere veya fonksiyonlara erişemez. Scriptler arasında değerleri ve fonksiyonları paylaşmak istiyorsanız, ModuleScripts kullanın.

local helloWorld = 'Merhaba Dünya!'
local function printHelloWorld()
	print(helloWorld)
end
printHelloWorld() -- Merhaba Dünya!

• Blok B, blok A'daki yerel değişkene erişebilir.
• Blok C, blok A ve B'deki yerel değişkenlere ve fonksiyonlara erişebilir.
• Blok A, blok B veya C'deki yerel değişkenlere ve fonksiyonlara erişemez.
• Blok B, blok C'deki yerel değişkene erişemez.

Küresel Kapsam

Bir küresel değişken veya fonksiyon tanımladıktan sonra, aynı script içindeki herhangi bir kod bloğu buna erişebilir. Değişkenler ve fonksiyonlar, local anahtar kelimesi ile tanımlanmadıkça küresel kapsamda olur.

Aşağıdaki kodda, testVar yerel testFunc() fonksiyonu içinde küresel bir kapsamda bulunmaktadır. Luau testFunc() fonksiyonunu çağırdığında, testVar'a 64 değerini atar. testVar küresel bir kapsamda olduğundan, testFunc() dışındaki print() fonksiyonu buna erişebilir ve 64 yazdırabilir.

local function testFunc()  -- yerel kapsam
	testVar = 64  -- küresel kapsam
end

testFunc()

print(testVar) -- 64

Aşağıdaki kodda, küresel değişken x 0 değerinde başlar, her yinelemede for döngüsü ile 1 artar ve ardından son değeri 4 ile tekrar yazdırılır.

x = 0  -- Küresel değişken "x"

for i = 1, 4 do
	x += 1
	print("Küresel 'x' = " .. x)
end

print("Küresel 'x' = " .. x)

--[[ Sonuç çıktısı:
Küresel 'x' = 1
Küresel 'x' = 2
Küresel 'x' = 3
Küresel 'x' = 4
Küresel 'x' = 4
]]

Küresel değişkenler ve fonksiyonlar tanımlamak daha kolaydır çünkü daha az yazmanız gerekir, ancak küresel değişkenler ve fonksiyonlar yerel olanlara göre aşağıdaki dezavantajlara sahiptir:

• Luau, küresel değişkenlere ve fonksiyonlara bir hash araması ile erişir, bu nedenle performans açısından pahalıdır. Zaman kritik bir döngüde bir küresel değişken kullanmak, aynı döngüde bir yerel değişken kullanmaktan %10'dan fazla daha yavaş çalışmasına neden olabilir.
• Luau, yerel değişkenleri kapsamları sona erdikten sonra yok eder, bu da bellek kullanımını azaltır.
• Aynı script içinde küresel değişkenlere ve fonksiyonlara erişebilirsiniz, ancak birden fazla script arasında erişemezsiniz. Bu nedenle, bir küresel değişken veya fonksiyon, kapsamda bir yerel eşdeğer, bir upvalue veya bir gölge ile karşılaştırıldığında herhangi bir avantaj sağlamaz.

Yerel Kapsam

Luau, yalnızca bir yerel değişkeni veya fonksiyonu tanımladığınız kod bloğunda erişebilir. Yerel kapsamda bir değişken oluşturmak, değerinin ne zaman ve nerede değişeceği üzerinde daha sıkı bir kontrol sağlar.

Aşağıdaki kodda, testFunc() fonksiyonu ve testVar değişkeni yerel kapsamda bulunmaktadır. Sadece testFunc() içindeki kod, testVar değişkenine erişebilir. testVar değişkeninin testFunc() dışında bir değeri yoktur, bu nedenle testFunc() içinde print(testVar) çağrısı testVar'ın değerini yazdırır, ancak testFunc() dışında print(testVar) çağrısı nil yazdırır.

local function testFunc()  -- yerel kapsam
	local testVar = 64  -- yerel kapsam
	print(testVar) -- 64
end

testFunc()

print(testVar) -- nil

Aşağıdaki kodda, yerel değişken x 1. satırda 0 değerine sahiptir. Luau, for döngüsü boyunca yineleme yaptıkça, farklı bir yerel değişken x 1 değerine sahiptir. Ardından, Luau başlangıçtaki değişken x'i değişmeden 0 değeri ile yazdırır.

local x = 0  -- Yerel değişken "x"

for i = 1, 4 do
	local x = 1  -- Bu "for" döngüsüne özgü farklı değişken "x"
	print("Döngü 'x' = " .. x)
end

print("Başlangıç 'x' = " .. x)

--[[ Sonuç çıktısı:
Döngü 'x' = 1
Döngü 'x' = 1
Döngü 'x' = 1
Döngü 'x' = 1
Başlangıç 'x' = 0
]]

const değişkenleri ve fonksiyonları, local olanlarla aynı kapsam kurallarını takip eder. Onları herhangi bir blokta, başka bir fonksiyonun içinde de tanımlayabilirsiniz. const hakkında daha fazla bilgi için Const değişkenleri sayfasına bakın.

Yakalama

Bir yerel değişkeni tanımlayıp atadıktan sonra, onu kapsam seviyesinde ve yerel değişkeni içeren aynı kapsamda yer alan fonksiyonlarda okuyabilirsiniz. Bu teknik yakalama olarak bilinir.

Aşağıdaki kodda, f fonksiyonu yerel değişken x'i yakalar. f() içindeki x bir upvalue'dir.

local x = 5

local function f()
	print(x)
end

f() -- 5
print(x) -- 5

Gölgeleme

Bir yerel değişkeni tanımlayıp atadıktan sonra, onu kapsam seviyesinde ve alt kapsam seviyelerinde okuyabilirsiniz. Eğer bir alt kapsam seviyesinde değişkeni yeniden tanımlayıp atarsanız, o zaman en son atamadan farklı bir değere sahip aynı isimde yeni bir yerel değişken oluşturursunuz. Yeni yerel değişken, önceki atamadan gelen yerel değişkeni etkilemez. Bu teknik, gölgeleme olarak bilinir ve bir değişkenin adını yeniden kullanmanıza yardımcı olurken, değerini yeniden kullanmanızı engeller.

Aşağıdaki kodda, Luau değişken x'i gölgeler. f() içindeki x bir gölge değişkenidir.

local x = 5

local function f()
	local x = 7
	print(x)
end

f() -- 7
print(x) -- 5

Ayrıca, bir yerel değişkeni değer atamadan yeniden tanımlayarak, hem kapsam seviyesinde hem de alt kapsam seviyelerinde değişkeni yeniden atayabilirsiniz. Değer atamadan bir yerel değişkeni yeniden tanımlamak, değerini nil olarak ayarlar.

Aşağıdaki kodda, Luau getFruitByColor() fonksiyonundaki yerel değişken fruitName'i gölgeler. Fonksiyon, fruitName'i yeni bir gölge değişkeni olarak yeniden tanımlar ve değerini nil olarak ayarlar. Fonksiyonun bir alt kapsam seviyesi, bir for döngüsü, fruitName'e bir değer atar. For döngüsünden sonra, fonksiyon fruitName gölge değişkenini döndürür. Fonksiyon boyunca, fruitName başlangıçtaki fruitName yerel değişkenini geçersiz kılmayan aynı yerel değişkendir.

local fruitName = "Çikolata"
local fruitTable = {
	Limon = "Sarı",
	Elma = "Kırmızı",
	Portakal = "Turuncu"
}

local function getFruitByColor(color)
	local fruitName
	for key, value in fruitTable do
		if value == color then
			fruitName = key
		end
	end
	return fruitName
end

local fruit = getFruitByColor("Sarı")
print(fruit) -- Limon
print(fruit .. ", değil " .. fruitName) -- Limon, değil Çikolata