Introduction aux dictionnaires

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

Exemple :

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

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

Syntaxe du dictionnaire

Comme les tableaux, les dictionnaires sont attribués à une variable avec des crochets courbes {} . 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 n'importe quel taperde données, y compris les chaînes, les nombres et les noms de variables.


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

Pour référencer des parties ou d'autres objets instanciés comme 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 de 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 de l'arrêt et confondre d'autres codificateurs.

Créer un dictionnaire

Une utilisation quotidienne des dictionnaires consiste à organiser les informations sur le joueur ou le personnage.Ces étapes explorent comment les informations d'un personnage ennemi théorique peuvent être stockées et consultées.

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

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

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


local enemy = {
	Name = "Spike",
}

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

Utiliser les valeurs du dictionnaire

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

tableName["keyName"] (notez surtout les citations)
tableName.keyName


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

print("The villain " .. enemy["Name"] .. " approaches!")
print("The villain " .. enemy.Name .. " approaches!")

Le style à utiliser dépend généralement du but de la table.Pour les tables qui contiennent une collection de valeurs comme une liste de joueurs dans un serveur, les développeurs utilisent généralement tableName["keyName"] .Pour un dictionnaire utilisé pour décrire un objet, les développeurs sont plus susceptibles d'utiliser tableName.keyName .

Modifier une valeur de dictionnaire

Changer la valeur d'une clé est la même chose que toute autre variable ; utilisez l'opérateur égal =.

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


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

enemy.Name = "Rana"

print("The enemy's name is " .. enemy.Name)

Testez 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 codage suivant utilise une variable pour ajouter le nom d'un joueur en tant que clé lorsqu'il rejoint l'expérience, puis définit la valeur de ses points à 0.

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


local Players = game:GetService("Players")

local playerPoints = {

}

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)

Dans la fonction, ajoutez une variable pour obtenir le Name du joueur, une propriété dans chaque objet Joueur , et une déclaration d'impression pour le test.


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

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


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

Puisque name a été créé en tant que variable, il peut être accédé avec le nom de variable réel.Si name étaient un nom de clé, il devrait être accédé 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("hello " .. name)
	playerPoints[name] = 0
	print(name .. " has " .. playerPoints[name] .. " points.")
end

Exécutez le projet et observez la sortie.

Script script
local Players = game:GetService("Players")

local playerPoints = {

}

local function setPoints(newPlayer)
   local name = newPlayer.Name
   print("hello " .. name)
   playerPoints[name] = 0
   print(name .. " has " .. 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. Voir si vous pouvez construire le code pour ces derniers.

Créer une partie de piège qui inflige des dommages au fil du temps à un joueur. Une fois qu'un joueur a touché la piège, infligez-lui des dommages, attendez, puis permettez-lui d'être à nouveau endommagé.
Créer une fonction qui vérifie laquelle des deux joueurs a le plus de points en accédant à un dictionnaire.
Créer un chiffre, 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 paires()

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


local myDictionary = {
	["Blue Player"] = "Ana",
	["Gold Player"] = "Binh",
	["Red Player"] = "Cate",
}

for key, value in pairs(myDictionary) do
	print(key .. " is " .. 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 voulez travailler est passé à pairs() .


local inventory = {
	["Gold Bricks"] = 43,
	Carrots = 3,
	Torches = 2,
}

print("You have:")

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

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


You have:
43 Gold Bricks
3 Carrots
2 Torches

Sommaire

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 attribuant des crochets courbes à une variable.Gardez les entrées séparées par des virgules.

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

La façon dont un dictionnaire est accédé peut transmettre son but.Un dictionnaire des propriétés ennemies sera probablement accessible avec l'opérateur point, tandis qu'une liste de noms utilisera probablement tableName[keyName].

Lors de l'utilisation de parenthèses, faites attention ; les noms de clé créés dans la table doivent être traités comme des chaînes : tableName["keyName"] .Cependant, lors de la référence à des objets tels que des parties, les citations ne sont pas nécessaires : tableName[keyName] .

De nombreux scripts doivent traverser des dictionnaires ou des tableaux, mais vous ne savez peut-être pas toujours le début et la fin de ces structures de données.Par exemple, un dictionnaire de joueurs peut changer, ou les joueurs peuvent avoir un inventaire d'arrays de tailles différentes.

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'extrémité connus.Vous pouvez également utiliser une itération générale via la balise in pour parcourir les éléments sans besoin de pairs() ou de ipairs().

Sur cette page