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 matrice, 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 chaîne
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 matrice, 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'matrice:

• 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 matrice, 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 item
print(testArray[2]) -- NOUVEL ITEM #2
print(testArray[3]) -- Next item

Supprimer des éléments

Pour supprimer un élément d'un matrice, 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 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 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 des guillemets ( ["key"] ) ou utilisez 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
-- 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] ) 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 la fonction globale pairs() dans une boucle for :

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

for key, value in pairs(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 pairs(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'matriceoriginal
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 suivre:

-- La fonction utilisée pour la copie profonde d'une table
local function deepCopy(original)
	-- Définir la nouvelle table pour la copie
	local copy = {}

	-- Boucle à travers la table originale pour cloner
	for key, value in original do
		-- Si le type de la valeur est une table, faites-en une copie profonde à la clé (index)
		-- Autrement (ou) le type n'est pas une table, attribuez la valeur par défaut à l'index à la place
		copy[key] = type(value) == "table" and deepCopy(value) or value
	end

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

Avec la fonction en emplacement, 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 = deepCopy(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 suivre:

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 _, v in target do
		if type(v) == "table" then
			deepFreeze(v)
		end
	end
end

Avec la fonction en emplacement, 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