Entendendo as Variáveis

Nesse artigo iremos falar um pouco sobre os tipos de variáveis, como acessá-las e onde definí-las.

Tipos de acesso

No Solidity, temos 3 tipos de declaração de variáveis:

• local
  • declarada dentro de uma função
  • não é armazenada na blockchain
• estado
  • declarada fora de uma função
  • são armazenadas na blockchain
• global
  • fornece informações sobre a blockchain

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

contract Variaveis {
    // As variáveis de estado são armazenadas na blockchain
    string public texto = "Olá Solidity";
    uint public numero = 123;

    function atualizaVariaveis() public {
        // As variáveis locais não são salvas na blockchain 
        // e só podem ser acessadas dentro da função que a declarou
        uint i = 456;

        // Essas são algumas das variáveis globais tendo seu valor 
        // atribuido à uma variável local
        uint timestamp = block.timestamp; // Timestamp do bloco atual
        address sender = msg.sender; // Endereço de quem chamou o contrato
    }
}

Variáveis Constantes

As Constantes são variáveis que não podem ser modificadas. Seu valor é definido na sua declaração. Variáveis constantes podem ajudar a economizar nos custos de gas.

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

contract Constantes {
    // Variáveis constantes geralmente são escritas com letras maiúsculas
    address public constant MEU_ENDERECO = 0x80F9486d904508BEb9b159b83c3605D974Baca1a;
    uint public constant MEU_UINT = 123;
}

Variáveis Imutáveis

As variáveis imutáveis são como as constantes, porémo s valores de variáveis imutáveis podem ser definidos dentro do construtor, mas não podem ser modificados posteriormente.

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

contract Imutavel {
    // Variáveis imutáveis geralmente são escritas com letras maiúsculas
    address public immutable MEU_ENDERECO;
    uint public immutable MEU_UINT;

    constructor(uint _myUint) {
        MEU_ENDERECO = msg.sender;
        MEU_UINT = _myUint;
    }
}

Tipos de dados primitivos

Alguns tipos de dados primitivos disponíveis no Solidity.

boolean - utilizado para definir se um valor é verdadeiro ou falso, true or false

uint - utilizado para definir um valor numérico inteiro somente positivo

int- utilizado para definir um valor numérico positivo ou negativo

address - utilizado para armazenar o endereço de uma carteira

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

contract DadosPrimitivos {
    bool public verdade = true;

    /*
    uint representa um valor inteiro sem sinal, ou seja, inteiros positivos >= 0
    pode ser definido para diferentes tamanhos
        uint8   varia de 0 até 2 ** 8 - 1
        uint16  varia de 0 até 2 ** 16 - 1
        ...
        uint256 varia de 0 até 2 ** 256 - 1
    */
    uint8 public u8 = 1;
    uint public u256 = 456;
    uint public u = 123; // uint é o mesmo que uint256

    /*
    Para números negativos, deve se usar o tipo int
    Assim como no uint, podemos definir diferentes 
    faixas de int que são int8 até int256
    
    int256 varia de -2 ** 255 até 2 ** 255 - 1
    int128 varia de -2 ** 127 até 2 ** 127 - 1
    */
    int8 public i8 = -1;
    int public i256 = 456;
    int public i = -123; // int é o mesmo que int256

    // mínimo e máximo de int
    int public minInt = type(int).min;
    int public maxInt = type(int).max;

    // Nosso endereço, caso sinta-se a vontade para nos enviar alguns bnb's :)
    address public addr = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c;

    /*
    Em Solidity, o tipo de dados byte representa uma sequência de bytes. 
    Solidity apresenta dois tipos de bytes :

     - matrizes de bytes de tamanho fixo
     - matrizes de bytes de tamanho dinâmico.
     
     O termo bytes no Solidity representa uma matriz dinâmica de bytes.
     É uma abreviação para byte[] .
    */
    bytes1 a = 0xb5; //  [10110101]
    bytes1 b = 0x56; //  [01010110]
    
    // Valores padrão
    // Variáveis não atribuídas têm um valor padrão
    bool public defaultBoo; // false
    uint public defaultUint; // 0
    int public defaultInt; // 0
    address public defaultAddr; // 0x0000000000000000000000000000000000000000
}

Lendo e escrevendo em uma variável de estado

Para escrever ou atualizar uma variável de estado, você precisa enviar uma transação para a blockchain. Por outro lado, você pode ler variáveis de estado sem precisar executar nenhuma transação, logo, não irá pagar nenhuma taxa de gas.

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

contract SimpleStorage {
    // Variável de estado para armazenar um valor
    uint public num;

    // Você precisa enviar uma transação para poder atualizar o valor da variável num
    function set(uint _num) public {
        num = _num;
    }

    // Você pode ler o valor da variável num sem precisar enviar nenhuma transação
    function get() public view returns (uint) {
        return num;
    }
}

Testar no Remix