O que são cordas na solidez?

Strings de solidez são usadas para representar dados textuais. Eles são uma sequência de caracteres Unicode entre aspas duplas ( “ ).

Strings podem conter qualquer caractere Unicode, incluindo letras, dígitos, sinais de pontuação e caracteres especiais.

Neste artigo, exploraremos profundamente as strings do Solidity , discutindo suas propriedades, limitações, como são declaradas e como são usadas em contratos inteligentes.

Índice-

cordas de solidez

No Solidity, strings literais podem ser usadas com aspas duplas ( “ ) ou aspas simples ( ' ).

Para declarar uma string no Solidity, você pode usar a palavra-chave string .

O tipo de dados String está disponível para declarar variáveis ​​do tipo String:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function get_String() public pure returns(string memory){
string memory mrx="Hey User !! You are learning about Solidity String";
return mrx;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

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: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function printString() public pure returns(string memory){
string memory mrx=" Greetings User !! We are learning about Solidity Strings ";
return mrx;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Exemplo de Explicação

Conforme o exemplo acima, “ Hey User !! Você está aprendendo sobre Solidity String ” representa uma string literal com dados representando uma variável de string.

Bytes são preferidos em vez de Strings, pois as operações de string requerem mais gás do que as operações de byte.

Há uma conversão embutida entre bytes e strings no Solidity.

É fácil atribuir um literal String a uma variável do tipo byte32 no Solidity. O Solidity o trata como um literal byte32.

Example: 

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

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
bytes32 my_string_to_byte="I hope Solidity strings are easy";
function String_To_Bytes() public returns(bytes32){
return my_string_to_byte;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

saída de exemplo de sequências de solidez

Personagens de fuga de solidez

No Solidity, os caracteres de escape são usados ​​para representar caracteres especiais ou sequências de caracteres em uma string.

Aqui estão alguns dos caracteres de escape comumente usados ​​no Solidity :

Personagens Visão geral
\n Inicializa uma nova linha.
\\ Barra invertida.
\' Citação única.
\” Citação dupla.
\b Backspace.
\f Alimentação de formulário.
\r Exibe Carruagem.
\t Espaços de tabulação são alocados para a string.
\v Guia Vertical.
\xNN Um valor Hex é representado e os bytes apropriados são inseridos.
\uNNNN Adiciona a sequência UTF-8 e representa o valor Unicode.

Conversão de Bytes para String

O construtor string() pode ser usado para converter Bytes em Strings.

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{
function get_String() public pure returns(string memory){
bytes memory my_Bytes = new bytes(12);
string memory message = string(my_Bytes);
return message;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
function get_Integer_to_String() public pure returns(uint){
uint mrx=4;
uint ample=6;
uint sum=mrx+ample;
return sum;
}
function get_String() public pure returns(string memory){
bytes memory my_Bytes = new bytes(20);
string memory message = string(my_Bytes);
return message;
}
function get_Length() public pure returns (uint256)
{
string memory s="Mr.Examples";
bytes memory b = bytes(s);
return b.length;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

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
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest {
uint myNumber = 31211;
function convertToString() public view returns (string memory) {
return uintToString(myNumber);
}
function uintToString(uint mrx) internal pure returns (string memory) {
if (mrx == 0) {
return "0";
}
uint ample = mrx;
uint length;
while (ample != 0) {
length++;
ample /= 10;
}
bytes memory my_Byte_String = new bytes(length);
uint mrx_ample = length;
while (mrx != 0) {
mrx_ample = mrx_ample-1;
uint8 temp = uint8(48 + mrx % 10);
my_Byte_String[mrx_ample] = bytes1(temp);
mrx /= 10;
}
return string(my_Byte_String);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Siga as etapas no capítulo Aplicação do Solidity First para executar o programa acima.

Conclusão

Strings de solidez são um componente essencial de muitos aplicativos de contratos inteligentes, fornecendo uma maneira versátil e poderosa de armazenar e manipular dados na blockchain Ethereum.

Embora tenham algumas limitações, como imutabilidade e custos mais altos para armazenamento de memória, elas podem ser contornadas usando as funções e bibliotecas integradas do Solidity para manipulação de strings.

À medida que o ecossistema blockchain continua a evoluir e se expandir, a importância das strings Solidity no desenvolvimento de contratos inteligentes só aumentará.

Ao entender suas propriedades e limitações e como trabalhar com elas de forma eficaz, os desenvolvedores podem criar aplicativos blockchain mais robustos e eficientes que podem beneficiar usuários em todo o mundo.

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.