Introduction aux dictionnaires

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

Exemple :

local pet = {
   Name = "Bobbie",
   Type = "Chien",
}

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

Syntaxe du dictionnaire

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 n'importe quel 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])

Créer un dictionnaire

Une utilisation quotidienne des dictionnaires est l'organisation des 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.

1. Dans un nouveau script, créez un dictionnaire nommé enemy.

   local enemy = {
   
   }

2. La première clé du dictionnaire suivra le nom de l'ennemi avec une variable appelée Name.

   local enemy = {
   	Name
   }

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

   local enemy = {
   	Name = "Spike",
   }

4. Ajoutez une deuxième paire clé-valeur pour combien de points de vie l'ennemi devrait avoir. N'oubliez pas, les clés doivent toujours utiliser le même type de données, mais les valeurs n'ont pas à l'être.

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

Utiliser les valeurs du dictionnaire

Il existe deux façons d'accéder aux valeurs d'un 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 de la table. Pour les tables 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 pour n'importe quelle autre variable ; utilisez l'opérateur égal =.

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

   local enemy = {
   	Name = "Spike",
   	Health = 1000,
   }
   
   enemy.Name = "Rana"
   
   print("Le nom de l'ennemi est " .. enemy.Name)

2. 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 le jeu, puis définit sa valeur de points à 0.

1. 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 = {
   
   }

2. Codez une fonction locale pour définir les points du joueur 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)

3. 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

4. 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

   Puisque name a été créé en tant que variable, il peut être accessible 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"].

5. 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

6. Exécutez le projet et observez la sortie.

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

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

• Créez une partie 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 à nouveau blessé.
• Créez une fonction qui vérifie lequel de deux joueurs a le plus de points en accédant à un dictionnaire.
• Créez un chiffre, un système d'échange d'une chaîne contre 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 les dictionnaires. Un exemple est vu ci-dessous.

local myDictionary = {
	["Joueur Bleu"] = "Ana",
	["Joueur Doré"] = "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 deuxième variable est la valeur. Le dictionnaire avec lequel vous souhaitez travailler est passé à pairs().

local inventory = {
	["Briques Dorées"] = 43,
	Carottes = 3,
	Torches = 2,
}

print("Vous avez :")

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

Lors de l'exécution, le code imprimera ce qui suit :

Vous avez :
43 Briques Dorées
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 manière similaire en assignant des accolades à une variable. Gardez les entrées séparées par des virgules.

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

La manière dont un dictionnaire est accédé peut transmettre son objectif. Un dictionnaire de propriétés d'ennemi sera probablement accessible avec l'opérateur 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 la table doivent être traités comme des chaînes : tableName["keyName"]. Cependant, lors de la référence à des objets comme des parties, les guillemets ne sont pas nécessaires : tableName[keyName].

De nombreux scripts doivent parcourir des dictionnaires ou des tableaux, mais vous ne savez 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 variées.

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