Introdução aos Dicionários | Documentação

Dicionários são tabelas que associam nomes ou "*keys**" com um valor em vez de um índice.

Exemplo:

Sintaxe do dicionário Lua
local pet = {
   Name = "Bobbie",
   Type = "Dog",
}

Use dicionários quando precisar rotular valores, não apenas listá-los na ordem em que uma matriz faz a prática de usar dicionários neste tutorial manipulando valores associados a um jogador.

Sintaxe do Dicionário

Como matrizes, dicionários são atribuídos a uma variável com colchetes {} . Pares de valor chave são armazenados em linhas separadas seguidas de uma vírgula. Chaves e valores podem ser de qualquer digitarde dados, incluindo cadeias de caracteres, números e nomes de variáveis.


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

Para fazer referência a peças ou outros objetos instanciados como chaves, use parênteses.


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

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

Use tipos de dados consistentes para chaves de dicionário. Misturar tipos de dados, como usar cadeias de caracteres e variáveis para chaves, pode levar a resultados inconsistentes ao manipular o array e confundir outros codificadores.

Criando um Dicionário

Um uso cotidiano dos dicionários é organizar informações de jogadores ou personagens. Essas etapas exploram como as informações de um personagem inimigo teórico podem ser armazenadas e acessadas.

Em um novo script, crie um dicionário chamado enemy.
```
local enemy = {

}
```
A primeira chave no dicionário rastreará o nome do adversário / inimigocom uma variável chamada name.
```
local enemy = {
   Name
}
```

Atribua um nome inimigo à chave, seguido por uma vírgula.


local enemy = {
   name = "Spike",
}

Adicione um segundo par de chaves e valores para saber a quantidade de vida que o inimigo deve ter. Lembre-se, as chaves devem sempre usar o mesmo digitarde dados, mas os valores não precisam.
```
local enemy = {
   Name = "Spike",
   Health  = 1000,
}
```

Usando Valores do Dicionário

Existem duas maneiras de acessar os valores do dicionário: tableName["keyName"] -- Observe as citações tableName.keyName


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

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

O estilo a ser usado geralmente depende do propósito da tabela. Para tabelas que contenham uma coleção de valores, como uma lista de jogadores em um servidor, os codificadores geralmente usarão tableName["keyName"]. Para um dicionário usado para descrever um Objeto, os codificadores provavelmente usarão tableName.keyName.

Mudando o valor de um dicionário

Mudar o valor de uma chave é igual a qualquer outra variável; use o igual = operador.

Debaixo da mesa enemy, defina o nome do adversário / inimigopara outra coisa.


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

enemy.Name = "Rana"

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

Teste de reprodução e verifique a janela de saída.

Variáveis pré-existentes como chaves

Dicionários podem interagir com variáveis pré-existentes declaradas em outras partes de um script. O exemplo de codificação a seguir usa uma variável para adicionar o nome de um jogador como chave quando eles se juntam à experiência e, em seguida, define o valor de seus pontos para 0.

Em ServerScriptService , crie um novo script chamado PlayerPoints. No script, pegue o Players Service e crie um dicionário vazio chamado playerPoints.


Players = game:GetService("Players")

local playerPoints = {

}

Crie uma função local para definir pontos de jogador com um parâmetro para uma nova variável de jogador. Conecte a função ao evento Players.PlayerAdded.


local playerPoints = {

}

local function setPoints(newPlayer)

end

Players.PlayerAdded:Connect(setPoints)

Na função, adicione uma variável para obter o Name do jogador, uma propriedade em cada Player Objetoe uma declaração de impressão para testes.


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

Insira o nome no playerPoints dicionário como uma chave, e defina o valor, os pontos do jogador, para 0.


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

Uma vez que name foi criado como uma variável, ele pode ser acessado com o nome da variável real. Se name tivesse sido simplesmente um nome de chave, ele precisaria ser acessado da mesma forma que outras cadeias de caracteres, playerPoints["name"]

Use name para imprimir o nome do jogador e playerPoints[name] para imprimir o valor da chave que corresponde à variável.


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

Corra o projeto e olhe no editor de saída.

scriptterminado
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)

Desafios Opcionais

Abaixo estão alguns desafios que se aplicam ao uso de dicionários de maneiras diferentes. Veja se você pode construir o código para esses.

Crie uma parte de armadilha que cause dano ao longo do tempo a um jogador. Assim que um jogador tocar na armadilha, danifique-o, espere e depois permita que ele seja danificado novamente.
Crie uma função que verifica qual dos dois jogadores tem mais pontos acessando um dicionário.
Crie uma cifra, um sistema de trocar uma palavra por outra para criar um código "secreto," por exemplo, como a letra "A" pode ser trocada por "G," ou como a palavra maçã pode ser trocada pela palavra laranja.

Dicionários e pares ()

pairs() é uma função que é frequentemente usada para iterar através de dicionários . Um exemplo é visto abaixo.


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

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

pairs() pode ser usado para trabalhar com a chave, valor ou ambos de um elemento de dicionário. No loop for abaixo, a primeira variável é a chave. A segunda variável é o valor. O dicionário com o qual você deseja trabalhar é passado para pairs().


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

print("You have:")

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

Quando expresso, o código irá imprimir o seguindo:


You have:
43 Gold Bricks
3 Carrots
2 Torches

Resumo

Dicionários são tabelas que usam pares de valores-chave em vez de valores indexados. Dicionários e matrizes começam de forma semelhante atribuindo colchetes a uma variável. Mantenha as entradas separadas por vírgulas.

Todas as chaves dentro de um dicionário devem usar o mesmo digitarde dados, mas os valores podem misturar tipos de dados sem problema.

O estilo de como um dicionário é acessado pode transmitir o propósito de um dicionário. Um dicionário de propriedades inimigas provavelmente será acessado com o operador de ponto, enquanto uma lista de nomes provavelmente usará tableName[keyName].

Ao usar colchetes, tenha cuidado; nomes de chaves criados na tabela devem ser tratados como cadeias de caracteres: tableName["keyName"] . No entanto, ao fazer referência a objetos como peças, as citações não são necessárias: tableName[keyName] .

Muitos scripts precisam passar por dicionários ou matrizes, mas você nem sempre sabe o começo e o fim dessas estruturas de dados. Por exemplo, um dicionário de jogadores pode estar mudando ou os jogadores podem ter um inventário de matrizes de tamanhos variáveis.

Nestas situações, você pode usar pairs() e ipairs() em um loop for para passar por cada elemento sem pontos de início e fim conhecidos. Você também pode usar a iteração geral através da palavra-chave in para passar por elementos sem a necessidade de pairs() ou ipairs() .