Tipos de Dados

Solidity é uma linguagem de tipagem estática. Isso significa que o tipo de uma variável é determinado no momento da compilação e não pode ser alterado durante a execução do programa.

Ao declarar uma variável em Solidity, é necessário especificar seu tipo de forma explícita. Uma vez definido, o tipo da variável permanece o mesmo durante toda a execução do código.

Por exemplo, uma variável chamada myNumber do tipo inteiro seria declarada assim:

uint256 myNumber;

Este enfoque de tipagem estática oferece diversos benefícios, como:

  • Detecção precoce de erros: Muitos problemas relacionados a tipos podem ser identificados pelo compilador antes da execução do programa.

  • Otimização de desempenho: O compilador pode aplicar verificações e otimizações específicas com base nos tipos de dados conhecidos, tornando o contrato mais eficiente.

Por outro lado, linguagens de tipagem dinâmica, como Python ou JavaScript, permitem que o tipo de uma variável seja alterado durante a execução do programa, o que pode levar a maior flexibilidade, mas também a erros inesperados.

Existen dos tipos de datos: tipos de valor y tipos de referencia.

Tipos de valor

Os tipos de valor armazenam diretamente o dado.

Abaixo estão os principais tipos dessa categoria:

Inteiros sem sinal (uint)

Representam números inteiros não negativos (unsigned). Exemplo:

uint256 varInt = 25; // se define como um uint com valor 25

  • Tamanhos disponíveis: De uint8 até uint256, em incrementos de 8 bits.

    • Exemplo: uint8, uint16, uint24 até uint256.

    • Limite de valores:

      • uint8: De 0 a 255 (2^8-1).

      • uint256: De 0 a (2^256-1).

  • Valor padrão: 0.

  • Valor máximo permitido:

🚨 Atenção: Se o valor ultrapassar os limites, a execução falha e a transação será revertida.

Se quisermos atribuir a um tipo de dado seu valor máximo possível em Solidity, podemos usar a seguinte instrução:

uint256 maxVal = type(uint256).max;

💡Dica: Se, ao escrever seu código, você declarar apenas uint sem especificar o número de bits, o Solidity assume que o tipo é uint256.

Inteiros com sinal (int)

Números inteiros con sinal. Exemplo:

int8 varInt = -4; // se define um int com valor -4

💡 Notas Importantes:

  • Essa abordagem também funciona para outros tamanhos de inteiros, como uint8, uint16, int8, etc. Basta substituir uint256 ou int256 pelo tipo desejado.

  • Da mesma forma, é possível obter o valor mínimo (para inteiros com sinal) utilizando type(int256).min, que retorna -(2^255).

Booleanos (bool)

  • Representam valores verdadeiros ou falsos.

Exemplo:

bool isAllowed = true; // se define isAllowed como verdadero

🥸 Valor padrão: false.

Endereços (address)

Representam endereços Ethereum (20 bytes). Usados para identificar contas externas (EOA) ou contratos inteligentes.

Exemplo:

address owner = 0x742d35Cc6634C0532925a3b844Bc454e4438f44e;

  • Estrutura:

    • 40 caracteres hexadecimais com prefixo 0x (indica formato hexadecimal).

  • Valor padrão:

    0x0000000000000000000000000000000000000000

    Conhecido como 0x0, address(0) ou address(0x0).

Enumerações (enum):

  • Fornecem uma maneira legível de associar valores significativos a variáveis.

  • Úteis para definir estados ou categorias específicas.

  • Melhoram a legibilidade, a manutenção e evitam erros ao substituir valores numéricos diretos por identificadores semânticos.

enum Estado = {Pendente, Aprovado, Reprovado}; // Define os estados possíveis
Estado public estadoAtual = Estado.Pendente; // Define o estado inicial como Pendente

Tipos de referência - Bytes e Strings

Os tipos de referência em Solidity são usados para armazenar dados complexos, referenciando uma localização de memória. Quando são atribuídos a outras variáveis ou passados como argumentos para funções, apenas a referência ao dado é passada, e não uma cópia do valor.

Isso implica que, ao modificar esses dados em uma função, você pode estar alterando diretamente o dado original. Os principais tipos de referência abordados aqui são os bytes e strings.

Bytes (bytes):

Os bytes são utilizados para armazenar sequências de bytes, sendo úteis para manipular dados binários arbitrários. Eles podem ser:

Podem ser dos tipos: estáticos o dinâmicos.

a) Bytes estáticos (bytesN)

  • Armazenam uma sequência de bytes de tamanho fixo, onde N varia entre 1 e 32.

  • Exemplo: bytes1, bytes2, ..., bytes32.

  • São mais eficientes em termos de custo de gás porque o tamanho é conhecido antecipadamente.

  • Usados para armazenar dados como hashes ou identificadores.

// Definindo uma variável de tipo bytes32
bytes32 public exampleBytes32;

b) Bytes dinâmicos (bytes)

  • Armazenam uma sequência de bytes de tamanho variável.

  • Funcionam como um array dinâmico de bytes1.

  • Mais flexíveis, mas têm um custo de gás maior devido à alocação dinâmica de memória.

contract Example {
// Definindo uma variável de tipo bytes (dinâmica)
bytes public dynamicBytes;

function setBytesValue() public {
    // Definido um valor na variável dynamicBytes
    // Pode ser de qualquer tamanho
    dynamicBytes = "Hello, Solidity!";
}
}

Valor padrão:

  • Formato inteiro: 0

  • Formato hexadecimal: 0x00.

String (string):

Os strings são projetados especificamente para armazenar cadeias de caracteres e são sempre dinâmicos, com tamanho variável. Eles representam sequências de caracteres Unicode codificadas em UTF-8.

Características:

  • Strings são ideais para armazenar texto legível, enquanto bytes é mais adequado para dados binários.

  • Se o texto tiver menos de 32 bytes, considere usar bytes32 para maior eficiência, já que a memória será alocada de forma estática.

  • Valor padrão: uma string vazia.


contract StringExample {
// Definindo uma variável de tipo string
    string public exampleString;

 // Função para atribuir um valor ao string
    function setString(string memory newString) public {
        exampleString = newString;
    }
}

🚨

Considerações importantes:

  1. 🚨 Codificação UTF-8: Cada caractere pode ocupar mais de um byte (por exemplo, letras com acentos). Usar caracteres fora do padrão pode causar erros.

  2. 🚨 Comparação de strings: Solidity não permite comparação direta de strings com ==. Em vez disso, compare os hashes das strings usando keccak256.

Exemplo:

solidityCopy codefunction compareStrings(string memory a, string memory b) public pure returns (bool) {
    return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
}

Armazenamento vs. Memória:

  • Strings podem ser armazenados na memória (dados temporários) ou no armazenamento (dados persistentes).

  • Usar memory é mais barato em termos de gás e comumente usado em parâmetros de funções. Exemplo:

function setStringMemory(string memory tempString) public {
    // tempString é armazenado temporariamente na memória
}

  • Valor padrão: uma string vazia.

🚨 Custo de gás:

  • Operações com strings podem ser caras para contratos inteligentes, especialmente ao manipular cadeias grandes.

PreviousHello WorldNextFunções

Last updated