---
title: "O que são arrays em Solidity?"
description: "Seu guia para começar com arrays em Solidity—funções, declaração e solução de problemas"
---

# O que são arrays em Solidity?

Arrays são estruturas de dados lineares que armazenam um número fixo de elementos do mesmo tipo de dado, armazenados em locais de memória contíguos e adjacentes. Cada elemento do array é especificado por sua localização, comumente conhecida como índice.

Arrays funcionam com um sistema baseado em índices, começando de 0 até \(n-1\), onde n representa o tamanho total do array. Em vez de criar várias variáveis individuais do mesmo tipo, os desenvolvedores só precisam declarar um array do tamanho desejado para armazenar elementos, que podem ser acessados usando o índice.

Em [Solidity](https://www.alchemy.com/overviews/solidity), a principal linguagem de programação web3 usada na Ethereum e em blockchains compatíveis com EVM, um array pode ter tamanho fixo ou dinâmico. Como linguagem de programação orientada a objetos, [Solidity suporta herança](https://www.alchemy.com/overviews/solidity-interface) entre smart contracts, onde múltiplos contratos podem ser herdados em um único contrato.

Se você quiser aprender mais a fundo sobre arrays em Solidity, inscreva-se no [curso gratuito de desenvolvedor Solidity](https://www.alchemy.com/university/courses/solidity) da Alchemy University.

## O que são arrays dinâmicos e fixos?

**O tamanho dos arrays dinâmicos não é predefinido quando são declarados, em contraste com os arrays fixos, que têm um tamanho predefinido.** À medida que elementos são adicionados sistematicamente, o tamanho do array dinâmico muda, e durante a execução, o tamanho real do array será determinado.

Em contrapartida, arrays fixos têm um tamanho predefinido, e a quantidade de elementos presentes no array não deve exceder o tamanho do array. Em raras circunstâncias em que o tamanho do array não é especificado, é criado um array de "tamanho suficiente". Um array de "tamanho suficiente" que seja o bastante para conter a inicialização.

### **Arrays de storage vs. arrays de memory**

**Em Solidity, há dois tipos de arrays que os desenvolvedores precisam considerar: arrays de storage e arrays de memory.**

#### **Arrays de storage**

**Arrays de storage** são tipicamente declarados como variáveis de estado e podem ter tamanho fixo ou dinâmico. É importante notar que arrays de storage com comprimento dinâmico podem ser redimensionados, o que significa que têm acesso tanto à função push\(\) quanto à pop\(\), que permitem adicionar e remover elementos do array, respectivamente.

#### **Arrays de memory**

**Arrays de memory** são declarados com memory como sua localização de dados. Assim como os arrays de storage, os arrays de memory também podem ter comprimento fixo ou dinâmico em tempo de compilação, porém não podem ser redimensionados depois que a memória é alocada. Isso significa que as [funções Solidity](https://www.alchemy.com/overviews/solidity-functions) pop\(\) e pull\(\) não podem ser usadas.

Arrays de memory de tamanho fixo são alocados automaticamente quando você os declara - como na instrução `uint256[5] memory numbers`. No entanto, para alocar arrays de memory dinâmicos, é necessário usar o operador new. Por exemplo, você poderia usar `uint256[] memory numbers = new uint256[](5)``;`

**Nota:** sempre inicialize o array antes de usá-lo, para que você possa obter um endereço válido para uso.

## Arrays em Solidity vs. mapping

[Mapping em Solidity](https://www.alchemy.com/overviews/solidity-mapping) é semelhante a um array no sentido de que é um tipo de referência destinado a armazenar um grupo de dados. A sintaxe e a estrutura de mappings é bastante diferente, o que permite que sirvam a um propósito único e importante. Mapping é uma tabela de chaves e valores, cada um com seu próprio tipo predefinido. Mapping pode ser entendido como a criação de uma tabela vazia que existe dentro de um [smart contract Solidity](https://www.alchemy.com/overviews/solidity-smart-contract), aguardando ser preenchida com dados.

Diferente de um array, um mapping não tem um comprimento recuperável, nem a chave ou o valor precisam ser "definidos" desde a etapa de inicialização. Além disso, não é possível fazer um loop por um mapping como é possível fazer com arrays em Solidity.

No entanto, recuperar um dado de um mapping é muito mais eficiente do que buscar o mesmo dado em um array. Para buscar dados em um array, é necessário iterar por todo o array até encontrar o elemento específico que você procura, mas um mapping obtém esse dado imediatamente.

Os benefícios de desempenho ao recuperar dados de mappings podem ser bastante importantes para [economizar gas em smart contracts Ethereum](https://www.alchemy.com/overviews/solidity-gas-optimization), visto que transações que editam dados na blockchain exigem taxas de gas. Portanto, armazenar ou recuperar dados de um smart contract da forma mais eficiente possível pode economizar ETH para os desenvolvedores ao longo do tempo.

Em resumo, se você precisa iterar por um grupo de dados, usando, digamos, um for loop, então use um array. Se não houver necessidade de iterar por um conjunto de dados, e em vez disso você puder recuperar valores com base em uma chave conhecida, considere usar mapping.

## Declarando e inicializando um array

Declarar um array em Solidity é relativamente simples. Os tipos de dados dos elementos e o número de elementos devem ser especificados, o tamanho do array deve ser um número inteiro positivo, e o tipo de dado deve ser válido em Solidity.

Por exemplo, a instrução básica abaixo inicializaria o array e, uma vez inseridos os dados, eles apareceriam no [console.log](https://www.alchemy.com/overviews/solidity-console-log):

Cada item do array é chamado de **elemento**, e cada elemento pode ser acessado por meio de seu índice numérico usando a função "n - 1", onde n representa o número do elemento.

Em geral, a numeração associada aos elementos começa em 0. Isso significa que o 10º elemento seria acessado no índice 9, o 11º elemento no índice 10, etc.

A restrição relacionada ao mesmo tipo de dado é importante de lembrar, pois os arrays são armazenados em células de memória consecutivas, o que implica que cada célula deve ser do mesmo tipo e, portanto, do mesmo tamanho.

## **Structs**

[Structs](https://www.alchemy.com/overviews/solidity-struct) permitem que os programadores definam seus próprios tipos de dados. Uma vez que um struct tenha sido definido, ele pode ser usado como uma variável de estado ou em uma variedade de outras funções, usando argumentos posicionais ou palavras-chave. A segunda abordagem evita a necessidade de lembrar a ordem dos membros incluídos no struct.

**Aqui está um exemplo de um novo struct:**

## **Mappings**

Mappings podem ser entendidos como armazenamentos de chave e valor, onde toda chave possível existe e qualquer valor pode ser definido ou recuperado em uma única operação com a chave. O **KeyType** pode ser qualquer tipo de valor embutido (ou seja, bytes, string, ou qualquer tipo de contract/enum). O **ValueType** pode ser qualquer tipo, incluindo mappings, arrays e structs.

Mappings podem ser declarados da seguinte forma:

Nota: a única localização de dados permitida para variáveis de mapping é storage.

## **Members**

Encontrar um membro específico de um array significa percorrer o array até que o membro seja encontrado. Os desenvolvedores devem estar cientes de duas funções importantes: `length` e `push`.

- ‍**Length** - retorna o tamanho do array e também pode ser usado para alterar o tamanho de um array dinâmico.
- ‍**Push** - permite que os desenvolvedores adicionem um elemento diretamente ao final de um array dinâmico de storage e, como resultado, retorna o novo comprimento do array.

## Solucionando problemas com arrays em Solidity

Ocasionalmente, os desenvolvedores podem encontrar erros de compilação, que podem surgir do mal-entendido das regras para declarar, criar e inicializar arrays. Aqui estão algumas formas gerais de solucionar erros comuns com arrays em Solidity:

### **1. Array.length**

A função `array.length` permite que os desenvolvedores verifiquem o número de elementos presentes no array. O tamanho do array de memory é fixo quando ele é declarado, enquanto no caso do array dinâmico, que é definido em tempo de execução, o length é necessário para a manipulação.

### **2. Abi.encode e abi.encodePacked**

Quando uma função é chamada em um contrato externo, a EVM computa um buffer de bytes contendo a assinatura da função e os argumentos, e há duas formas de serializar argumentos: [`abi.encode` e `abi.encodePacked`](https://www.alchemy.com/overviews/solidity-abi).

**Abi.encode** codifica seus parâmetros usando as especificações do ABI. Efetivamente, o ABI foi projetado para fazer chamadas a contratos, onde os parâmetros são preenchidos (padded) até 32 bytes. Se chamadas estão sendo feitas a um contrato, é provável que essa função esteja sendo usada.

Comparativamente, **abi.encodePacked** codifica seus parâmetros usando o espaço mínimo exigido pelo tipo. Codificar um uint8 usará 1 byte, e é usado quando você quer economizar espaço e não pretende chamar um contrato.

### **3. Byte\[\] ou bytes**

**‍**Ambos os tipos de array podem conter uma quantidade arbitrária de dados brutos em bytes. A diferença entre `byte\[\] ` e bytes é que `bytes\[\]` segue as regras do tipo array, e elementos em arrays de memory em Solidity sempre ocupam múltiplos de 32 bytes. Isso significa que, se um elemento tiver menos do que um múltiplo de 32 bytes, ele será preenchido (padded) até atingir o tamanho necessário. Por exemplo, 31 bytes poderiam ser desperdiçados para cada elemento no caso do array de byte, o que não ocorre ao usar o array de bytes ou string.

### **4. String**

**‍**Esse array dinâmico em particular é um tipo de dado UTF-8 e, diferente de outras linguagens de programação, Solidity não fornece funções para obter o comprimento da string ou realizar concatenação ou comparação de duas strings. Uma string pode ser rapidamente convertida em um array de bytes usando bytes\[\].

### **5. Array null em Solidity**

**‍**Embora o conceito inerente de _undefined_, _null_, _nil_, _none_, etc. exista em outras linguagens de programação como Python e JavaScript, ele não existe em Solidity. Em vez disso, os desenvolvedores podem chamá-lo de conceito de zero ou valor padrão, pois cada valor recebe um slot na memória assim que é criado e, portanto, deve conter algo.

## Como aprender mais sobre arrays em Solidity

Para [aprender mais sobre a linguagem de programação Solidity](https://www.alchemy.com/overviews/learn-solidity) e se familiarizar com arrays, entre outros tópicos fundamentais, acesse o [Ethereum bootcamp](https://www.alchemy.com/university/courses/ethereum) da Alchemy University. O Ethereum bootcamp é um curso de programação gratuito, de 7 semanas, completo com vídeos guiados e projetos práticos.

Se os desenvolvedores forem novos no desenvolvimento em geral, o [curso de JavaScript para Ethereum de 3 semanas](https://www.alchemy.com/university/courses/js) da Alchemy é um ótimo pré-requisito antes de começar um Ethereum bootcamp.