Guia rápido para loops de solidez

Nesta discussão, exploraremos os vários tipos de loops Solidity e como eles podem ser usados ​​em contratos inteligentes com exemplos.

Ao redigir um contrato , existe a possibilidade de você se deparar com uma situação em que terá que realizar uma ação repetidas vezes.

Como resultado, nesses casos, uma instrução de loop seria necessária para que houvesse menos linhas para escrever.

Índice-

Tipos de loops de solidez

Os loops de solidez são uma ferramenta essencial para a construção de contratos inteligentes, pois permitem a execução eficiente e precisa de tarefas repetitivas.

É extremamente fácil escrever programas com Solidity, pois suporta todos os loops necessários para facilitar o processo de programação.

Solidity tem três tipos de loops:

  1. o laço for
  2. O loop while
  3. O loop faça-enquanto

Cada loop tem sua própria sintaxe e casos de uso exclusivos.

É importante usar loops com cuidado no Solidity, pois eles podem consumir uma quantidade significativa de gás, o que pode encarecer a execução do contrato inteligente.

Gas é a unidade monetária usada na rede Ethereum para medir os recursos computacionais necessários para executar uma transação ou contrato inteligente.

Lembre-se : cada operação no Solidity requer uma certa quantidade de gás, e os loops não são exceção.

Para otimizar o uso de gás nos loops, é importante reduzir ao mínimo o número de iterações e evitar operações desnecessárias dentro do loop.

Recomendação : é recomendável usar o tipo de dados uint256 para variáveis ​​de loop para evitar erros de estouro.

Solidez For Loop

For loops são os loops mais simples usados ​​no Solidity que costumavam executar um bloco de código um número fixo de vezes.

Três partes significativas do loop for estão listadas abaixo.

 

Instruções de sintaxe Visão geral
Declaração de inicialização O primeiro passo no loop é inicializar nossa variável com um valor inicial. Antes de iniciar o loop, a instrução de inicialização é executada.
Declaração de teste Uma expressão que testa se uma determinada condição é verdadeira ou não. Caso a condição seja verdadeira, o código dentro do loop é executado; caso contrário, o loop é encerrado.
Declaração de iteração As instruções de iteração permitem que você aumente ou diminua seu contador.

As três partes podem ser colocadas em uma única linha, separando-as com ponto e vírgula ; .

Sintaxe

A sintaxe básica do loop for é dada abaixo:

for (initialization; test condition; iteration statement) {

//The given block of code will be executed if the condition is met

}

No exemplo abaixo, o loop for imprimirá todos os números pares até 30:

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint[] data;
uint loop_variable;
function for_loop_working() public returns(uint[] memory){
for(loop_variable=0;loop_variable<=30;loop_variable++){
if(loop_variable%2==0){
data.push(loop_variable);
}
}
return data;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
O exemplo abaixo ilustra o funcionamento do loop for para imprimir o valor do array:

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
string[] america_Famous_Resturants=["Anajak Thai","Andiario","Apteka","Audrey","Bacanora","Bonnies","Brennans"];
uint loop_variable;
function for_loop_working() public returns(string[] memory){
for(loop_variable=0;loop_variable<america_Famous_Resturants.length;loop_variable++){
america_Famous_Resturants[loop_variable];
}
return america_Famous_Resturants;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Enquanto loop em solidez

O objetivo de um loop while é repetir a execução de uma instrução ou bloco de código várias vezes enquanto uma determinada expressão for verdadeira .

Assim que a expressão se tornar false , o loop terminará.

Sintaxe

Enquanto os loops no Solidity têm a seguinte sintaxe:

while (expression) {

//This statement (or statements) will be executed if the expression is true

}

Você pode implementar um loop while seguindo o exemplo abaixo.

O seguinte programa imprime os números naturais de 1 a 10:

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint [] data; // An array of integer is created in order to store the elements at every iteration
uint loop_variable=0; // The looping Element is initialized here
function While_Loop_Working() public returns (uint[] memory){ // Function of While loop is declared here
while(loop_variable<10){ // Loop is initialized here
loop_variable++; // An increament in looping element is done here
data.push(loop_variable); // Here we use the built in push function to keep elements in the data array
}
return data; // The value of data array is printed here
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
O exemplo abaixo exibe todos os elementos de um array da America's Airports List:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
string[] list_of_Airports=["Denver International Airport","Los Angeles International Airport","Chicago O'Hare International Airport","Dallas/Fort Worth International Airport","Denver International Airport"]; // An array of integer is created in order to store the elements at every iteration
uint loop_variable=0; // The looping Element is initialized here
function While_Loop_Working() public returns (string[] memory){ // Function containing the while loop is declared here
while(loop_variable<list_of_Airports.length){ // Loop is initialized here
list_of_Airports[loop_variable]; // The increamented loop_variable will be used as an index to print the string array
loop_variable++; // An increament in looping element is done here
}
return list_of_Airports; // The values of array list_of_Aiports is shown
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Loop faça-enquanto no Solidity

Esse loop é semelhante em muitos aspectos ao loop while, exceto pelo fato de executar a verificação de condição bem no final do loop, e não no início.

Sempre haverá pelo menos uma execução do loop, independentemente de a condição ser verdadeira ou falsa .

Sintaxe

No Solidity, você pode criar um loop do-while usando a seguinte sintaxe:

do {
//The following lines of code will be executed during the working of Do-While Loop;
} while (expression);

O programa fornecido imprime a tabela de 13:

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint[] data;
uint mrx=13;
uint loop_variable=0;
function get_Table() public returns(uint[] memory){
do{
loop_variable++;
uint value= mrx*loop_variable;
data.push(value);
}
while(loop_variable<=10);
return data;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
A tabela será impressa até 11, pois a condição é verificada após a execução.

Outro exemplo mostra os números de 20 a 0 em ordem inversa usando o loop do while:

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint[] data;
uint loop_variable=21;
function get_Value() public returns(uint[] memory){
do{
loop_variable--;
data.push(loop_variable);
}
while(loop_variable>0);
return data;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Controle de loop de solidez

No Solidity, loops e instruções switch podem ser manipulados com controle total.

Quando você está dentro de um loop, pode haver circunstâncias em que deseja sair dele antes de chegar ao fundo do loop.

Além disso, pode ocorrer uma situação em que você deseja pular uma parte do bloco de código e ir direto para a próxima iteração do loop nesse meio tempo.

Como resultado, o Solidity fornece instruções break e continue que podem lidar com todas essas situações. Se você usar essas instruções, poderá sair imediatamente de qualquer loop ou poderá iniciar a próxima iteração de qualquer loop imediatamente.

Declaração de quebra de solidez

As instruções break, que foram brevemente introduzidas com a instrução switch , são usadas como uma forma de sair de um loop.

Isso permite pular o código sob as chaves {} .

O exemplo a seguir mostra o funcionamento da instrução break.

O exemplo a seguir imprime todos os números ímpares de 1 a 10 e, em seguida, pula o loop devido à presença da instrução break:

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint loop_Element;
uint []odd_numbers;
function get_Odd_Numbers() public returns(uint[] memory){
for(loop_Element=1;loop_Element<=40;loop_Element++){
if(loop_Element % 2 ==1){
if(loop_Element==11){
break;
}
odd_numbers.push(loop_Element);
}
}
return odd_numbers;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
O exemplo a seguir mostra o funcionamento da instrução break de uma forma mais simples:

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 loop_Element;
uint []factorial_numbers;
uint fact=1;
function get_Factorial() public returns(uint[] memory){
for(loop_Element=1;loop_Element<=20;loop_Element++){
if(loop_Element == 10){
break;
}
else{
fact=fact*loop_Element;
factorial_numbers.push(fact);
}
}
return factorial_numbers;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Declaração de continuação de solidez

Quando o interpretador encontrar a sintaxe continue , ele iniciará imediatamente a próxima iteração do loop e pulará o restante dos blocos de código restantes no loop.

No caso de uma instrução continue, o fluxo do programa move-se imediatamente para a expressão de verificação de loop e, se a condição permanecer true , inicia a próxima iteração, caso contrário, sai do loop e imprime o bloco de código fora do loop.

O exemplo dado mostra o uso da instrução continue :

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint loop_Element;
uint []numbers;
function get_Multiples_of_5() public returns(uint[] memory){
for(loop_Element=1;loop_Element<=20;loop_Element++){
if(loop_Element==5){
continue;
}
uint value=loop_Element*5;
numbers.push(value);
}
return numbers;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

O exemplo a seguir mostra a sequência de 10 números naturais, exceto 2,4,6, usando a instrução continue :

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint loop_Element;
uint []numbers;
function get_Natural_Numbers() public returns(uint[] memory){
for(loop_Element=1;loop_Element<=10;loop_Element++){
if(loop_Element==2 || loop_Element==4 || loop_Element==6){
continue;
}
uint value=loop_Element;
numbers.push(value);
}
return numbers;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Conclusão

Os loops de solidez são uma parte crucial, permitindo que os desenvolvedores executem um bloco de código repetidamente com base em certas condições.

Quando usados ​​de forma eficaz, os loops do Solidity podem melhorar a eficiência e a legibilidade do seu código, permitindo que você execute operações complexas com facilidade. No entanto, é importante usar loops criteriosamente e evitar loops infinitos, que podem levar a problemas de desempenho e até travar seu programa.

Com uma sólida compreensão dos loops do Solidity, você pode escrever contratos inteligentes eficientes e eficazes que podem alimentar uma ampla gama de aplicativos descentralizados .

Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.