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 genel veya yerel olabilir. Tüm bloklar genel değişkenlere ve fonksiyonlara erişebilir. Bir blok, üst bloktaki yerel değişkenlere ve fonksiyonlara erişebilir, ancak alt bloktaki değişkenlere ve fonksiyonlara erişemez.

Değişkenler ve fonksiyonlar varsayılan olarak genel bir kapsama sahiptir, ancak çoğu zaman yerel kapsamda bildirmek daha iyidir çünkü Luau, yerel değişkenlere ve fonksiyonlara genel olanlardan daha hızlı erişir. Bir değişkenin veya fonksiyonun yerel kapsamda olmasını sağlamak için, onu bildirdiğinizde adının önüne local anahtar kelimesini koyun.

Scriptler, diğer scriptlerdeki genel ve yerel değişkenlere veya fonksiyonlara erişemez. Eğer değerleri ve fonksiyonları scriptler arasında 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.

Genel kapsam

Bir genel değişken veya fonksiyon bildirdikten sonra, aynı script içindeki herhangi bir kod bloğu buna erişebilir. Değişkenler ve fonksiyonlar, local anahtar kelimesi ile bildirilmedikleri sürece genel kapsamda bulunurlar.

Aşağıdaki kodda, testVar yerel testFunc() fonksiyonunun içinde genel bir kapsama sahiptir. Luau testFunc() çağırdığında, testVar değerini 64 olarak atar. testVar genel bir kapsama sahiptir, bu nedenle testFunc() dışında bulunan print() fonksiyonu buna erişebilir ve 64 yazdırabilir.

Genel fonksiyonlar ve değişkenler örneği
local function testFunc()  -- yerel kapsam
	testVar = 64  -- genel kapsam
end

testFunc()

print(testVar) -- 64

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

x = 0  -- Genel değişken "x"

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

print("Genel 'x' = " .. x)

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

Genel değişkenleri ve fonksiyonları bildirmek daha kolaydır çünkü daha az yazmanız gerekir, ancak genel değişkenlerin ve fonksiyonların yerel olanlarla karşılaştırıldığında bazı dezavantajları vardır:

• Luau genel değişkenlere ve fonksiyonlara hash araması ile eriştiğinden, bu modül performans açısından maliyetlidir. Zaman açısından kritik bir döngüde bir genel değişken kullanmak, aynı döngüde bir yerel değişken kullanmaktan %10'dan fazla daha yavaş performans sergileyebilir.
• Luau, yerel değişkenleri kapsamları sona erdiğinde tasfiye eder, bu da bellek kullanımını azaltır.
• Aynı script içinde genel değişkenlere ve fonksiyonlara erişebilirsiniz, ancak birden fazla script arasında erişemezsiniz. Bu nedenle, bir genel değişken veya fonksiyon, kapsamda bulunan bir yerel eşdeğeri, 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, bildirdiğiniz kod bloğunda erişebilir. Yerel kapsamda bir değişken oluşturmak, ne zaman ve nerede değerinin değiştiği üzerinde daha sıkı bir kontrol sağlar.

Aşağıdaki kodda, testFunc() fonksiyonu ve testVar değişkeni yerel kapsama sahiptir. Sadece testFunc() içindeki kod, testVar değişkenine erişebilir. testVar değişkeni testFunc() dışında bir değere sahip olmadığı için, testFunc() içinde print(testVar) çağrıldığında testVar değerini yazdırır, ancak testFunc() dışında çağrıldığında 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 ilerledikçe, farklı bir yerel değişken x 1 değerine sahiptir. Ardından Luau, değişmeyen 0 değeri ile başlangıçta tanımlanan x değişkenini 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
]]

Yakalama

Bir yerel değişkeni bildirdikten ve atadıktan sonra, onu kapsam seviyesinde ve yerel değişkeni içeren aynı kapsamı kapsayan fonksiyonlarda okuyabilirsiniz. Bu tekniğe yakalama denir.

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

local x = 5

local function f()
	print(x)
end

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

Gölge

Bir yerel değişkeni bildirdikten ve atadıktan sonra, onu kapsam seviyesinde ve soyut kapsam seviyelerinde okuyabilirsiniz. Eğer bir alt kapsam seviyesinde değişkeni yeniden bildirirseniz ve atama yaparsanız, en son atamadan farklı bir değere sahip olan aynı isimde yeni bir yerel değişken oluşturmuş olursunuz. Yeni yerel değişken, önceki atamadan gelen yerel değişkeni etkilemez. Bu tekniğe gölgeleme denir ve bir değişkenin adını yeniden kullanmanıza yardımcı olurken değerini yeniden kullanmanızı önler.

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 atama yapmadan yeniden bildirebilirsiniz, böylece hem kapsam seviyesinde hem de alt kapsam seviyelerinde değişkeni yeniden atayabilirsiniz. Bir yerel değişkeni, değer atanmadan yeniden bildirmek, değerini nil olarak ayarlar.

Aşağıdaki kodda, Luau getFruitByColor() fonksiyonundaki yerel değişken fruitName'i gölgeler. Fonksiyon, fruitName'yi yeni bir gölge değişkeni olarak yeniden bildirir ve değerini nil olarak ayarlar. Fonksiyon, bir soyut kapsam seviyesine, bir for döngüsüne sahiptir ve bu döngüde fruitName'e 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