Funções Solidity: dicas e truques para um desenvolvimento eficiente

Este artigo explorará como as funções do Solidity podem ser usadas para criar contratos inteligentes eficientes e seguros na blockchain Ethereum implementando as funções do Solidity.

Durante esta sessão, também examinaremos alguns dos principais recursos e benefícios das funções do Solidity, bem como alguns exemplos de como elas podem ser aplicadas no desenvolvimento de contratos inteligentes .



Funções de Solidez

Solidity Functions são grupos reutilizáveis ​​de código, acessíveis de qualquer lugar em seu programa.

Não há necessidade de escrever o mesmo código repetidamente.

Facilita a escrita de código modular.

O uso de funções permite que um programador divida um grande programa em partes menores e gerenciáveis.

Semelhante a outras linguagens de programação avançadas, o Solidity também suporta funções para escrever código modular.

As seções a seguir explicam como escrever suas próprias funções do Solidity.


Declarar função de solidez

As funções são normalmente definidas no Solidity usando a palavra-chave function seguida por um nome distinto.

Nota : lembre-se de que não corresponde a nenhuma palavra-chave reservada na programação do solidity.

Além disso, uma função pode conter uma lista de parâmetros que contém o nome do parâmetro e seu tipo de dados correspondente.

Os valores de retorno nas funções são opcionais, mas no Solidity , se existirem, os tipos de retorno são especificados no momento da declaração.

Sintaxe

function mrx_function_name(parameter_list) scope returns(return_type) {
// The code and working of the function should be declared here.
// This is also known as function definition.
}

 

O programa a seguir mostra uma função chamada Multiply_Mrx_and_Ample() para obter o produto para duas variáveis ​​uint mrx e ample :

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function Multiply_Mrx_and_Ample() public pure returns(uint){
uint mrx=20;
uint ample=10;
return (mrx*ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
Da mesma forma, o mesmo trabalho poderia ser feito recebendo uma entrada do usuário:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function Multiply_Mrx_and_Ample(uint mrx,uint ample) public pure returns(uint){
return (mrx*ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Exemplo de Explicação

No exemplo acima, definimos uma função chamada “ Multiply_Mrx_and_Ample ” que recebe dois parâmetros de entrada inteiros não assinados “ mrx ” e “ amplo ” e retorna seu produto como um valor inteiro não assinado.

Vamos analisar o código linha por linha:
  • // SPDX-License-Identifier: 3.0 : Este é um comentário que especifica a licença sob a qual o código é lançado. Nesse caso, a licença não é especificada, mas usa SPDX, que é um formato padrão para especificar licenças de código aberto.
  • solidez de pragma ^0.8.0; : Esta é uma declaração de pragma de versão do Solidity que especifica a versão do compilador do Solidity que deve ser usada para compilar este contrato. Nesse caso, especifica a versão 0.8.0 ou superior.
  • contract SolidityTest{ : declara um novo contrato Solidity chamado “SolidityTest”.
  • function Multiply_Mrx_and_Ample(uint mrx,uint ample) public pure return(uint){ : Esta é uma declaração de função que recebe dois parâmetros de entrada “mrx” e “ample” do tipo “uint” (inteiro sem sinal), é marcada como “public” (o que significa que pode ser chamado de fora do contrato) e marcado como “puro” (o que significa que não lê ou modifica o estado do contrato).
  • retorno (mrx*amplo); : Este é o corpo da função que retorna o produto dos dois parâmetros de entrada “mrx” e “ample” como um valor inteiro sem sinal.

função de chamada

Uma chamada para a função é feita quando o usuário precisa executá-la.

A função no Solidity é simplesmente invocada escrevendo seu nome no lugar onde ela deve ser chamada.

Uma função pode ser chamada com diferentes argumentos.

Da mesma forma, vários parâmetros podem ser passados ​​para a função, separando-os com uma vírgula.

O exemplo a seguir mostra a chamada de uma função:

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
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function get_Square(uint mrx_Number) public pure returns(uint){
return mrx_Number * mrx_Number;
}
function get_Square_devide_by_Two() public pure returns(uint){
uint mrx_1=get_Square(13)/2;
return mrx_1;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
O código a seguir mostra a chamada da função dentro de outra função:

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: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function get_Product(uint mrx,uint ample) public pure returns(uint){
return mrx * ample;
}
function get_Product_Devided_by_4() public pure returns(uint){
return get_Product(2,5)/4;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Parâmetros da função de solidez

Também existe uma maneira de fornecer valores para uma função como parâmetros.

É possível capturar esses parâmetros passados ​​dentro da função para que qualquer manipulação possa ser realizada sobre eles para atingir os resultados desejados.

Nota : Vários parâmetros podem ser passados ​​para uma função, separados por vírgulas.

Um nome de função simples get_Name() é usado aqui, que recebe o nome como entrada do usuário e o imprime de acordo:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function get_Name(string memory mrx) public pure returns(string memory){
return mrx;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
O código fornecido ilustra a entrada do usuário e a localização de seu módulo, respectivamente:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function get_Modulus(uint mrx,uint ample) public pure returns(uint){
return mrx % ample;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

A declaração de retorno

O Solidity fornece uma instrução de retorno como uma instrução opcional.

A última instrução de uma função retorna seus valores da função.

A linguagem de programação solidity suporta o retorno de múltiplos valores de cada função.

Para retornar valores de uma função, os tipos de dados dos valores de retorno devem ser definidos no momento da declaração da função.

Você pode entender melhor o funcionamento da instrução return consultando o exemplo abaixo:

 

// SPDX-License-Identifier: 3.0
pragma solidity ^0.8.0;

contract SolidityTest{

function mrx_Calculator(string memory mrx_Topic) public pure returns(string memory){

return mrx_Topic;

}

}

 

O exemplo fornecido mostra o funcionamento de várias instruções de retorno :

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: 3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function mrx_Calculator(uint mrx,uint ample) public pure returns(string memory,uint,uint,uint,uint,uint){
uint sum=mrx+ample;
uint difference=mrx-ample;
uint product=mrx*ample;
uint divide=mrx/ample;
uint modulus=mrx % ample;
string memory mrx_ample="After Performing Calculations the results are: ";
return(mrx_ample,sum,difference,product,divide,modulus);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Conclusão

Os contratos inteligentes de Solidity dependem fortemente de funções.

Isso permite que você especifique o comportamento, a lógica e a interação de um contrato no blockchain.

Utilizando os vários tipos de função do Solidity, uma ampla variedade de contratos inteligentes pode ser criada.

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