No history yet

Introduction à Solidity

Qu'est-ce que Solidity ?

Solidity est le langage de programmation le plus populaire pour écrire des contrats intelligents sur la blockchain Ethereum. Si vous avez déjà touché à des langages comme JavaScript, C++ ou Java, vous vous sentirez en terrain connu. Sa syntaxe est conçue pour être familière, ce qui facilite son apprentissage.

Solidity is a high-level programming language used for implementing smart contracts.

Un contrat intelligent, ou smart contract, est un programme qui s'exécute automatiquement lorsque certaines conditions sont remplies. Il est stocké et répliqué sur la blockchain, ce qui le rend immuable et transparent. Solidity nous donne les outils pour définir les règles, la logique et les données de ces contrats.

Syntaxe et Types de Données

Chaque fichier Solidity commence par une déclaration de version, appelée pragma. Cela indique au compilateur quelle version du langage utiliser, évitant ainsi des problèmes de compatibilité. Ensuite, on définit le contrat lui-même avec le mot-clé contract.

// Indique une version compatible du compilateur
pragma solidity ^0.8.0;

// Définit un contrat nommé 'MonContrat'
contract MonContrat {
    // Le code du contrat vient ici
}

À l'intérieur d'un contrat, nous déclarons des variables d'état, qui stockent des données sur la blockchain. Solidity est un langage à typage statique, ce qui signifie que le type de chaque variable doit être spécifié lors de sa déclaration. Voici les types de données les plus courants :

  • uint et int : Pour les nombres entiers. uint signifie entier non signé (positif uniquement), tandis que int est un entier signé (positif ou négatif).
  • bool : Pour les valeurs booléennes, qui ne peuvent être que true ou false.
  • string : Pour les chaînes de caractères, comme du texte.
  • address : Un type spécial pour stocker les adresses de comptes Ethereum (20 octets). C'est fondamental pour interagir avec d'autres comptes ou contrats.
pragma solidity ^0.8.0;

contract TypesDeDonnees {
    uint public nombrePositif = 123;
    int public nombreSigne = -456;
    bool public estVrai = true;
    string public message = "Bonjour le monde !";
    address public proprietaire = 0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2;
}

Contrôler le Flux d'Exécution

Comme dans la plupart des langages, nous avons besoin de structures pour contrôler le déroulement de notre code. Solidity utilise des instructions conditionnelles et des boucles pour exécuter de la logique complexe.

Les instructions if et else permettent d'exécuter du code uniquement si une certaine condition est remplie.

function verifierAge(uint _age) public pure returns (string memory) {
    if (_age >= 18) {
        return "Majeur";
    } else {
        return "Mineur";
    }
}

Les boucles sont utilisées pour répéter des actions. La boucle for est idéale lorsque vous savez combien de fois vous voulez répéter une action. La boucle while continue tant qu'une condition reste vraie.

function compterJusqua(uint _nombre) public pure returns (uint) {
    uint somme = 0;
    for (uint i = 1; i <= _nombre; i++) {
        somme += i;
    }
    return somme;
}

Attention : Les boucles dans les contrats intelligents doivent être utilisées avec prudence. Une boucle qui s'exécute trop de fois peut consommer beaucoup de gaz (les frais de transaction sur Ethereum) et potentiellement échouer.

Visibilité des Données et Fonctions

La visibilité définit qui peut accéder à vos variables et fonctions. C'est un concept de sécurité essentiel en Solidity. Une mauvaise gestion de la visibilité peut exposer votre contrat à des attaques. Il existe quatre niveaux de visibilité.

public

adjective

Accessible depuis n'importe où : à l'intérieur du contrat, par les contrats dérivés et depuis l'extérieur. Pour les variables d'état, Solidity crée automatiquement une fonction 'getter' pour y accéder.

private

adjective

Accessible uniquement depuis le contrat qui les définit. Ni les contrats dérivés ni les acteurs externes ne peuvent y accéder.

internal

adjective

Similaire à private, mais également accessible par les contrats qui en héritent.

external

adjective

Ne peut être appelé que depuis l'extérieur du contrat. C'est souvent plus efficace en termes de gaz pour les fonctions qui reçoivent de grandes quantités de données.

Le choix de la bonne visibilité est crucial pour la sécurité et l'optimisation des coûts de gaz de votre contrat.

pragma solidity ^0.8.0;

contract Visibilite {
    // Accessible par tout le monde, un getter est créé
    string public messagePublic = "Visible par tous";

    // Accessible seulement dans ce contrat
    string private messagePrive = "Secret";

    // Accessible dans ce contrat et les contrats dérivés
    uint internal nombreInterne = 42;

    // Fonction appelable uniquement depuis l'extérieur
    function actionExterne() external pure returns (string memory) {
        return "Action externe effectuée";
    }

    // Fonction appelable en interne et en externe
    function actionPublique() public view returns (string memory) {
        // On peut appeler une fonction privée depuis une fonction publique
        return messagePrive;
    }
}
VisibilitéContrat lui-mêmeContrats dérivésAppels externes
public✔️✔️✔️
external❌❌✔️
internal✔️✔️❌
private✔️❌❌

Maintenant que vous connaissez les bases, testons vos connaissances.

Quiz Questions 1/5

Quelle est la fonction principale du langage de programmation Solidity ?

Quiz Questions 2/5

À quoi sert la directive pragma au début d'un fichier Solidity ?

Vous avez maintenant une base solide pour commencer à explorer le monde des contrats intelligents. Ces concepts fondamentaux sont les piliers sur lesquels reposent toutes les applications décentralisées complexes.