ขอบเขต

ในการเขียนสคริปต์ บล็อกของโค้ดคือเนื้อหาของ โครงสร้างควบคุม หรือ ฟังก์ชัน ขอบเขตของตัวแปรหรือฟังก์ชันคือบล็อกของโค้ดที่สามารถเข้าถึงได้ และสามารถเป็น ทั่วโลก หรือ ท้องถิ่น บล็อกทั้งหมดสามารถเข้าถึงตัวแปรและฟังก์ชันทั่วโลกได้ บล็อกสามารถเข้าถึงตัวแปรและฟังก์ชันท้องถิ่นในบล็อกพ่อแม่ของมัน แต่ไม่สามารถเข้าถึงในบล็อกลูกใด ๆ

ตัวแปรและฟังก์ชันมีขอบเขตทั่วโลกตามค่าเริ่มต้น แต่โดยทั่วไปแล้วจะดีกว่าที่จะประกาศพวกมันด้วยขอบเขตท้องถิ่นเพราะ Luau เข้าถึงตัวแปรและฟังก์ชันท้องถิ่นได้เร็วกว่าตัวแปรทั่วโลก เพื่อให้ตัวแปรหรือฟังก์ชันมีขอบเขตท้องถิ่น ให้ใส่คีย์เวิร์ด local ก่อนชื่อของมันเมื่อคุณประกาศ

สคริปต์ไม่สามารถเข้าถึงตัวแปรหรือฟังก์ชันทั่วโลกและท้องถิ่นในสคริปต์อื่น หากคุณต้องการแชร์ค่าและฟังก์ชันระหว่างสคริปต์ ให้ใช้ ModuleScripts.

local helloWorld = 'Hello World!'
local function printHelloWorld()
	print(helloWorld)
end
printHelloWorld() -- Hello World!

• บล็อก B สามารถ เข้าถึงตัวแปรท้องถิ่นในบล็อก A
• บล็อก C สามารถ เข้าถึงตัวแปรและฟังก์ชันท้องถิ่นในบล็อก A และ B
• บล็อก A ไม่สามารถ เข้าถึงตัวแปรและฟังก์ชันท้องถิ่นในบล็อก B หรือ C
• บล็อก B ไม่สามารถ เข้าถึงตัวแปรท้องถิ่นในบล็อก C

ขอบเขตทั่วโลก

หลังจากที่คุณประกาศตัวแปรหรือฟังก์ชันทั่วโลก บล็อกของโค้ดใด ๆ ใน สคริปต์ เดียวกันสามารถเข้าถึงมันได้ ตัวแปรและฟังก์ชันมีขอบเขตทั่วโลก เว้นแต่คุณจะประกาศพวกมันด้วยคีย์เวิร์ด local

ในโค้ดต่อไปนี้ testVar มีขอบเขตทั่วโลกภายในฟังก์ชันท้องถิ่น testFunc() เมื่อ Luau เรียก testFunc() มันจะกำหนดค่า testVar เป็น 64 ตัวแปร testVar มีขอบเขตทั่วโลก ดังนั้นฟังก์ชัน print() ที่อยู่นอก testFunc() สามารถเข้าถึงมันและพิมพ์ 64

local function testFunc()  -- ขอบเขตท้องถิ่น
	testVar = 64  -- ขอบเขตทั่วโลก
end

testFunc()

print(testVar) -- 64

ในโค้ดต่อไปนี้ ตัวแปรทั่วโลก x เริ่มต้นที่ 0 เพิ่มขึ้น 1 ในแต่ละรอบของ for loop และพิมพ์อีกครั้งหลังจากนั้นด้วยค่าที่สุดท้ายเป็น 4

x = 0  -- ตัวแปรทั่วโลก "x"

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

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

--[[ ผลลัพธ์ที่ได้:
Global 'x' = 1
Global 'x' = 2
Global 'x' = 3
Global 'x' = 4
Global 'x' = 4
]]

การประกาศตัวแปรและฟังก์ชันทั่วโลกนั้นง่ายกว่าเพราะคุณไม่ต้องพิมพ์มากนัก แต่ตัวแปรและฟังก์ชันทั่วโลกมีข้อเสียต่อไปนี้เมื่อเปรียบเทียบกับตัวแปรท้องถิ่น:

• Luau เข้าถึงตัวแปรและฟังก์ชันทั่วโลกด้วยการค้นหาฮาช ดังนั้นมันจึงมีค่าใช้จ่ายสูงในแง่ของประสิทธิภาพ การใช้ตัวแปรทั่วโลกในลูปที่มีความสำคัญต่อเวลาอาจทำให้มันทำงานช้ากว่าการใช้ตัวแปรท้องถิ่นในลูปเดียวกันมากกว่า 10%
• Luau จะกำจัดตัวแปรท้องถิ่นหลังจากที่ขอบเขตของมันสิ้นสุดลง ลดการใช้หน่วยความจำ
• คุณสามารถเข้าถึงตัวแปรและฟังก์ชันทั่วโลกภายในสคริปต์เดียวกัน แต่ไม่สามารถเข้าถึงระหว่างหลายสคริปต์ ดังนั้น ตัวแปรหรือฟังก์ชันทั่วโลกจึงไม่ให้ประโยชน์ใด ๆ เมื่อเปรียบเทียบกับตัวแปรท้องถิ่นที่อยู่ในขอบเขต, upvalue, หรือ shadow.

ขอบเขตท้องถิ่น

Luau สามารถเข้าถึงตัวแปรหรือฟังก์ชันท้องถิ่นได้เฉพาะในบล็อกของโค้ดที่คุณประกาศมัน การสร้างตัวแปรด้วยขอบเขตท้องถิ่นช่วยให้คุณควบคุมได้มากขึ้นว่าเมื่อใดและที่ไหนค่าของมันจะเปลี่ยนแปลง

ในโค้ดต่อไปนี้ ฟังก์ชัน testFunc() และตัวแปร testVar มีขอบเขตท้องถิ่น เฉพาะโค้ดภายใน testFunc() เท่านั้นที่สามารถเข้าถึงตัวแปร testVar ตัวแปร testVar ไม่มีค่าอยู่นอก testFunc() ดังนั้นการเรียก print(testVar) ภายใน testFunc() จะพิมพ์ค่าของ testVar แต่การเรียก print(testVar) ภายนอก testFunc() จะพิมพ์ nil

local function testFunc()  -- ขอบเขตท้องถิ่น
	local testVar = 64  -- ขอบเขตท้องถิ่น
	print(testVar) -- 64
end

testFunc()

print(testVar) -- nil

ในโค้ดต่อไปนี้ ตัวแปรท้องถิ่น x มีค่า 0 ที่บรรทัด 1 ขณะที่ Luau ทำการวนซ้ำผ่าน for loop ตัวแปรท้องถิ่นที่แตกต่างกัน x มีค่า 1 จากนั้น Luau จะพิมพ์ตัวแปรเริ่มต้น x ด้วยค่าที่ไม่เปลี่ยนแปลง 0

local x = 0  -- ตัวแปรท้องถิ่น "x"

for i = 1, 4 do
	local x = 1  -- ตัวแปรที่แตกต่าง "x" ท้องถิ่นสำหรับลูป "for" นี้
	print("Loop 'x' = " .. x)
end

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

--[[ ผลลัพธ์ที่ได้:
Loop 'x' = 1
Loop 'x' = 1
Loop 'x' = 1
Loop 'x' = 1
Initial 'x' = 0
]]

ตัวแปรและฟังก์ชัน const จะปฏิบัติตามกฎขอบเขตเดียวกันกับตัวแปร local คุณสามารถประกาศพวกมันในบล็อกใดก็ได้ รวมถึงภายในฟังก์ชันอื่น สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ const ดูที่ ตัวแปร Const.

การจับ

หลังจากที่คุณประกาศและกำหนดค่าตัวแปรท้องถิ่น คุณสามารถอ่านมันในระดับขอบเขตของมันและฟังก์ชันที่มีขอบเขตที่ถูกห่อหุ้มโดยขอบเขตเดียวกันที่มีตัวแปรท้องถิ่น เทคนิคนี้เรียกว่า การจับ

ในโค้ดต่อไปนี้ ฟังก์ชัน f จับตัวแปรท้องถิ่น x ตัวแปร x ใน f() เป็น upvalue

local x = 5

local function f()
	print(x)
end

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

เงา

หลังจากที่คุณประกาศและกำหนดค่าตัวแปรท้องถิ่น คุณสามารถอ่านมันในระดับขอบเขตของมันและระดับขอบเขตที่สืบทอด หากคุณประกาศใหม่และกำหนดค่าตัวแปรในระดับขอบเขตที่สืบทอด คุณจะสร้างตัวแปรท้องถิ่นใหม่ที่มีชื่อเดียวกันแต่มีค่าที่แตกต่างจากการกำหนดค่าครั้งล่าสุด ตัวแปรท้องถิ่นใหม่จะไม่ส่งผลกระทบต่อตัวแปรท้องถิ่นจากการกำหนดค่าครั้งก่อน เทคนิคนี้เรียกว่า การเงา ช่วยให้คุณสามารถใช้ชื่อของตัวแปรซ้ำโดยไม่ใช้ค่าของมันซ้ำ

ในโค้ดต่อไปนี้ Luau เงาตัวแปร x ตัวแปร x ใน f() เป็นตัวแปร เงา

local x = 5

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

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

คุณยังสามารถประกาศตัวแปรท้องถิ่นใหม่โดยไม่กำหนดค่าให้กับมันเพื่อให้คุณสามารถกำหนดค่าตัวแปรใหม่ในทั้งระดับขอบเขตของมันและระดับขอบเขตที่สืบทอด การประกาศตัวแปรท้องถิ่นใหม่โดยไม่กำหนดค่าให้กับมันจะตั้งค่าค่าของมันเป็น nil

ในโค้ดต่อไปนี้ Luau เงาตัวแปรท้องถิ่น fruitName ในฟังก์ชัน getFruitByColor() ฟังก์ชันนี้ประกาศ fruitName เป็นตัวแปรเงาใหม่และตั้งค่าค่าของมันเป็น nil ฟังก์ชันนี้มีระดับขอบเขตที่สืบทอด, for loop, ที่กำหนดค่าตัวแปร fruitName หลังจากลูป for ฟังก์ชันจะส่งคืนตัวแปรเงา fruitName ตลอดทั้งฟังก์ชัน fruitName เป็นตัวแปรท้องถิ่นเดียวกันที่ไม่เขียนทับตัวแปรท้องถิ่น fruitName เริ่มต้น

local fruitName = "Chocolate"
local fruitTable = {
	Lemon = "Yellow",
	Apple = "Red",
	Orange = "Orange"
}

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("Yellow")
print(fruit) -- Lemon
print(fruit .. ", not " .. fruitName) -- Lemon, not Chocolate