Qu'est-ce que la Solidité ?

Solidity est le langage de programmation utilisé pour écrire, créer, et mettre en œuvre des contrats intelligents. Si vous voulez apprendre les contrats intelligents, vous ne pouvez pas le faire sans comprendre et apprendre la Solidité.

Il a été initialement proposé en 2014 par Gavin Wood, mais a ensuite été développé et lancé par Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai, et plusieurs anciens contributeurs principaux d'Ethereum, Solidity permet la création et la rédaction de contrats intelligents sur des plateformes blockchain comme Ethereum, Ethereum Classique, Tron, entre autres.

Il sert de langage principal sur la machine virtuelle d'Ethereum (EVM).

Similaire à Javascript

Dans sa forme la plus basique, c'est un « langage vaguement typé ». Le langage fonctionne de manière très similaire à C et Javascript mais intègre un support supplémentaire pour les variables d'état, Types de données, et des fonctions de programmation.

Lorsque Wood a conçu cela pour la première fois, il a dit que c'était pour le rendre familier et facile pour les développeurs Web existants. Contrairement à Javascript, Solidity a un typage statique et des types de retour variadiques.

Avec Solidité, Les développeurs de blockchain sont capables d'écrire des applications qui implémentent une logique métier auto-applicable (autonome) incorporée dans des contrats intelligents. En clair, c'est ce qui permet aux contrats d'être auto-exécutables, ne nécessitant pas d'intervention humaine, une fois le code écrit.

Pour ceux qui sont des programmeurs qualifiés, cette langue est assez facile. Au profane, cependant, cela demande du temps et de la patience.

Comprendre la syntaxe et les types de données générales

Solidity prend en charge les types de valeur génériques, spécifiquement les booléens, entiers, adresses, littéraux de chaîne, et modificateurs. Explorons chacun.

Booléens

En informatique, Le type de données booléen est un type de données qui a deux valeurs possibles :vrai ou faux. Ces valeurs sont destinées à représenter les deux valeurs de vérité de la logique et de l'algèbre booléenne. Pour plus d'informations à ce sujet, cliquez ici s'il vous plait.

Les opérateurs logiques renvoyant des types de données booléens :

• ! Négation logique
• &&conjonction logique, "et"
• || disjonction logique, "ou"
• ==égalité
• !=inégalité

Entiers

Solidity prend en charge int/unit pour les entiers signés et non signés respectivement. Ces allocations de stockage peuvent être de différentes tailles. Des mots clés tels que uint8 et uint256 peuvent être utilisés pour allouer une taille de stockage de 8 bits à 256 bits respectivement. Par défaut, l'allocation est de 256 bits. C'est-à-dire, uint et int peuvent être utilisés à la place de uint256 et int256.

Les opérateurs compatibles avec les types de données entiers sont :

• Comparaisons :<=, <, ==, !=,> =,> . Ceux-ci sont utilisés pour évaluer à bool.
• Opérateurs binaires :&, |, ^ "ou" exclusif au niveau du bit, ~ négation au niveau du bit, "ne pas".
• Opérateurs arithmétiques :+, -, unaire -, unaire +, *, /, % restant, ** exponentiation, <> décalage à droite.

L'EVM renvoie une exception d'exécution lorsque l'opérateur de module est appliqué au zéro d'une opération « diviser par zéro ».

Adresse

Une adresse peut contenir une valeur de 20 octets équivalente à la taille d'une adresse Ethereum. Ces types d'adresses sont sauvegardés avec des membres qui servent de base de contrat.

Pour plus d'informations sur les « octets-valeurs », cliquez ici s'il vous plait.

Littéraux de chaîne

Un « littéral de chaîne » ou une chaîne anonyme, est un type de littéral en programmation pour la représentation d'une valeur « chaîne » dans le code source d'un programme informatique. Pour plus d'informations à ce sujet, cliquez ici s'il vous plait.

Contrairement au langage C, les littéraux de chaîne dans Solidity impliquent des zéros à la fin. Ceux-ci peuvent être représentés en utilisant des guillemets simples ou doubles --- "foo" ou "bar".

Par exemple, "bar" représentera un élément de 3 octets, plutôt que quatre (4).

De la même manière, avec des littéraux entiers, les littéraux sont convertibles par nature, en utilisant le fit--byte ou la chaîne correspondant.

Modificateur

Dans les contrats intelligents, les modificateurs permettent d'assurer la cohérence des conditions définies, avant d'exécuter le code. En d'autres termes, il s'assure que les conditions sont bien définies, au risque de fausser le calcul et donc l'exécution.

Mappages

Solidity fournit des tableaux de base, énumérations, les opérateurs, et des valeurs de hachage pour créer une structure de données, connu sous le nom de « cartographies ». Ceux-ci sont utilisés pour renvoyer des valeurs associées à un emplacement de stockage donné.

Un « tableau » est une allocation de mémoire contiguë d'une taille définie par le programmeur où si la taille est initialisée à « K », et le type d'élément est instancié comme "T", le tableau peut être écrit sous la forme T [k].

Tableaux dynamiques

Les tableaux peuvent également être instanciés dynamiquement en utilisant la notation uint [ ] [6]. Cela signifie qu'un tableau dynamique avec six allocations de mémoire contiguës sera lancé, tandis qu'un tableau à deux dimensions peut être initialisé comme arr [2] [4], où les deux indices indiquent les dimensions de la matrice.

Exemple de code de solidité

solidité ragma> =0,5.0 <0,7.0 ;

contract Coin { // Le mot-clé "public" fait des variables
// accessible depuis d'autres contrats
adresse publique monnayeur;
cartographie (adresse => uint) soldes publics; // Les événements permettent aux clients de réagir à des
// changements de contrat que vous déclarez
événement Envoyé (adresse de, Adressé à, montant uint); // Le code constructeur n'est exécuté que lorsque le contrat
// est créé
constructeur() public {
minter =msg.sender; } // Envoie un montant de pièces nouvellement créées à une adresse
// Ne peut être appelé que par le créateur du contrat
fonction menthe (adresse récepteur, uint montant) public {
require(msg.sender ==minter); exiger(montant <1e60); soldes[receveur] +=montant ; } // Envoie un montant de pièces existantes
// de n'importe quel appelant vers une adresse
fonction envoyer (adresse du destinataire, uint montant) public {
exiger(montant <=soldes[msg.sender], "Solde insuffisant."); soldes[msg.sender] -=montant ; soldes[receveur] +=montant ; émettre Envoyé (msg.sender, destinataire, montant); } }