Anterior

Siguientes

Exploración de los tipos de valores

Completado

En esta unidad veremos cuáles son los principales tipos de valor en Solidity. Los tipos de valor se pasan por valor y se copian cuando se usan. Los tipos de valor principales que se usan al escribir contratos son enteros, valores booleanos, string literal, direcciones y enumeraciones.

Enteros

En todos los archivos de código fuente de Solidity se usan enteros. Representan números enteros y pueden llevar o no signo. Los enteros varían en tamaño de almacenamiento de 8 a 256 bits.

• Con signo: incluye números negativos y positivos. Se puede representar como int.
• Sin signo: incluyen únicamente números positivos. Se puede representar como uint.

Si no se especifica un número de bits, el valor predeterminado es de 256.

En los enteros se pueden usar las siguientes operaciones:

• Comparaciones: <=, <, ==, !=, >=, >
• Operadores de bits: & (and), | (or), ^ (bitwise exclusive), ~ (bitwise negation)
• Operadores aritméticos: + (addition),- (subtraction), * (multiplication), / (division), % (modulo), ** (exponential)

Estos son algunos ejemplos de definiciones de enteros:

int32 price = 25; // signed 32 bit integer
uint256 balance = 1000; // unsigned 256 bit integer

balance - price; // 975
2 * price; // 50
price % 2; // 1

Valores booleanos

Los valores booleanos se definen usando la palabra clave bool. Su valor siempre es true o false.

Así es como se pueden definir:

bool forSale; //true if an item is for sale
bool purchased; //true if an item has been purchased

Los valores booleanos se suelen usar en instrucciones de comparación. Por ejemplo:

if(balance > 0 & balance > price) {
    return true;
}

if(price > balance) {
    return false;
}

También se pueden usar en parámetros de funciones y en tipos de valores devueltos.

function buy(int price) returns (bool success) {
    // ...
}

Literales de cadena

También se usan String literals en la mayoría de los archivos de contrato. que son caracteres o palabras entre comillas simples o dobles.

    String shipped = "shipped"; // shipped
    String delivered = 'delivered'; // delivered
    String newItem = "newItem"; // newItem

Además, con string literals se pueden usar los siguientes caracteres de escape.

• \<newline> (escapa a una línea nueva)
• \n (línea nueva)
• \r (retorno de carro)
• \t (pestaña)

Dirección

Una dirección es un tipo con un valor de 20 bytes que representa una cuenta de usuario de Ethereum. Este tipo puede ser address a secas o address payable.

La diferencia entre ambos es que un tipo address payable es una dirección a la que se puede enviar Ethers y que contiene los miembros adicionales transfer y send.

address payable public seller; // account for the seller
address payable public buyer; // account for the user

function transfer(address buyer, uint price) {
    buyer.transfer(price); // the transfer member transfers the price of the item
}

Enumeraciones

En Solidity, puede usar enumeraciones para crear un tipo definido por el usuario. Decimos "definido por el usuario" porque la persona que crea el contrato decide qué valores se van a incluir. Las enumeraciones se pueden usar para presentar muchas opciones seleccionables, una de las cuales es obligatoria.

Una enumeración se puede usar, por ejemplo, para presentar diferentes estados de un artículo. Las enumeraciones pueden considerarse como una presentación de varias opciones de respuesta donde todos los valores están predefinidos y hay que seleccionar uno. Las enumeraciones se pueden declarar en definiciones de contrato o de biblioteca.

enum Status { 
    Pending,
    Shipped,
    Delivered 
}

Status public status;

constructor() public {
    status = Status.Pending;
}

Continuar