Guia rápido para matrizes de solidez

Neste artigo, exploraremos os arrays do Solidity em profundidade, observando seus tipos, sintaxe e funcionalidade, bem como alguns dos melhores exemplos para trabalhar com arrays no Solidity.

Arrays são estruturas de dados que armazenam coleções sequenciais de elementos semelhantes de tamanho fixo.

As matrizes contêm uma coleção de dados, mas você pode considerá-las como coleções de variáveis semelhantes.

É preferível declarar uma variável de array como números em vez de variáveis individuais como número0, número1, … e número99. Um elemento específico em uma matriz é acessado por um índice.

Os arrays Solidity podem ter um tamanho fixo em tempo de compilação ou um tamanho dinâmico. Da mesma forma, as matrizes de armazenamento também podem ter diferentes tipos de elementos. Tipos de elemento de matriz de memória não podem ser mapeamentos e, se forem usados como parâmetros de função, devem ser tipos ABI.

Uma matriz é composta de locais de memória interconectados. É o endereço mais baixo que aponta para o primeiro elemento, enquanto o endereço mais alto se refere ao último elemento.

Índice-

Guia rápido para matrizes de solidez:

Tipos de matriz de solidez

O Solidity suporta arrays estáticos e dinâmicos .

tipos	Visão geral
Matrizes Estáticas	Arrays estáticos têm um comprimento fixo que é definido em tempo de compilação. Depois que o comprimento de um array estático é definido, ele não pode ser alterado.
Matrizes Dinâmicas	As matrizes dinâmicas têm um comprimento variável que pode ser alterado em tempo de execução.

Declarar Matriz

Para declarar um array de tamanho fixo no Solidity, o programador especifica o tipo dos elementos e o número de elementos requeridos por um array da seguinte forma:

Arrays desse tipo são chamados de arrays unidimensionais.

Para declarar uma matriz, certifique-se de que o tamanho da matriz deve ser definido como uma constante inteira positiva maior que zero e seu tipo deve ser qualquer tipo de dados Solidity.

Aqui está um exemplo de como declarar um array de 10 elementos conhecido como balance do tipo uint :

uint numbers[10];

Os programadores declaram arrays dinâmicos no Solidity apenas especificando os tipos de elementos da seguinte forma:

type[] arrayName;

Inicializar Arrays

É possível inicializar os elementos do array Solidity um de cada vez ou com uma única instrução conforme mostrado abaixo:

uint number[10] = [1, 2, 3,4,5,6,7,8,9,10];

Não é possível declarar um número maior de elementos para o array entre colchetes [ ] do que o número de valores entre colchetes [ ] .

Quando o tamanho do array é omitido, um array grande o suficiente para manter a inicialização é criado.

O exemplo a seguir mostra como atribuir um elemento à matriz.

uint number[4] = 5

Aqui acessamos o 5º elemento da matriz fornecida.

Criando matrizes de memória dinâmica

A palavra-chave new cria arrays de memória dinâmicos.

uint mrx = 4;
uint numbers[] = new uint[](mrx);

Acessando elementos da matriz

Um membro de uma matriz é acessado indexando seu nome. Nesse caso, o índice de cada elemento será colocado entre colchetes após o nome do array. Por exemplo:

uint value = number[3];

Na instrução acima, o valor do quarto elemento será atribuído à variável chamada value.

O exemplo abaixo incorpora todos os três conceitos mencionados acima, declaração, atribuição e acesso a matrizes.

Membros

Métodos	Visão geral
Comprimento	O comprimento de uma matriz é calculado por este método. O comprimento de um array dinâmico pode ser alterado definindo-o.
Empurrar	Adiciona um elemento a uma matriz dinâmica. Ele fornece o comprimento modificado da matriz.

O exemplo a seguir mostra o funcionamento dos arrays do Solidity:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint loop_element;
uint length_array;
string[] software_houses_in_USA=["Microsoft","Capital One","Cisco Systems","Northrop","Verizon"];
function display_Array() public returns (string[] memory){
for(loop_element=0;loop_element<software_houses_in_USA.length;loop_element++){
software_houses_in_USA[loop_element];
length_array=software_houses_in_USA.length;
}
return software_houses_in_USA;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Você verá a saída abaixo na execução dos exemplos acima:

Exemplos de matrizes de solidez

Você pode entender melhor sobre o array estático seguindo o exemplo abaixo:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint mrx;
uint[] Even_Numbers;
function get_Array_Elements() public returns(uint[] memory){
for(mrx=0;mrx<=10;mrx++){
uint value=mrx*2;
Even_Numbers.push(value);
}
return Even_Numbers;
}
uint[] prime_Numbers=[2,3,5,7,11,13,17];
function Static_Array() public returns(uint){
uint value=prime_Numbers[2];
return value;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

A matriz dinâmica pode ser inicializada da seguinte maneira:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
  function table_of_5() public pure returns (uint[] memory){
uint[] memory myArray=new uint[](12);
myArray[0]=5;
myArray[1]=10;
myArray[2]=15;
myArray[3]=20;
myArray[4]=25;
myArray[5]=30;
myArray[6]=35;
myArray[7]=40;
myArray[8]=45;
myArray[9]=50;
myArray[10]=55;
myArray[11]=60;
return myArray;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Conclusão

Matrizes de solidez são estruturas de dados importantes que permitem armazenar e manipular coleções de valores.

O Solidity suporta vários tipos de arrays, incluindo arrays dinâmicos | arrays de tamanho fixo e arrays multidimensionais.

Observação : ao trabalhar com arrays Solidity, é importante considerar os custos de gás das operações de array, especialmente para arrays grandes.

Para minimizar os custos de gás, você pode usar arrays de tamanho fixo em vez de arrays dinâmicos se o tamanho do array for conhecido antecipadamente.

Além disso, você pode usar a palavra-chave memory para criar arrays temporários que são armazenados apenas na memória durante a execução da função.

Nós valorizamos o seu feedback.

Guia rápido para matrizes de solidez

Tipos de matriz de solidez

Declarar Matriz

Inicializar Arrays

Criando matrizes de memória dinâmica

Acessando elementos da matriz

Membros

Example:

Example:

Example:

Conclusão

Sentindo entediado?