Modificadores de função Solidity: um guia completo

Neste artigo, exploraremos os modificadores de função do Solidity em detalhes, incluindo o que são, como funcionam e por que são úteis.

Os modificadores de função do Solidity permitem definir regras personalizadas que devem ser atendidas antes da execução de uma função .



O que são Modificadores de Função Solidity?

Os modificadores de função do Solidity são recursos poderosos que permitem adicionar código adicional a uma função para modificar seu comportamento.

Os modificadores de função são tipos especiais de funções que podem alterar o comportamento de outras funções dentro de um contrato.

Usando um modificador de função, você pode adicionar funcionalidade adicional à sua função sem alterar sua lógica principal.


Como funcionam os modificadores de função Solidity?

No Solidity , as funções são modificadas pegando o código existente da função e envolvendo-o em código adicional para cumprir seu propósito.

Existem muitas funções que podem ser realizadas usando o código adicional, como verificar se o chamador da função está autorizado a executá-la ou registrar os dados no blockchain, usando o código adicional.


Como criar modificadores de função?

A declaração dos modificadores da função Solidity pode ser feita da seguinte forma:

Sintaxe

modifier modifier_name{

// The code to be executed

_;

}

Os curingas de mesclagem são representados por _; símbolo, que é substituído quando a definição da função é executada.

Existem dois tipos de modificadores:

1. Modificadores com Parâmetros:

modifier modifier_name(unit mrx_Args)
{
// action to be taken
}

2. Modificadores sem Parâmetros:

modifier modifier_name()
{
// function to be performed
}

Siga o exemplo abaixo para entender melhor os modificadores de solidez:

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
address banker_address;
struct Banker{
uint banker_Id;
string banker_name;
string banker_code;
}
constructor() public{
banker_address=msg.sender;
}
modifier is_Banker{
require(banker_address==msg.sender);
_;
}
Banker mrx;
function fetch_Data(uint mrx_banker,string memory ample,string memory ample2) public is_Banker{
mrx.banker_Id=mrx_banker;
mrx.banker_name=ample;
mrx.banker_code=ample2;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
Também podemos usar o modificador tendo uma entrada do usuário. Dê uma olhada no 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
struct Banker{
uint banker_Id;
string banker_name;
string banker_code;
}
modifier is_Banker_Experienced(uint exp){
if(exp >= 6){
_;
}
else{
revert("The Banker Does not have an Experience of more than 5 years ");
}
}
Banker mrx;
function fetch_Data(uint mrx_banker,string memory ample,string memory ample2) public is_Banker_Experienced(7){
mrx.banker_Id=mrx_banker;
mrx.banker_name=ample;
mrx.banker_code=ample2;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Exemplo de Explicação

O exemplo acima é um contrato inteligente Solidity escrito na versão 0.8.0 da linguagem de programação Solidity. Ele define um contrato chamado “ SolidityTest ” que contém uma estrutura chamada “ Banker ”.

A estrutura “Banker” tem três propriedades – “ banker_Id ” do tipo uint (inteiro sem sinal), “ banker_name ” do tipo string e “ banker_code ” do tipo string.

O contrato também contém um modificador denominado “ is_Banker_Experienced ” que recebe um parâmetro de entrada “ exp ” do tipo uint.

O modificador verifica se o parâmetro de entrada é maior ou igual a 6. Se a condição for true , ele executa a função à qual o modificador está vinculado usando o _;  extrato, caso contrário reverte a transação com mensagem de erro “ O Banqueiro não tem Experiência superior a 5 anos ”.

O contrato tem uma função chamada “ fetch_Data ” que recebe três parâmetros de entrada – “ mrx_banker ” do tipo uint, “ ample ” do tipo string e “ ample2 ” do tipo string.

A função é anexada com o modificador “ is_Banker_Experienced ” com valor 7. Isso significa que apenas os banqueiros com experiência de 7 ou mais anos podem executar esta função.

A função “ fetch_Data ” atribui os valores de entrada às propriedades do objeto “ mrx ” da estrutura “ Banker ”.

Correspondendo ao outro exemplo, mostra que a função add só é executada se as variáveis ​​mrx e ample forem maiores que 10, caso contrário:

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
34
35
36
37
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
modifier when_condition_is_4(uint condition){
if(condition == 4){
_;
}
else{
revert("The Condition is not matched hence function can not be executed ");
}
}
function get_Sum(uint mrx,uint ample) public pure when_condition_is_4(4) returns (uint){
uint sum=mrx+ample;
return sum;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Conclusão

Os modificadores de função Solidity fornecem aos desenvolvedores de contrato uma maneira poderosa de adicionar verificações adicionais e pré e pós-condições .

Usando modificadores, você pode impor controles de acesso, validar entradas ou modificar o comportamento de funções com base em condições específicas.

Ao projetar modificadores de função do Solidity, é importante mantê-los simples e fáceis de entender.

Os modificadores devem ser usados ​​para implementar requisitos comuns que são compartilhados por várias funções em um contrato, em vez de adicionar uma lógica complexa a funções individuais.

Ao seguir as práticas recomendadas para o design do modificador de função do Solidity, você pode criar contratos inteligentes que são mais seguros, eficientes e fáceis de manter.

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