Algunas características importantes de los contratos inteligentes de solidez, como las variables de memoria y almacenamiento en matrices de longitud variable, las ubicaciones de almacenamiento de almacenamiento y memoria, y el uso de la matriz de cadenas string [].
Más tecnología blockchain y clasificación de aplicaciones:
Blockchain applicationBlockchain desarrollo
Ethernet Square | Fabric | BCOS | criptografía | algoritmo de consenso | bitcoin | Otra cadena
Economía de Fichas | Escenarios Financieros tradicional | descentralizada Finanzas | Anti-falsificación de trazabilidad | Intercambio de Datos | Trusted fuerte
1. Respecto a las matrices de longitud variable.
cadena [], bytes []
Para las matrices de longitud variable, no se pueden utilizar antes de inicializar el espacio asignado. Puede inicializar una matriz con la nueva palabra clave. No se puede acceder a ellos mediante subíndices antes de inicializar con la nueva palabra clave.
almacenamiento
La matriz dinámica de tipo de almacenamiento tiene un atributo de longitud, que representa la longitud actual de la matriz. Para arreglos de almacenamiento de longitud variable, la longitud del arreglo se puede ajustar asignando un valor a la longitud. Puede cambiar la longitud de la matriz de dos formas, index ++ y método push.
contract test{
string[] strs = new string[](0);
function test1() public returns(uint, string[]){
strs[strs.length++] = "a1";
return (strs.length, strs);
}
function test2() public returns(uint, string[]){
strs.push("b1");
return (strs.length, strs);
}
}
memoria
La matriz dinámica de tipo de memoria no admite la modificación de la propiedad de longitud para ajustar el tamaño de la matriz. Una vez terminado el nuevo, no se puede cambiar el tamaño.
2. Almacenamiento y memoria de la ubicación de almacenamiento
Asignar memoria al almacenamiento
contract test1{
int i;
struct S{string a;uint b;}
function assign(S s) internal{
S tmp = s; // 报错，tmp是局部变量(storage类型)，s是函数参数(memory类型)
}
function change(int changei) public returns(int){
i = changei;
return i; // 返回等于changei的值
}
}
Convertir almacenamiento en almacenamiento
contract test2{
struct S{string a;uint b;}
//状态变量，合约内声明的公有变量，默认是storage的
S s;
function convertStorage(S storage s) internal{
S tmp = s; // tmp也是storage类型的
tmp.a = "Test";
}
function call() returns (string){
convertStorage(s);
return s.a;//Test
}
}
Asignar memoria al almacenamiento
contract test3{
struct S{string a;uint b;}
//默认是storage的
S s;
function memoryToState(S memory tmp) internal{
s = tmp; //tmp是memory的，从内存中复制到状态变量中。
//修改旧memory中的值，并不会影响状态变量
tmp.a = "Test";
}
function call() returns(string){
S memory tmp = S("memory", 0);
memoryToState(tmp);
return s.a;
}
}
Asignar memoria a variables locales (almacenamiento)
contract test4{
struct S{string a;uint b;}
function memoryToLocal(S s) internal{
S tmp = s; // 报错，tmp是局部变量(storage类型)，s是函数参数(memory类型)
//修改变量为memory类型, 不会报错
S memory tmp = s;
}
}
memoria de asignación de almacenamiento
contract test5{
struct S{string a;uint b;}
S s = S("storage", 1);
function storageToMemory(S storage x) internal{
S memory tmp = x;//由Storage拷贝到memory中
//memory的修改不影响storage
tmp.a = "Test";
}
function call() returns (string){
storageToMemory(s);
return s.a; //storage
}
}
memoria de asignación de memoria
La memoria se pasa por referencia y los datos no se copian. Asignar un tipo de referencia de una memoria a una referencia de otra memoria no creará otra copia nueva.
contract test6{
struct S{string a;uint b;}
//默认参数是memory
function memoryToMemory(S s) internal{
S memory tmp = s; // tmp是memory，s是memory
//引用传递
tmp.a = "other memory";
}
function call() returns (string){
S memory mem = S("memory", 1);
memoryToMemory(mem);
return mem.a;//other memory
}
}
3. Cadena de matriz de cadenas []
function getEntry(string[] fields, Entry entry) internal view returns (string[]) {
//string[] values = new string[](fields.length); 报错，values是storage类型的，后面是memory
for (uint i = 0; i < fields.length; i++) {
values[i] = entry.getString(fields[i]);
}
return values;
}
function getEntry(string[] fields, Entry entry) internal view returns (string[]) {
string[] memory values = new string[](fields.length); // 正确
for (uint i = 0; i < fields.length; i++) {
values[i] = entry.getString(fields[i]);
}
return values;
}
Enlace original: características importantes de los contratos inteligentes de solidez