Cos'è la Solidità?

Solidity è il linguaggio di programmazione che si usa per scrivere, creare, e implementare contratti intelligenti. Se vuoi imparare contratti intelligenti, non puoi farlo senza capire e imparare la Solidità.

È stato inizialmente proposto nel 2014 da Gavin Wood, ma è stato successivamente sviluppato e lanciato da Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai, e diversi ex contributori principali di Ethereum, Solidity consente la creazione e la scrittura di contratti intelligenti su piattaforme blockchain come Ethereum, Ethereum classico, Tron, tra gli altri.

Serve come lingua principale sulla Virtual Machine (EVM) di Ethereum.

Simile a Javascript

Nella sua forma più elementare, è un “linguaggio vagamente dattiloscritto”. Il linguaggio funziona in modo molto simile a C e Javascript ma integra un supporto aggiuntivo per le variabili di stato, tipi di dati, e funzioni di programmazione.

Quando Wood lo progettò per la prima volta, ha detto che era per renderlo familiare e facile per gli sviluppatori web esistenti. A differenza di Javascript, Solidity ha tipizzazione statica e tipi di ritorno variadici.

Con Solidità, gli sviluppatori blockchain sono in grado di scrivere applicazioni che implementano la logica aziendale auto-applicativa (autogovernativa) incorporata negli smart contract. In parole povere, questo è ciò che consente ai contratti di essere autoeseguibili, non richiede coinvolgimento umano, una volta scritto il codice.

Per coloro che sono abili programmatori, questa lingua è abbastanza facile. Al laico, però, Ci vuole tempo e pazienza.

Comprensione della sintassi e dei tipi di dati generali

Solidity supporta tipi di valore generici, specificamente booleani, interi, indirizzi, letterali stringa, e modificatori. Esploriamo ciascuno.

booleani

Nell'informatica, Il tipo di dati booleano è un tipo di dati che ha due possibili valori:vero o falso. Questi valori hanno lo scopo di rappresentare i due valori di verità della logica e dell'algebra booleana. Per maggiori informazioni in merito, per favore clicca qui.

Gli operatori logici che restituiscono tipi di dati booleani:

• ! Negazione logica
• &&congiunzione logica, "e"
• || disgiunzione logica, "o"
• ==uguaglianza
• !=disuguaglianza

numeri interi

Solidity supporta int/unit rispettivamente per interi con segno e senza segno. Queste allocazioni di archiviazione possono essere di varie dimensioni. Parole chiave come uint8 e uint256 possono essere utilizzate per allocare una dimensione di archiviazione da 8 bit a 256 bit rispettivamente. Per impostazione predefinita, l'allocazione è di 256 bit. Questo è, uint e int possono essere usati al posto di uint256 e int256.

Gli operatori compatibili con i tipi di dati interi sono:

• Confronti:<=, <, ==, !=,> =,> . Questi sono usati per valutare bool.
• Operatori di bit:&, |, ^ bit a bit esclusivo 'o', ~ negazione bit a bit, "non".
• Operatori aritmetici:+, -, unario -, unario +, *, /, % resto, ** esponenziale, <> spostamento a destra.

L'EVM restituisce un'eccezione di runtime quando l'operatore modulo viene applicato allo zero di un'operazione di "divisione per zero".

Indirizzo

Un indirizzo può contenere un valore di 20 byte equivalente alla dimensione di un indirizzo Ethereum. Questi tipi di indirizzi vengono sottoposti a backup con membri che fungono da base del contratto.

Per maggiori informazioni sui “valori byte”, per favore clicca qui.

Letterali stringa

Una "stringa letterale" o stringa anonima, è un tipo di letterale in programmazione per la rappresentazione di un valore "stringa" all'interno del codice sorgente di un programma per computer. Per maggiori informazioni in merito, per favore clicca qui.

A differenza del linguaggio C, i valori letterali stringa in Solidity implicano zeri di valore finale. Questi possono essere rappresentati utilizzando virgolette singole o doppie --- "foo" o "bar".

Per esempio, "bar" rappresenterà un elemento a 3 byte, anziché quattro (4).

Allo stesso modo, con interi letterali, i letterali sono intrinsecamente convertibili, utilizzando il corrispondente fit--byte o stringa.

Modificatore

Nei contratti intelligenti, i modificatori contribuiscono a garantire la coerenza delle condizioni definite, prima di eseguire il codice. In altre parole, assicura che le condizioni siano adeguatamente definite, in modo da rischiare calcolo e quindi esecuzione imprecisi.

mappature

Solidity fornisce array di base, enumerazioni, operatori, e valori hash per creare una struttura dati, noti come "mapping". Questi vengono utilizzati per restituire i valori associati a una determinata posizione di archiviazione.

Un "array" è un'allocazione di memoria contigua di una dimensione definita dal programmatore dove se la dimensione è inizializzata come "K", e il tipo di elemento viene istanziato come "T", l'array può essere scritto come T [k].

Array dinamici

Gli array possono anche essere istanziati dinamicamente usando la notazione uint [ ] [6]. Ciò significa che verrà avviato un array dinamico con sei allocazioni di memoria contigue, mentre un array bidimensionale può essere inizializzato come arr [2] [4], dove i due indici mostrano le dimensioni della matrice.

Esempio di codice di solidità

solidità ragma> =0.5,0 <0,7.0;

contract Coin { // La parola chiave "public" rende variabili
// accessibile da altri contratti
indirizzo minatore pubblico;
mappatura (indirizzo => uint) bilanci pubblici; // Gli eventi consentono ai clienti di reagire a specifiche
// modifiche al contratto che dichiari
evento Inviato (indirizzo da, indirizzato a, unico importo); // Il codice costruttore viene eseguito solo quando il contratto
// è creato
costruttore() pubblico {
minter =msg.mittente; } // Invia una quantità di monete appena create a un indirizzo
// Può essere chiamato solo dal creatore del contratto
funzione menta (indirizzo destinatario, unico importo) pubblico {
require(msg.sender ==minter); require(importo <1e60); saldi[ricevitore] +=importo; } // Invia una quantità di monete esistenti
// da qualsiasi chiamante a un indirizzo
funzione invio (indirizzo destinatario, unico importo) pubblico {
require(importo <=saldi[msg.sender], "Equilibrio insufficiente."); saldi[msg.sender] -=importo; saldi[ricevitore] +=importo; emit Inviato (msg.sender, ricevitore, Quantità); } }