Explorer les types valeur

  • 6 minutes

Dans cette unité, vous allez découvrir les principaux types valeur de Solidity. Les valeurs sont passées par valeur et copiées lorsqu’elles sont utilisées. Les principaux types valeur que vous allez utiliser quand vous écrirez des contrats incluent entier, booléen, string literal, adresseet énumération.

Entiers

Les entiers sont utilisés dans chaque fichier source Solidity. Ils représentent des nombres entiers et peuvent être signés ou non signés. La taille de stockage des nombres entiers varie de 8 à 256 bits.

  • Signé : comprend des nombres négatifs et positifs. Peut être représenté par un int.
  • Non signés : Incluent uniquement des nombres positifs. Peut être représenté par un uint.

Si le nombre de bits n’est pas spécifié, la valeur par défaut est 256 bits.

Les opérations suivantes peuvent être appliquées aux entiers :

  • Comparaisons : <=, <, ==, !=, >=, >
  • Opérateurs de bits : & (and), | (or), ^ (bitwise exclusive), ~ (bitwise negation)
  • Opérateurs arithmétiques : + (addition),- (subtraction), * (multiplication), / (division), % (modulo), ** (exponential)

Voici quelques exemples de définitions d’entiers :

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

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

valeurs booléennes

Les types booléens sont définis à l’aide du mot clé bool. Ils ont toujours la valeur true ou false.

Voici la manière de les définir :

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

Les types booléens sont couramment utilisés dans les instructions de comparaison. Par exemple :

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

if(price > balance) {
    return false;
}

Et les types booléens peuvent aussi être utilisés dans des paramètres de fonction et des types de retour.

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

Littéraux de chaîne

String literals sont également utilisés dans la plupart des fichiers de contrat. Il s’agit de caractères ou de mots placés entre guillemets doubles ou simples.

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

Les caractères d’échappement suivants peuvent aussi être utilisés avec des string literals.

  • \<newline> place une nouvelle ligne dans une séquence d’échappement.
  • \n nouvelle ligne.
  • \r retour chariot.
  • \t tabulation.

Adresse

Une adresse est un type doté d’une valeur de 20 octets qui représente un compte d’utilisateur Ethereum. Ce type peut être une adresse normale ou une adresse payable.

La différence entre les deux réside dans le fait qu’un type adresse payable est une adresse à laquelle vous pouvez envoyer de l’Ether et qui contient les membres supplémentaires transfer et 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
}

Énumérations

Dans Solidity, vous pouvez utiliser des énumérations pour créer un type défini par l’utilisateur. Le type est qualifié de défini par l’utilisateur, car la personne qui crée le contrat décide des valeurs à inclure. Les énumérations peuvent être utilisées pour présenter plusieurs choix possibles, l’un d’entre eux étant nécessaire.

Une énumération peut être utilisée, par exemple, pour présenter les différents états d’un élément. Vous pouvez considérer les énumérations comme les réponses à une question à choix multiples : toutes les valeurs sont prédéfinies et vous devez en sélectionner une. Les énumérations peuvent être déclarées dans des définitions de contrat ou de bibliothèque.

enum Status { 
    Pending,
    Shipped,
    Delivered 
}

Status public status;

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