Tables

Le type de données de la table peut stocker plusieurs valeurs de n'importe quel type qui n'est pas nil, y compris booleans, 1> nombres1>, 4> chaînes4>, 7> fonctions7> et d'autres tables. Construisez des tables avec des guillettes courantes ( 0> 0> ):

-- Construisez une table vide attribuée à la variable « t »
local t = {}
print(t) -- {}

Vous pouvez utiliser un tableau comme un tableau ou un dictionnaire. Les tableaux utilisent une liste ordonnée de numéros en tant que indexs, mais les dictionnaires peuvent avoir des numéros, des chaînes et des objets comme des index.

Pour plus d'informations sur les fonctions intégrées pour travailler avec des tableaux, voir 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, telles qu'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 un ordre séquentiel, séparées par des virgules.

-- Construisez un tableau avec trois articles
local testArray = {"A string", 3.14159, workspace.Camera}
print(testArray)

Lire à partir des tableaux

Pour lire à partir d'un matrice, ajoutez un couple de paires de parenthèses après sa référence et spécifiez le numéro d'index de l'élément à l'intérieur ( [pos] ):

-- Construisez un tableau avec trois articles
local testArray = {"A string", 3.14159, workspace.Camera}

print(testArray[1]) -- Une chaîne
print(testArray[2]) -- 3.14159
print(testArray[3]) -- Camera

Écrire dans les tableaux

Pour définir ou réécrire la valeur d'un tableau à un index, déclarez le numéro d'index dans les parenthèses carrées ( [index] ) suivi de = et de la valeur :

local testArray = {"A string", 3.14159, workspace.Camera}

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

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

Rotation sur les tableaux

Pour itérer sur un matrice, vous pouvez utiliser un boucle for. Parce que les tableaux ont des index numériques, vous pouvez également utiliser un boucle numérique for à partir de 1 à la longueur du tableau ( 2># array2>).

local testArray = {"A string", 3.14159, workspace.Camera, "New string"}

-- Loop à l'aide de 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 de tableau (#)
for index = 1, #testArray do
	print(index, testArray[index])
end

--[[ Résultat de sortie:
1 A string
2 3.14159
3 Camera
4 New string
1 A string
2 3.14159
3 Camera
4 New string
]]

Insérer des éléments

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

• Passez une référence à l'arrêt et à la valeur de l'élément à Luau's table.insert() fonction.
• Ajoutez le nouvel élément à l'arrêt 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 en tant que deuxième argument de table.insert() . Cela insère le nouvel élément et pousse les éléments suivants d'un position d'index.

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

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

print(testArray[1]) -- Premier item
print(testArray[2]) -- NOUVEL ÉLÉMENT #2
print(testArray[3]) -- Next item

Suppression 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'un position d'index.

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 chacune des clés suivies par = et la valeur . Séparez chaque paire de clés-valeur avec un point-virgule :

local testDictionary = {
	FruitName = "Lemon",
	FruitColor = "Yellow",
	Sour = true
}

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

local part = Instance.new("Part")

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

Lecture à partir des dictionnaires

Pour lire à partir d'un dictionnaire, ajoutez une paire de parenthèses après sa référence et spécifiez le nom de la clé. Référez-vous directement à un élément de chaîne en utilisant des guêtes ( ["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"]) -- Bloquer
-- Omettre des guillettes pour les clés non scriptées
print(testDictionary[part]) -- true

Écrire dans les dictionnaires

Pour définir ou réécrire la valeur d'une nouvelle ou existante clé de dictionnaire, déclarez le nom de la clé dans les parenthèses ( [key] ) suivi de = et 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"]) -- Cerise
print(testDictionary["Sour"]) -- faux
print(testDictionary["FruitCount"]) -- 10

Itération sur les dictionnaires

Pour itérer sur un dictionnaire, utilisez la fonction globale pairs() dans un for boucle :

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
]]

Suppression des paires de valeur clé

Pour supprimer ou effacer une paire clé-valeur d'un dictionnaire, définissez sa valeur pour une clé sur 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
]]

Les 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 à la valeur , ou un pointeur, à la table d'origine. Toute référence à une table reflète les modifications à la table d'origine :

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
]]

Tables de clonage

Clones rapides

Pour copier une table sans tableaux imbriqués, 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 recursive similaire à la suivre:

-- La fonction utilisée pour copier en profondeur une table
local function deepCopy(original)
	-- Définissez la nouvelle table pour la copie
	local copy = {}

	-- Loop à travers la table d'origine pour cloner
	for key, value in original do
		-- Si le type de la valeur est une table, copiez-le en profondeur à la clé (index)
		-- Autre (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

	-- Renvoie la copie finalisée de la table clonée profonde
	return copy
end

Avec la fonction en emplacement, vous pouvez prendre une copie profonde comme suivant :

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

local clone = deepCopy(original)

Tables de congélation

Geler une table la rend inécritible, ce qui est utile pour créer des valeurs constantes que vous ne voulez pas modifier. Geler 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() .

Éclairage léger

Pour geler une table sans tableaux imbriqués, 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

gel profond

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

local function deepFreeze(target)
	-- Générer une table vide
	table.freeze(target)

	-- Vérifiez chaque clé de la table et faites-la geler 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 une table en profondeur 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