Débuter sur Solidity : Les types de variables et données

Types de données en Solidity :

Solidity prend en charge plusieurs types de données qui sont utilisés pour stocker différentes informations. Les types de données de Solidity peuvent être classés en deux catégories : les types de données élémentaires et les types de données complexes.

Les types de données élémentaires sont les types de données de base dans Solidity. Ils sont les suivants :

1. bool : un type de données qui ne peut prendre que deux valeurs – true ou false.
2. uint : un type de données entier non signé qui peut stocker des valeurs positives.
3. int : un type de données entier signé qui peut stocker des valeurs positives et négatives.
4. address : un type de données qui stocke une adresse Ethereum de 20 octets.
5. bytes : un type de données qui peut stocker une séquence d’octets.

Les types de données complexes sont les types de données qui sont construits à partir des types de données élémentaires. Les types de données complexes de Solidity comprennent :

1. tableaux : un ensemble de données qui peut contenir plusieurs éléments du même type.
2. structures : un ensemble de données qui peut contenir plusieurs éléments de types différents.
3. enums : un type de données qui permet de définir un ensemble de valeurs possibles.

Variables en Solidity :

Les variables en Solidity sont utilisées pour stocker des valeurs dans la mémoire du contrat. Pour utiliser une variable en Solidity, vous devez d’abord déclarer le type de données de la variable, puis donner un nom à la variable. Par exemple, pour déclarer une variable de type uint, vous pouvez utiliser la syntaxe suivante :

csharpCopy codeuint myVariable;

Vous pouvez également initialiser une variable lors de sa déclaration. Par exemple, pour initialiser une variable de type uint avec la valeur 10, vous pouvez utiliser la syntaxe suivante :

csharpCopy codeuint myVariable = 10;

En Solidity, il est possible de déclarer des variables locales et des variables de stockage. Les variables locales sont déclarées à l’intérieur d’une fonction et sont stockées dans la pile de la fonction. Les variables de stockage sont déclarées en dehors des fonctions et sont stockées dans le stockage permanent du contrat.

Exemple de contrat :

Pour mieux comprendre les types de données et les variables en Solidity, voici un exemple de contrat que vous pouvez exécuter sur Remix.

pragma solidity ^0.8.0;

contract MyContract {
    uint public myUint;
    bool public myBool;
    address public myAddress;
    bytes public myBytes;
    
    struct MyStruct {
        uint structUint;
        bool structBool;
    }
    
    MyStruct public myStruct;
    
    enum MyEnum {
        VALUE_ONE,
        VALUE_TWO,
        VALUE_THREE
    }

    function setMyUint(uint newValue) public {
        myUint = newValue;
    }
    
    MyEnum public myEnum;
    
    constructor() {
        myUint = 123;
        myBool = true;
        myAddress = msg.sender;
        myBytes = "hello world";
        
        myStruct = MyStruct(456, false);
        
        myEnum = MyEnum.VALUE_TWO;
    }
}

Ce contrat contient des exemples de différents types de données et de variables en Solidity, notamment des types de données élémentaires tels que uint, bool, address et bytes.

Il contient également des types de données complexes tels que les structures et les enums. Le contrat contient une structure appelée « MyStruct » qui a deux champs, un champ de type uint appelé « structUint » et un champ de type bool appelé « structBool ». Le contrat contient également une énumération appelée « MyEnum » qui définit trois valeurs possibles.

Le contrat a un constructeur qui initialise les variables avec des valeurs par défaut. Le constructeur initialise la variable « myUint » avec la valeur 123, la variable « myBool » avec la valeur true, la variable « myAddress » avec l’adresse de l’expéditeur du contrat, la variable « myBytes » avec la valeur « hello world », la variable « myStruct » avec un nouvel objet de type MyStruct qui a les valeurs 456 et false pour les champs structUint et structBool respectivement, et la variable « myEnum » avec la valeur MyEnum.VALUE_TWO.

Pour tester ce contrat, vous pouvez suivre les étapes suivantes :

1. Ouvrez Remix et créez un nouveau fichier Solidity.
2. Copiez le code du contrat ci-dessus dans le fichier.
3. Compilez le contrat en cliquant sur le bouton « Compile » dans Remix.
4. Déployez le contrat en cliquant sur le bouton « Deploy » dans Remix.
5. Une fois le contrat déployé, vous pouvez accéder aux différentes variables en utilisant les fonctions publiques générées automatiquement par Solidity. Par exemple, pour accéder à la variable « myUint », vous pouvez utiliser la fonction « myUint() ». Pour accéder à la variable « myStruct », vous pouvez utiliser la fonction « myStruct() ».
6. Vous pouvez également modifier les variables en appelant les fonctions correspondantes. Par exemple, pour modifier la variable « myUint », vous pouvez utiliser la fonction « setMyUint(uint newValue) ». Vous pouvez ensuite utiliser la fonction « myUint() » pour vérifier que la variable a été modifiée.

Conclusion :

En conclusion, les types de données et les variables sont des éléments clés de la programmation en Solidity. Solidity prend en charge plusieurs types de données différents, notamment les types de données élémentaires tels que bool, uint et address, ainsi que les types de données complexes tels que les structures et les enums. Les variables en Solidity sont utilisées pour stocker des données dans la mémoire du contrat, et il est possible de déclarer des variables locales et des variables de stockage. En utilisant l’exemple de contrat fourni ci-dessus, vous pouvez expérimenter avec différents types de données et variables pour mieux comprendre comment ils fonctionnent en Solidity.