15.11.2024

Lição: 034: Mapeamentos em Solidity

Os mapeamentos são uma das estruturas de dados mais importantes em Solidity, permitindo que você crie pares de chave-valor para armazenar e recuperar dados de forma eficiente. Nesta aula, vamos explorar como usar mapeamentos em Solidity, juntamente com exemplos práticos.

O que é um Mapeamento?

Um mapeamento é semelhante a uma tabela hash ou dicionário em outras linguagens de programação. Ele permite associar uma chave única a um valor. A sintaxe para declarar um mapeamento é a seguinte:

mapping(tipoChave => tipoValor) nome;

Onde tipoChave é o tipo de dado da chave e tipoValor é o tipo de dado do valor.

É importante notar que os mapeamentos não têm um comprimento pré-definido e não armazenam as chaves em si; eles apenas mantêm o controle dos valores associados a essas chaves.

Sintaxe Básica

Aqui está um exemplo de como declarar um mapeamento simples:

mapping(address => uint) public saldos;

Neste exemplo:

• O mapeamento chamado saldos usa um address como chave e um uint como valor.
• Esse mapeamento pode ser usado para armazenar os saldos de diferentes endereços de carteira.

Definindo Valores em um Mapeamento

Para definir valores em um mapeamento, você pode simplesmente usar o operador de atribuição =. Veja como adicionar ou atualizar um saldo:

function depositar() public payable {
    saldos[msg.sender] += msg.value;
}

Nesta função, quando um usuário chama depositar, o valor do Ether enviado é adicionado ao seu saldo no mapeamento saldos.

Recuperando Valores de um Mapeamento

Para acessar valores armazenados em um mapeamento, você pode referenciar a chave diretamente:

function obterSaldo(address usuario) public view returns (uint) {
    return saldos[usuario];
}

Esta função retorna o saldo do usuário especificado.

Exemplo: Contrato de Token Usando Mapeamentos

Vamos olhar um exemplo completo de um contrato de token simples que usa mapeamentos para acompanhar saldos e permissões:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract TokenSimples {
    string public nome = "TokenSimples";
    string public simbolo = "STK";
    uint8 public decimais = 18;
    uint256 public fornecimentoTotal = 1000000 * (10 ** uint256(decimais));

    mapping(address => uint256) public saldos;
    mapping(address => mapping(address => uint256)) public permissao;

    constructor() {
        saldos[msg.sender] = fornecimentoTotal;
    }

    function transferir(address para, uint256 quantia) public returns (bool) {
        require(saldos[msg.sender] >= quantia, "Saldo insuficiente.");
        saldos[msg.sender] -= quantia;
        saldos[para] += quantia;
        return true;
    }

    function aprovar(address gastador, uint256 quantia) public returns (bool) {
        permissao[msg.sender][gastador] = quantia;
        return true;
    }

    function transferirDe(address de, address para, uint256 quantia) public returns (bool) {
        require(saldos[de] >= quantia, "Saldo insuficiente.");
        require(permissao[de][msg.sender] >= quantia, "Permissão excedida.");

        saldos[de] -= quantia;
        saldos[para] += quantia;
        permissao[de][msg.sender] -= quantia;
        return true;
    }
}

Explicação do Contrato de Token

1. Variáveis de Estado:

   • nome, simbolo, decimais e fornecimentoTotal definem as características do token.
   • O mapeamento saldos é usado para acompanhar o saldo de tokens de cada usuário.
   • O mapeamento permissao rastreia quanto um endereço está autorizado a gastar de outro endereço.

2. Construtor:

   • O construtor atribui o fornecimento total de tokens à conta que implanta o contrato.

3. Funções:

   • transferir: Permite transferir tokens entre endereços.
   • aprovar: Permite que outro endereço tenha permissão para gastar tokens em nome do chamador.
   • transferirDe: Executa uma transferência de um endereço para outro somente se a permissão tiver sido aprovada.

Conclusão

Os mapeamentos em Solidity oferecem uma maneira poderosa de gerenciar pares de chave-valor, permitindo que os desenvolvedores implementem funcionalidades como saldos de usuários e controle de acesso de forma eficiente. Compreender como usar mapeamentos é crucial para desenvolver contratos inteligentes robustos.

Nesta aula, cobrimos a sintaxe básica dos mapeamentos, como definir e recuperar valores, além de um exemplo prático no contexto de um contrato de token simples. À medida que você continuar desenvolvendo em Solidity, aproveitar as capacidades dos mapeamentos aprimorará a funcionalidade e a eficiência de seus contratos.

Video

Navigation