Introduction aux dictionnaires | Documentation

Les dictionnaires sont des tables qui associent des noms ou clés à une valeur au lieu d'un index.

Exemple :

Syntaxe du dictionnaire Luau
local pet = {
   Name = "Bobbie",
   Type = "Chien",
}

Utilisez des dictionnaires lorsque vous devez étiqueter des valeurs, et non pas simplement les énumérer dans l'ordre comme le fait un tableau. Pratiquez l'utilisation de dictionnaires dans ce tutoriel en manipulant des valeurs associées à un joueur.

Syntaxe des dictionnaires

Comme les tableaux, les dictionnaires sont assignés à une variable avec des accolades {}. Les paires clé-valeur sont stockées sur des lignes séparées suivies d'une virgule. Les clés et les valeurs peuvent être de tout type de données, y compris des chaînes, des nombres et des noms de variables.


local playerNames = {
	player1 = "Zap",
	player2 = "Kel",
}
print(playerNames["player1"])

Pour référencer des parties ou d'autres objets instanciés en tant que clés, utilisez des crochets.


local greenPart = workspace.GreenPart
local redPart = workspace.RedPart

local partList = {
	[greenPart] = true,
	[redPart] = false,
}
print(partList[redPart])

Utilisez des types de données cohérents pour les clés de dictionnaire. Le mélange des types de données, comme l'utilisation à la fois de chaînes et de variables pour les clés, peut entraîner des résultats incohérents lors de la manipulation du tableau et confondre d'autres programmeurs.

Créer un dictionnaire

Un usage quotidien des dictionnaires est d'organiser les informations sur les joueurs ou les personnages. Ces étapes explorent comment les informations d'un personnage ennemi théorique peuvent être stockées et accessibles.

Dans un nouveau script, créez un dictionnaire nommé enemy.
```
local enemy = {

}
```
La première clé dans le dictionnaire suivra le nom de l'ennemi avec une variable appelée Name.
```
local enemy = {
	Name
}
```

Assignez un nom d'ennemi à la clé, suivi d'une virgule.


local enemy = {
	Name = "Spike",
}

Ajoutez une seconde paire clé-valeur pour combien de points de vie l'ennemi devrait avoir. N'oubliez pas que les clés doivent toujours utiliser le même type de données, mais les valeurs n'ont pas à le faire.
```
local enemy = {
	Name = "Spike",
	Health = 1000,
}
```

Utiliser les valeurs de dictionnaire

Il y a deux façons d'accéder aux valeurs du dictionnaire :

tableName["keyName"] (notez bien les guillemets)
tableName.keyName


local enemy = {
	Name = "Spike",
	Health = 1000,
}

print("Le méchant " .. enemy["Name"] .. " s'approche !")
print("Le méchant " .. enemy.Name .. " s'approche !")

Le style à utiliser dépend généralement de l'objectif du tableau. Pour les tableaux contenant une collection de valeurs, comme une liste de joueurs dans un serveur, les programmeurs utiliseront généralement tableName["keyName"]. Pour un dictionnaire utilisé pour décrire un objet, les programmeurs sont plus susceptibles d'utiliser tableName.keyName.

Changer une valeur de dictionnaire

Changer la valeur d'une clé est le même que n'importe quelle autre variable ; utilisez l'opérateur égal =.

Sous la table enemy, définissez le nom de l'ennemi sur quelque chose d'autre.


local enemy = {
	Name = "Spike",
	Health = 1000,
}

enemy.Name = "Rana"

print("Le nom de l'ennemi est " .. enemy.Name)

Testez le jeu et vérifiez la fenêtre de sortie.

Variables préexistantes comme clés

Les dictionnaires peuvent interagir avec des variables préexistantes déclarées dans d'autres parties d'un script. L'exemple de code suivant utilise une variable pour ajouter le nom d'un joueur en tant que clé lorsqu'il rejoint l'expérience, puis définit sa valeur de points à 0.

Dans ServerScriptService, créez un nouveau script nommé PlayerPoints. Dans le script, obtenez le service Players et créez un dictionnaire vide nommé playerPoints.


local Players = game:GetService("Players")

local playerPoints = {

}

Codez une fonction locale pour définir les points des joueurs avec un paramètre pour une nouvelle variable de joueur. Connectez la fonction à l'événement Players.PlayerAdded.


local playerPoints = {

}

local function setPoints(newPlayer)

end

Players.PlayerAdded:Connect(setPoints)

Dans la fonction, ajoutez une variable pour obtenir le Name du joueur, une propriété de chaque objet Player, et une instruction print pour le test.


local function setPoints(newPlayer)
	local name = newPlayer.Name
	print("bonjour " .. name)
end

Insérez name dans le dictionnaire playerPoints en tant que clé, et définissez la valeur, les points du joueur, à 0.


local function setPoints(newPlayer)
	local name = newPlayer.Name
	print("bonjour " .. name)
	playerPoints[name] = 0
end

Comme name a été créé en tant que variable, il peut être accédé avec le nom de variable réel. Si name était un nom de clé, il devrait être accessible de la même manière que d'autres chaînes : playerPoints["name"].

Utilisez name pour imprimer le nom du joueur et playerPoints[name] pour imprimer la valeur de la clé correspondant à la variable.


local function setPoints(newPlayer)
	local name = newPlayer.Name
	print("bonjour " .. name)
	playerPoints[name] = 0
	print(name .. " a " .. playerPoints[name] .. " points.")
end

Exécutez le projet et observez la sortie.

Script terminé
local Players = game:GetService("Players")

local playerPoints = {

}

local function setPoints(newPlayer)
   local name = newPlayer.Name
   print("bonjour " .. name)
   playerPoints[name] = 0
   print(name .. " a " .. playerPoints[name] .. " points.")
end

Players.PlayerAdded:Connect(setPoints)

Défis optionnels

Ci-dessous quelques défis qui s'appliquent à l'utilisation de dictionnaires de différentes manières. Voyez si vous pouvez développer le code pour ceux-ci.

Créez une partie de piège qui inflige des dégâts au fil du temps à un joueur. Une fois qu'un joueur touche le piège, infligez-lui des dégâts, attendez, puis permettez-lui d'être endommagé à nouveau.
Créez une fonction qui vérifie lequel des deux joueurs a le plus de points en accédant à un dictionnaire.
Créez un chiffrement, un système d'échange d'une chaîne pour une autre pour créer un code "secret". Par exemple, la lettre "A" peut être échangée avec "G," ou le mot "pomme" peut être échangé avec "orange."

Dictionnaires et pairs()

pairs() est une fonction souvent utilisée pour itérer à travers des dictionnaires. Un exemple est présenté ci-dessous.


local myDictionary = {
	["Joueur Bleu"] = "Ana",
	["Joueur d'Or"] = "Binh",
	["Joueur Rouge"] = "Cate",
}

for key, value in pairs(myDictionary) do
	print(key .. " est " .. value)
end

pairs() peut être utilisé pour travailler avec la clé, la valeur, ou les deux d'un élément de dictionnaire. Dans la boucle for ci-dessous, la première variable est la clé. La seconde variable est la valeur. Le dictionnaire avec lequel vous souhaitez travailler est passé à pairs().


local inventory = {
	["Briques d'Or"] = 43,
	Carottes = 3,
	Torches = 2,
}

print("Vous avez :")

for itemName, itemValue in pairs(inventory) do
	print(itemValue, itemName)
end

Lorsqu'il est exécuté, le code imprimera ce qui suit :


Vous avez :
43 Briques d'Or
3 Carottes
2 Torches

Résumé

Les dictionnaires sont des tables qui utilisent des paires clé-valeur au lieu de valeurs indexées. Les dictionnaires et les tableaux commencent de la même manière en assignant des accolades à une variable. Gardez les entrées séparées par des virgules.

Toutes les clés d'un dictionnaire devraient utiliser le même type de données, mais les valeurs peuvent mélanger des types de données sans problème.

La manière d'accéder à un dictionnaire peut en révéler son but. Un dictionnaire de propriétés d'ennemi sera probablement accessible avec l'opérateur de point, tandis qu'une liste de noms utilisera probablement tableName[keyName].

Lorsque vous utilisez des crochets, soyez prudent ; les noms de clés créés dans le tableau doivent être traités comme des chaînes : tableName["keyName"]. Cependant, lors de la référence à des objets comme des pièces, les guillemets ne sont pas nécessaires : tableName[keyName].

De nombreux scripts doivent passer par des dictionnaires ou des tableaux, mais vous ne connaissez peut-être pas toujours le début et la fin de ces structures de données. Par exemple, un dictionnaire de joueurs peut être en train de changer, ou les joueurs peuvent avoir un inventaire de tableau de tailles variables.

Dans ces situations, vous pouvez utiliser pairs() et ipairs() dans une boucle for pour passer à travers chaque élément sans points de départ et d'arrivée connus. Vous pouvez également utiliser une itération générale via le mot-clé in pour boucler à travers les éléments sans avoir besoin de pairs() ou ipairs().