Tables

Le type de données de la table peut stocker plusieurs valeurs de n'importe quel type qui ne sont pas , y compris booléens , nombres , chaînes , fonctions et d'autres tables.Construire des tables avec des crochets courbes ( {} ):

-- Construire une table vide attribuée à la variable "t"
local t = {}
print(t) -- {}

Vous pouvez utiliser une table comme tableau ou dictionnaire.Les tableaux utilisent une liste ordonnée de nombres comme index, mais les dictionnaires peuvent avoir des nombres, des chaînes et des objets comme index.

Pour plus d'informations sur les fonctions intégrées pour travailler avec des tables, voir la bibliothèque table.

Tables d'arrêt

Un array est une liste ordonnée de valeurs.Les tableaux sont utiles pour stocker des collections de données, comme un groupe de joueurs avec des permissions spéciales.

Créer des tableaux

Pour créer un tableau à l'aide d'une table Luau, déclarez les valeurs dans l'ordre séquentiel, séparées par des virgules.

-- Construire un tableau avec trois éléments
local testArray = {"A string", 3.14159, true}
print(testArray)

Lire à partir d'arrays

Pour lire à partir d'un tableau, ajoutez une paire de crochets carrés après sa référence et spécifiez le numéro d'index de l'élément à l'intérieur ( [pos] ):

-- Construire un tableau avec trois éléments
local testArray = {"A string", 3.14159, true}

print(testArray[1]) -- Un texte
print(testArray[2]) -- 3.14159
print(testArray[3]) -- true

Écrire dans des tableaux

Pour définir ou réécrire la valeur d'un tableau à un index, déclarez le numéro d'index dans des crochets carrés ( [index] ) suivi de = et de la valeur :

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

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

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

Itérer sur les tableaux

Pour itérer sur un tableau, vous pouvez utiliser une boucle for.Comme les tableaux ont des index numériques, vous pouvez également utiliser une boucle numérique de la longueur de l'array ( ).

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

-- Boucle en utilisant une itération générale
for index, value in testArray do
	print(index, value)
end

-- Itérer en utilisant l'opérateur de longueur de l'array (#)
for index = 1, #testArray do
	print(index, testArray[index])
end

Insérer des éléments

Il y a deux façons intégrées d'insérer un élément à la fin de l'array :

• Passez une référence à l'array et la valeur de l'élément à la fonction Luau's table.insert() .
• Ajoutez le nouvel élément à l'array en utilisant la syntaxe array[#array+1].

local testArray = {"A string", 3.14159}

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

print(testArray[3]) -- Nouvelle chaîne
print(testArray[4]) -- Another new string

Pour insérer un élément entre le début et la fin d'un tableau, incluez une valeur de position comme deuxième argument de table.insert() .Cela insère le nouvel élément et pousse les éléments suivants d'une position d'index vers le haut.

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

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

print(testArray[1]) -- Premier article
print(testArray[2]) -- NOUVEL ITEM #2
print(testArray[3]) -- Next item

Supprimer des éléments

Pour supprimer un élément d'un tableau, utilisez table.remove() .Cela supprime l'élément à la position spécifiée et déplace tous les éléments suivants d'une position d'index vers l'arrière.

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

table.remove(testArray, 2)

print(testArray[1]) -- Premier article
print(testArray[2]) -- Last item

Dictionnaires

Les dictionnaires sont une extension des tableaux. Les dictionnaires stockent un ensemble de paires clé-valeur, où les clés peuvent être n'importe quel nombre, chaîne ou objet.

Créer des dictionnaires

Pour créer une table de dictionnaire, définissez chaque clé suivie de = et de la valeur . Séparez chaque paire de clé-valeur avec une virgule :

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

Les clés pour les dictionnaires peuvent être des nombres, des chaînes et des objets.Par exemple, une clé peut également être un Instance.Pour utiliser des objets comme clés, déclarez la clé dans des crochets carrés ( [key] ):

local part = Instance.new("Part")

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

Lire à partir de dictionnaires

Pour lire à partir d'un dictionnaire, ajoutez une paire de crochets après sa référence et spécifiez le nom de la clé.Faites référence directement à une clé de chaîne en utilisant either ( ["key"] ) ou ( .key ), ou utilisez plutôt une valeur de variable ( [key] ).

local part = Instance.new("Part")

local testDictionary = {
	partType = "Block",
	[part] = true
}
-- Inclure des citations pour les clés de chaîne
print(testDictionary["partType"]) -- Bloc
-- Ou utilisez . pour indexer les clés de chaîne sans espaces
print(testDictionary.partType) -- Bloc
-- Omettre les quotes pour les clés non-chaîne
print(testDictionary[part]) -- true

Écrire dans les dictionnaires

Pour définir ou réécrire la valeur d'une clé de dictionnaire nouvelle ou existante, déclarez le nom de la clé entre parenthèses ( [key] ) ou, si la clé est une chaîne, utilisez ( .key ) suivi de = et de la valeur :

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

-- Changer la valeur des clés existantes
testDictionary["fruitName"] = "Cherry"
testDictionary.sour = false

-- Insérer une nouvelle paire clé-valeur
testDictionary.fruitCount = 10

print(testDictionary.fruitName) -- Cerise
print(testDictionary.sour) -- faux
print(testDictionary.fruitCount) -- 10

Itérer sur les dictionnaires

Pour itérer sur un dictionnaire, utilisez une boucle for :

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

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

--[[ Résultat de sortie :
fruitName Lemon
sour true
fruitColor Yellow
]]

Supprimer les paires clé-valeur

Pour supprimer ou effacer une paire clé-valeur d'un dictionnaire, définissez sa valeur pour une clé à nil .

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

testDictionary.sour = nil

for key, value in testDictionary do
	print(key, value)
end
--[[ Résultat de sortie :
fruitName Lemon
fruitColor Yellow
]]

Tables en tant que références

Si vous stockez une table dans une nouvelle variable, Luau ne crée pas une copie de cette table.Au lieu de cela, la variable devient une référence de référence ou un pointeur vers la table originale.Toute référence à une table reflète tout changement apporté à la table originale :

local originalArray = {10, 20}

local arrayReference = originalArray

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

-- Changer les valeurs dans l'array original
originalArray[1] = 1000
originalArray[2] = 2000

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

--[[ Résultat de sortie :
Original: 10 20
Reference: 10 20
Reference: 1000 2000
]]

Cloner les tables

Clones superficiels

Pour copier une table sans tables imbriquées, Luau offre la méthode table.clone().

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

local clone = table.clone(original)

Clones profonds

Pour copier une table plus complexe avec des tables imbriquées à l'intérieur, vous devrez utiliser une fonction récursive similaire à la suivante :

-- La fonction utilisée pour la clonage profond d'une table
local function deepClone(original)
	-- Définir la nouvelle table pour la copie
	local clone = table.clone(original) 

	-- Loop à travers la table originale pour vérifier les valeurs de table
	-- Si une table est trouvée comme valeur, clone-la profondément à la clé (index)
	for key, value in original do
		if type(value) == "table" then
			clone[key] = deepClone(value)
		end
	end

	-- Retourner la copie finale de la table clonée profonde
	return clone
end

Avec la fonction en place, vous pouvez faire une copie profonde comme suivant :

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

local clone = deepClone(original)

Geler les tables

Geler une table la rend lisible, ce qui est utile pour créer des valeurs constantes que vous ne voulez pas modifier.Le gel est permanent ; il n'y a pas de méthode « dégeler » ou « décongeler ».Pour vérifier si une table est gelée, utilisez table.isfrozen() .

Gel superficiel

Pour geler une table sans tables imbriquées, Luau offre la méthode table.freeze().

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

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

Gels profonds

Pour geler une table plus complexe avec des tables imbriquées à l'intérieur, utilisez une fonction récursive similaire à la suivante :

local function deepFreeze(target)
	-- Gel superficiel de la table
	table.freeze(target)

	-- Vérifiez chaque clé de la table et congelez-la si c'est une table
	for _, value in target do
		-- Assurez-vous que la valeur n'est pas gelée ; si elle l'est déjà, une erreur se produira
		if type(value) == "table" and table.isfrozen(value) == false then
			deepFreeze(v)
		end
	end
end

Avec la fonction en place, vous pouvez geler profondément une table comme suivant :

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