Introduction aux dictionnaires | Documentation

Les dictionnaires sont des tables qui associent des noms ou «*cles**» à une valeur au lieu d'un index.

Exemple :

Syntaxe de la dicton de Lua
local pet = {
   Name = "Bobbie",
   Type = "Dog",
}

Utilisez des dictionnaires lorsque vous devez étiqueter des valeurs, non seulement les lister en ordre comme un tableau le fait - pratiquez à utiliser des dictionnaires dans ce tutoriel en manipulant les valeurs associées à un joueur.

Syntaxe de dictionnaire

Comme les tableaux, les dictionnaires sont attribués à une variable avec des crochets {} . Les valeurs clés sont stockées sur des lignes séparées suivies d'un point virgule. Les clés et les valeurs peuvent être n'importe quel taperde données, y compris les chaînes, les numéros et les noms de variables.


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

Pour référencer des parties ou d'autres objets instancés en tant que clés, utilisez des parenthèses.


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. Mélanger des types de données, tels que l'utilisation de deux 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 les autres coders.

Créer un dictionnaire

L'utilisation quotidienne d'un dictionnaire organise l'information du joueur ou du personnage. Ces étapes explorent comment l'information d'un personnage ennemi théorique peut être stockée et accessible.

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
}
```

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


local enemy = {
	Name = "Spike",
}

Ajoutez une deuxième paire de valeurs clé pour le nombre 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 ne le doivent pas.
```
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 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 varie généralement du but de la table. Pour les tables contenant une collection de valeurs comme une liste de joueurs dans un serveur, les coders utilisent généralement tableName ["keyName"). Pour un dictionnaire utilisé pour décrire un objet, les coders sont plus susceptibles d'utiliser tableName.keyName.

Modifier une valeur de dictionnaire

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

Sous la table enemy, définissez le nom de l'ennemi comme n'importe quoi d'autre.


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.

Variable existant comme clé

Les dictionnaires peuvent interagir avec les 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 comme clé lorsqu'il rejoint l'expérience et définit ensuite sa valeur de points sur 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 = {

}

Code 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 Player et une déclaration d'impression pour tester.


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

Insérez le nom dans le playerPoints dictionnaire 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éé comme une variable, il peut être accédé avec le nom de variable actuel. Si name avait été simplement un nom de clé, il devrait être accédé avec le même nom que d'autres chaînes, playerPoints ["name"]

Utilisez name pour imprimer le nom du joueur et des points de joueurPoints[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 regardez dans l'éditeur de 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 facultatifs

Ceux-ci sont quelques défis qui s'appliquent à l'utilisation de dictionnaires de différentes manières. Voyez si vous pouvez construire le code pour eux.

Créez une partie de piège qui fait des dégâts au fil du temps à un joueur. Une fois qu'un joueur a touché le piège, détruis-le, attendez, puis autorisez-le à être endommagé à nouveau.
Créez une fonction qui vérifie qu'un des deux joueurs a le plus de points en accédant à un dictionnaire.
Crée un cipher, un système de substitution d'un mot pour un autre pour créer un code « secret », par exemple, comment la lettre « A » peut être échangée avec « G », ou comment le mot pomme peut être échangé pour le mot orange.

Dictionnaires et couples()

pairs() est une fonction qui est 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 le for loop ci-dessous, la première variable est la clé. La deuxième variable est la valeur. Le dictionnaire que vous voulez travailler avec est passé dans le pairs() .


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

print("You have:")

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

Lors de l'exécution, le code imprimera les éléments suivre:


You have:
43 Gold Bricks
3 Carrots
2 Torches

Résumé

Les dictionnaires sont des tables qui utilisent des paires de valeurs clés au lieu des valeurs indexées. Les dictionnaires et les tableaux commencent également par attribuer des majuscules aux valeurs. Gardez les entrées séparées par des virgules.

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

Le style de la façon dont un dictionnaire est accédé peut transmettre le but d'un dictionnaire. Un dictionnaire de 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 des brackets, attentionnez-vous ; les noms des clés créés dans la table doivent être traités comme des chaînes : tableName["keyName"] . Cependant, lorsque vous faites référence à des objets comme des parties, les quotations ne sont pas nécessaires : tableName[keyName] .

De nombreux scripts doivent passer par 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 être en cours de mise à jour, ou les joueurs peuvent avoir un inventaire de tableau de taille variante.

Dans ces situations, vous pouvez utiliser pairs() et ipairs() dans un for boucle pour traverser chaque élément sans points de départ et de fin connus. Vous pouvez également utiliser l'itération générale via le mot-clé 1> in1> pour traverser les éléments sans le besoin d'4> pairs()</