Tables | Documentation - Hub Création Roblox

Le type de données table peut stocker plusieurs valeurs de tout type qui n'est pas nil, y compris des booléens, des nombres, des chaînes de caractères, des fonctions et d'autres tables. Construisez des tables avec des accolades ({}):

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

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

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

Tableaux

Un tableau 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 autorisations 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 des tableaux

Pour lire à partir d'un tableau, ajoutez une paire de crochets 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]) -- A string
print(testArray[2]) -- 3.14159
print(testArray[3]) -- true

Contrairement à certains langages, Luau utilise l'indexation à base 1 pour les tableaux, donc le premier élément du tableau est [1], pas [0].

Écrire dans les tableaux

Pour définir ou réécrire la valeur d'un tableau à un index, déclarez le numéro d'index entre crochets ([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 des tableaux

Pour itérer sur un tableau, vous pouvez utiliser une boucle for. Comme les tableaux ont des indices numériques, vous pouvez également utiliser une boucle for numérique de 1 à la longueur du tableau (#array).

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

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

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

Insérer des éléments

Il existe deux manières intégrées d'insérer un élément à la fin d'un tableau :

Passez une référence au tableau et la valeur de l'élément à la fonction table.insert() de Luau.
Ajoutez le nouvel élément au tableau 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]) -- New string
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'un index vers le haut.

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

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

print(testArray[1]) -- First item
print(testArray[2]) -- NEW 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'un index vers le bas.

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

table.remove(testArray, 2)

print(testArray[1]) -- First item
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 clé-valeur par 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é entre crochets ([cle]) :

local part = Instance.new("Part")

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

Lire à partir des 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é. Référencez directement une clé de chaîne en utilisant soit (["key"]) soit (.key), ou utilisez plutôt une valeur variable ([key]).

local part = Instance.new("Part")

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

Écrire dans les dictionnaires

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

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

-- Modifier 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) -- Cherry
print(testDictionary.sour) -- false
print(testDictionary.fruitCount) -- 10

Itérer sur des 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 :
fruitName Lemon
sour true
fruitColor Yellow
]]

Supprimer des 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 :
fruitName Lemon
fruitColor Yellow
]]

Tables comme références

Si vous stockez une table dans une nouvelle variable, Luau ne crée pas de copie de cette table. Au lieu de cela, la variable devient une référence, ou pointeur, vers la table originale. Toute référence à une table reflète les modifications apportées à 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 le tableau original
originalArray[1] = 1000
originalArray[2] = 2000

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

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

Cloner des tables

Clones peu profonds

Pour copier une table sans aucune table imbriquée, Luau propose 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 à celle-ci :

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

	-- Boucle à travers la table originale pour vérifier les valeurs de table
	-- Si une table est trouvée comme valeur, clonez-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 finalisée de la table clonée profondément
	return clone
end

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

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

local clone = deepClone(original)

Geler des tables

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

Geler peu profondément

Pour geler une table sans aucune table imbriquée, Luau propose la méthode table.freeze().

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

table.freeze(target)
target.playerID = 1 --> tentative de modifier une table en lecture seule

Geler profondément

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

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

	-- Vérifiez chaque clé de la table et gel 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(value)
		end
	end
end

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

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

deepFreeze(target)
target.playerInfo.playerID = 1 --> tentative de modifier une table en lecture seule