Extensión Solidity: conversión de tipos de datos

 

1. Conversión implícita de tipo de datos (automática)

Conversión entre el mismo tipo: de longitud baja a longitud alta int8-int16-int32······int256, pero int no se puede convertir automáticamente a uint, porque el número negativo no se puede convertir directamente y no se puede convertir  int8 a  uint256 (porque  uint256 algunos valores no se pueden cubrir, por ejemplo,  -1).

Los operandos y y z de la adición a continuación no tienen el mismo tipo, pero uint8 se puede convertir implícitamente en uint16, pero no al revés. Por lo tanto, antes de realizar la suma, convierta y al tipo de z, en tipo uint16. El tipo de resultado de la expresión y + z es uint16. Después de realizar la adición. Debido a que se asigna a una variable de tipo uint32, se realiza otra conversión implícita.

uint8 y;
uint16 z;
uint32 x = y + z;

2. Conversión de visualización del tipo de datos (obligatorio)        

Si el compilador no admite la conversión implícita en algunos casos, pero sabe exactamente lo que quiere hacer, puede considerar la conversión explícita en este caso. Tenga en cuenta que esto puede tener algunas consecuencias imprevistas, ¡así que asegúrese de probar para asegurarse de que el resultado es el que desea!

1. Convierta un  int8 número negativo de un tipo en  uint:

int8 y = -3; 
uint x = uint(y);

Al final de este código, x el valor de será  0xfffff..fd (64 caracteres hexadecimales), ya que este es el complemento de 256 bits de -3.

 

2. Si un tipo se convierte explícitamente a un tipo más pequeño, los bits altos correspondientes se descartarán

uint32 a = 0x12345678; 
uint16 b = uint16(a); // en este momento el valor de b es 0x5678

3. Si un número entero se convierte explícitamente a un tipo más grande, se rellenará a la izquierda (es decir, en una posición de orden superior). El resultado de la conversión sigue siendo igual al entero original

uint16 a = 0x1234; 
uint32b = uint32(a); // b 为 0x00001234 ahora 
afirmar (a == b);

Las conversiones de matriz de bytes de longitud fija son diferentes, se pueden considerar como una secuencia de bytes individuales y la conversión a un tipo más pequeño cortará la secuencia.

bytes2 a = 0x1234; 
bytes1 b = bytes1(a); // b 0x12

1. Si la matriz de bytes de longitud fija se convierte explícitamente a un tipo más grande, se completará de la manera correcta. Acceder a los bytes convertidos con un índice fijo será igual al valor anterior (si el índice todavía está dentro del rango):

bytes2 a = 0x1234; 
bytes4 b = bytes4(a); // b es 0x12340000 
afirmar(a[0] == b[0]); 
afirmar(a[1] == b[1]); 

porque la suma de enteros Las matrices de bytes largos se comportan de manera diferente cuando se truncan (o se rellenan), lo que permite la conversión explícita entre matrices de bytes de longitud fija y entera si tienen el mismo tamaño. Para convertir entre matrices de bytes, se debe usar un tipo intermedio para especificar las reglas de truncamiento y relleno necesarias: 
bytes2 a = 0x1234; 
uint32 b = uint16(a); // b es 0x00001234 
uint32 c = uint32(bytes4(a )); // c es 0x12340000 
uint8 d = uint8(uint16(a)); // d es 0x34 
uint8 e = uint8(bytes1(a)); // e es 0x12

3. Conversión de constantes literales y tipos básicos

Conversión constante de enteros y literales

Los literales decimales y hexadecimales se pueden convertir implícitamente a cualquier tipo de entero lo suficientemente grande como para representarlo sin truncamiento

uint8 a = 12; // factible 
uint32 b = 1234; // factible 
uint16 c = 0x123456; // fallido, será truncado a 0x3456

Matriz de bytes de longitud fija y conversión constante literal

Un literal decimal no se puede convertir implícitamente en una matriz de bytes de longitud fija. Un literal hexadecimal puede serlo, pero solo si el tamaño del número hexadecimal se ajusta exactamente a la longitud de la matriz de bytes de longitud fija. Con la excepción del valor cero, tanto los literales decimales como hexadecimales de cero se pueden convertir a cualquier tipo de matriz de bytes de longitud fija:

bytes2 a = 54321; // no factible 
bytes2 b = 0x12; // no factible 
bytes2 c = 0x123; // no factible 
bytes2 d = 0x1234; // factible 
bytes2 e = 0x0012; // factible 
bytes4 f = 0; // Bytes4 factible 
g = 0x0; // Factible

Los literales de cadena y los literales de cadena hexadecimales se pueden convertir implícitamente en matrices de bytes de longitud fija si su número de caracteres coincide con el tamaño del tipo de byte:

bytes2 a = hex "1234"; // factible 
bytes2 b = "xy"; // factible 
bytes2 c = hex "12"; // no factible 
bytes2 d = hex "123"; // n no factible 
bytes2 e = " x"; // no factible 
bytes2 f = "xyz"; // no factible

4. Conversión de datos relacionada con el tipo de dirección

• Los literales hexadecimales del tamaño correcto que superan la prueba de suma de comprobación se utilizan como  address tipos. 
• Solo  bytes20 y  uint160 permitir conversiones explícitas a  address tipos 
• Al convertir desde  bytes20 o hacia otro  address tipo de visualización de enteros, se trata como  address payable el tipo. 
• Una dirección  address a se puede  payable(a)　convertir a  address payable tipo .