Tablolar

tablo veri türü, booleans , sayılar , dize , fonksiyonlar ve diğer tablolar dahil olmak üzere herhangi bir türden çok sayıda değer saklayabilir.Kıvrımlı parantezlerle tablolar oluştur ( {} ):

-- Değişken "t" için atanan boş bir tablo oluştur
local t = {}
print(t) -- {}

Bir tabloyu bir dizin veya sözlük olarak kullanabilirsiniz.Diziler sayıların sıralı bir listesini indeks olarak kullanır, ancak sözlükler sayılar, dize ve nesneler olarak indeks olabilir.

Tablolarla çalışmak için yerleşik işlevler hakkında daha fazla bilgi için, table kütüphanesine bakın.

Diziler

Bir dizilim düzenli bir değer listesidir.Diziler, özel izinlere sahip bir grup oyuncuyla gibi veri koleksiyonlarını depolamak için yararlıdır.

Diziler oluştur Create arrays

Bir Luau tablosu kullanarak bir dizi oluşturmak için, değerleri virgülle ayrılmış sırayla belirtin.

-- Üç öğe ile bir dizi oluştur
local testArray = {"A string", 3.14159, true}
print(testArray)

Dizilerden okuma

Bir dizeden okumak için, referansından sonra bir çift kare parantez ekleyin ve içindeki elemanın indeks numarasını belirtin ( [pos] ):

-- Üç öğe ile bir dizi oluştur
local testArray = {"A string", 3.14159, true}

print(testArray[1]) -- Bir dize
print(testArray[2]) -- 3.14159
print(testArray[3]) -- true

Dizilere yaz

Bir indekste bir dizi değerini tanımlamak veya yeniden yazmak için, indeks numarasını kare parantezlerle ( [index] ) takip eden = ve değer:

local testArray = {"A string", 3.14159, true}

testArray[2] = 12345
testArray[4] = "New string"

print(testArray[2]) --12345
print(testArray[4]) -- New string

Diziler üzerinde döngü geçirme Iterate over arrays

Bir dizi üzerinde döngü yapmak için, bir for döngüsü kullanabilirsiniz.Diziler sayısal indekslere sahip olduğundan, dizi uzunluğuna kadar bir sayısal döngüsü de kullanabilirsiniz ( ).

local testArray = {"A string", 3.14159, true, "New string"}

-- Genel döngü kullanarak döngü oluşturma
for index, value in testArray do
	print(index, value)
end

-- Dizin uzunluğu işlecisi kullanarak döngü yap (#)
for index = 1, #testArray do
	print(index, testArray[index])
end

Eşyaları ekleyin

Bir öğeyi bir dize sonuna eklemek için iki yerleşik yol vardır:

• Dizinin ve öğe değerinin bir referansını Luau'nun table.insert() işlevine geçirin.
• Yeni öğeyi array[#array+1] söntaxını kullanarak dizine ekleyin.

local testArray = {"A string", 3.14159}

table.insert(testArray, "New string")
testArray[#testArray+1] = "Another new string"

print(testArray[3]) -- Yeni dize
print(testArray[4]) -- Another new string

Bir dizi arasındaki bir öğeyi başlangıç ve bitiş arasına eklemek için, table.insert() 'in ikinci argümanı olarak bir konum değeri dahil edin.Bu, yeni öğeyi girer ve aşağıdaki öğeleri bir indeks pozisyonuna ittirir.

local testArray = {"First item", "Next item"}

table.insert(testArray, 2, "NEW ITEM #2")

print(testArray[1]) -- İlk öğe
print(testArray[2]) -- Yeni Eşya #2
print(testArray[3]) -- Next item

Eşyaları kaldır

Bir öğeyi bir dizeden kaldırmak için table.remove() kullanın.Bu, belirtilen pozisyondaki öğeyi kaldırır ve herhangi bir sonraki öğeyi bir indeks pozisyonuna geri hareket ettirir.

local testArray = {"First item", "Next item", "Last item"}

table.remove(testArray, 2)

print(testArray[1]) -- İlk öğe
print(testArray[2]) -- Last item

Sözlükler

Sözlükler, dizilere bir uzantıdır. Sözlükler, anahtarların herhangi bir sayı, dize veya nesne olabileceği bir dizi depolar, değerler.

Sözlükler oluştur

Bir sözlük tablosu oluşturmak için, her bir anahtar ı tanımlayın, ardından = ve değer . Her anahtar-değer çiftini virgülle ayırın:

local testDictionary = {
	fruitName = "Lemon",
	fruitColor = "Yellow",
	sour = true
}

Sözlükler için anahtarlar sayılar, dize ve nesneler olabilir.Örneğin, bir anahtar da bir Instance olabilir.Nesneleri anahtar olarak kullanmak için, anahtarı kare parantezlerle ilan edin ( [key] ):

local part = Instance.new("Part")

local testDictionary = {
	partType = "Block",
	[part] = true
}

Sözlüklerden okuma

Bir sözlükten okumak için, referansından sonra bir çift parantez ekleyin ve anahtar adını belirtin.Doğrudan bir dize anahtarını kullanarak referans verin ( ["key"] ) veya ( .key ), ya da bunun yerine değişken bir değer kullanın ( [key] ).

local part = Instance.new("Part")

local testDictionary = {
	partType = "Block",
	[part] = true
}
-- Dize anahtarları için alıntılar dahil et
print(testDictionary["partType"]) -- Bloğu
-- Veya boşluklar olmadan dizin anahtarlarını indekslemek için . kullanın
print(testDictionary.partType) -- Bloğu
-- Dize olmayan anahtarlar için özellikleri atla
print(testDictionary[part]) -- true

Sözlüklere yaz

Yeni veya mevcut bir sözlük anahtarının değerini tanımlamak veya yeniden yazmak için, anahtar adını parantezlerde ( ) belirtin veya anahtar bir dize ise ( ) ve değeri kullanın:

local testDictionary = {
	fruitName = "Lemon",
	sour = true
}

-- Mevcut anahtarların değerini değiştirme
testDictionary["fruitName"] = "Cherry"
testDictionary.sour = false

-- Yeni anahtar-değer çifti ekleyin
testDictionary.fruitCount = 10

print(testDictionary.fruitName) -- Kiraz
print(testDictionary.sour) -- sahte
print(testDictionary.fruitCount) -- 10

Sözlüklere tekrar edin

Bir sözlüğü döngüye sokmak için, bir for döngüsü kullanın:

local testDictionary = {
	fruitName = "Lemon",
	fruitColor = "Yellow",
	sour = true
}

for key, value in testDictionary do
	print(key, value)
end

--[[ Sonuç çıkışı:
fruitName Lemon
sour true
fruitColor Yellow
]]

Anahtar-değer çiftlerini kaldır

Bir sözlükten bir anahtar-değer çiftini kaldırmak veya silmek için, değerini bir anahtar için nil olarak ayarlayın.

local testDictionary = {
	fruitName = "Lemon",
	fruitColor = "Yellow",
	sour = true
}

testDictionary.sour = nil

for key, value in testDictionary do
	print(key, value)
end
--[[ Sonuç çıkışı:
fruitName Lemon
fruitColor Yellow
]]

Referans olarak tablolar

Yeni bir değişken içine bir tablo saklarsanız, Luau bu tablonun bir kopyasını oluşturmaz.Bunun yerine, değişken orijinal tabloya referans veya işaret olur.Bir tabloya yapılan herhangi bir referans, orijinal tablodaki herhangi bir değişikliği yansıtır:

local originalArray = {10, 20}

local arrayReference = originalArray

print("Original:", originalArray[1], originalArray[2])
print("Reference:", arrayReference[1], arrayReference[2])

-- Orijinal dize değerlerini değiştir Change values in original array
originalArray[1] = 1000
originalArray[2] = 2000

print("Reference:", arrayReference[1], arrayReference[2])

--[[ Sonuç çıkışı:
Original: 10 20
Reference: 10 20
Reference: 1000 2000
]]

Tabloları klonla

Derin olmayan klonlar

İç içe geçmiş tablolara sahip olmadan bir tabloyu kopyalamak için, Luau table.clone() yöntemini sunar.

local original = {
	key = "value",
	engine = "Roblox",
	playerID = 505306092
}

local clone = table.clone(original)

Derin klonlar

İçinde çember içeren daha karmaşık bir tabloyu kopyalamak için, aşağıdakine benzer bir recursive işlev kullanmanız gerekecektir:

-- Bir tabloyu derin olarak klonlamak için kullanılan işlev
local function deepClone(original)
	-- Kopya için yeni tabloyu tanımla
	local clone = table.clone(original) 

	-- Tablo değerlerini kontrol etmek için orijinal tabloyu dolaşın
	-- Bir tablo bir değer olarak bulunduysa, anahtara (index) derin kopyalayın
	for key, value in original do
		if type(value) == "table" then
			clone[key] = deepClone(value)
		end
	end

	-- Derin klonlanmış tablonun son kopyasını döndür
	return clone
end

İşlev yerinde olduğundan, şu şekilde derin bir kopya oluşturabilirsiniz:

local original = {
	key = "value",
	playerInfo = {
		playerID = 505306092,
		playerName = "PlayerName"
	},
	otherInfo = {
		{
			{1, 3, 5, 7, 9}
		}
	}
}

local clone = deepClone(original)

Tabloları dondurma

Bir tabloyu dondurmak onu okunur olarak yapar, ki bu değiştirmek istemediğiniz sabit değerler oluşturmak için yararlıdır.Donma kalıcıdır; "çözme" veya "eritme" yöntemi yoktur.Bir tablonun donup donmadığını kontrol etmek için, table.isfrozen() kullanın.

Derin dondurma

İç içe geçmiş tablolara sahip olmadan bir tabloyu dondurmak için, Luau table.freeze() yöntemini sunar.

local target = {
	key = "value",
	engine = "Roblox",
	playerID = 505306092
}

table.freeze(target)
target.playerID = 1 --> attempt to modify a readonly table

Derin dondurma

İçinde yer alan karmaşık bir tabloyu dondurmak için, aşağıdakine benzer bir recursive işlev kullanın:

local function deepFreeze(target)
	-- Tabloyu yüzeysel dondurun
	table.freeze(target)

	-- Tablonun her anahtarını kontrol edin ve bir tabloysa dondurun
	for _, value in target do
		-- Değerin dondurulmadığından emin olun; eğer zaten öyleyse, bir hata oluşur
		if type(value) == "table" and table.isfrozen(value) == false then
			deepFreeze(v)
		end
	end
end

İşlev yerinde olduğundan, bir tabloyu aşağıdaki gibi derin dondurabilirsiniz:

local target = {
	key = "value",
	playerInfo = {
		playerID = 505306092,
		playerName = "PlayerName"
	},
	otherInfo = {
		{
			{1, 3, 5, 7, 9}
		}
	}
}

deepFreeze(target)
target.playerInfo.playerID = 1 --> attempt to modify a readonly table