Introduktion til Javascript and Solidity-Part 2: Solidity

I den første del tacklede vi JavaScript og viste dig det grundlæggende i programmeringssproget. I del 2 vil vi tale om soliditet, og hvordan du kan bruge dette programmeringssprog til din fordel. Før vi begynder med kodningsdelen, nogle grundlæggende om soliditet.

Soliditet – En introduktion

For alle, der ønsker at lære at lave DAPP’er (decentrale applikationer) eller komme ind i ICO-spillet, er læring om soliditet et absolut must. Solidity blev udviklet af Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai og flere tidligere Ethereum-kernebidragydere for at muliggøre skrivning af smarte kontrakter på blockchain-platforme som Ethereum.

Soliditet er beregnet til at være et målrettet slanket, løst skrevet sprog med en syntaks, der ligner JavaScript. Du kan tjekke Solidity Docs lige her.

Ved hjælp af Solidity vil du kode smarte kontrakter, der skal udføres i Ethereum Virtual Machine aka EVM. Ethereum-udviklere nævner en bestemt mængde gas, som tildeles deres kontrakter. Hver kontraktlinje kræver en vis mængde gas at udføre. Gasgrænsen skal være nok til, at kontrakten kan udføres fuldstændigt.

Når det er sagt, lad os begynde at kode.

Remix – IDE

Vi skal udføre vores koder på Remix. Klik her at gå til Remix-webstedet. Remix er et miljø i browseren, hvor du kan udføre dine smarte kontrakter på en test blockchain. Dette blev oprettet af Ethereum Foundation selv, så du kan begynde at udvikle kontrakter, når og når du vil.

Så i det øjeblik du går på dette websted, vil du se denne skærm:

Introduktion til Javascript and Solidity-Part 2: Solidity

Nu kan dette brugergrænseflade være ekstremt skræmmende, når du ser på det for første gang. Lad os dog opdele det sektion for sektion. Vi vil gå fra venstre.

Introduktion til Javascript and Solidity-Part 2: Solidity

Venstre side af browseren har alle de kontrakter, som du i øjeblikket arbejder på.

Næste du har dette:

Introduktion til Javascript and Solidity-Part 2: Solidity

Dette er redaktøren, hvor du faktisk skal kode. Som standard har Remix-brugergrænsefladen den smarte afstemningskontrakt, som du kan ignorere indtil videre. Det er ikke nødvendigt at komme ind på dette.

Derefter har du:

Introduktion til Javascript and Solidity-Part 2: Solidity

Dette er programloggen.

Eventuelle fejl, du møder under kodning, og alle output fra dit program vil blive beskrevet i denne log.

På højre side har du:

Introduktion til Javascript and Solidity-Part 2: Solidity

På højre side har du den sektion, der skal udføre det meste af arbejdet. Som standard vil det være på “Kompilér fanen”, men det er på “Kør fanen”, hvor du skal udføre det meste af arbejdet.

Introduktion til Javascript and Solidity-Part 2: Solidity

Miljø: Der er tre miljøer, hvor du kan udføre dine smarte kontrakter, som er: JavaScript VM, Injected Web3 og Web3 Provider.

Konto: Der er fem konto-adresser, som du kan bruge som ejer af denne kontrakt. Hver adresse har 100 testether-tokens knyttet til sig.

Introduktion til Javascript and Solidity-Part 2: Solidity

Gasgrænse: Den samlede gasgrænse, der er tildelt til udførelsen af ​​denne smarte kontrakt.

Værdi: Hvor meget Ether-tokens du vil give til dine transaktioner.

Dette skulle være nok for nu. Lad os komme i gang med nogle enkle, grundlæggende programmer.

Datatyper i fasthed

Lad os først dække de datatyper, som du vil bruge i soliditet. I datalogi og computerprogrammering er en datatype eller simpelthen en klassificering af data, der fortæller compileren eller tolken, hvordan programmøren har til hensigt at bruge dataene.

Er dataene et heltal eller en streng eller en matrix?

Den måde, compileren tager disse beslutninger på, er ved at se på datatypen.

Så lad os først kontrollere heltal datatyper, som du vil have i soliditet:

  • Normal heltalsdeklaration kaldet “int”, som går fra -128 til 127
  • Usigneret heltal “uint”, der går fra 0-255 og ikke gemmer nogen negative værdier

Det næste har vi boolsk datatyper, der kun gemmer “sand” eller “falsk”. For at erklære boolske værdier gør du dette: bool a;

Derefter har du det Strenge og Bytes.

Du kan bruge streng i soliditet som dette: strengnavn. Strenge lagres som en række værdier i soliditet.

Bytes er en række bytes, der går fra 1-32 tegn. Så hvad er forskellen mellem strenge og byte?

Dokumentation om soliditet siger:

Som tommelfingerregel skal du bruge bytes til rå byte-data med vilkårlig længde og streng til data om vilkårlig længde (UTF-8). Hvis du kan begrænse længden til et bestemt antal byte, skal du altid bruge en af ​​byte1 til bytes32, fordi de er meget billigere.

Næste, har vi noget sejt kaldet “enum”. Enums er en måde at oprette en brugerdefineret type i soliditet på. Sådan erklærer du dem:

enum Handling {FJERN, OPDATER}

 Så hvordan bruger du dem i programmet?

Handling myAction = Action.UPDATE;

Du opretter en variabel af typen Handling, som er navnet på den enum, som vi har brugt i eksemplet ovenfor. Og så tildel dem simpelthen en handling.

Du kan læse soliditetsdokumenterne for at få en mere dybtgående viden om forskellige datatyper.

Grundlæggende programmer

# 1 Hej Verden

pragmasoliditet ^ 0.4.19;

//Afsnit 1

kontrakt min første kontrakt {

streng offentlig hilsen;

adresse offentlig ejer

begivenhed GreetingChanged (streng oldGreeting, streng newGreeting);

// afsnit 2

funktion myfirstcontract (streng _hilsen) {

hilsen = _hilsen;

ejer = msg.sender;

}

// afsnit 3

funktions sætGreeting (streng _greeting) {

kræve (ejer == msg.sender);

GreetingChanged (hilsen, _hilsen);

hilsen = _hilsen;

}

}

Så vi har opdelt den smarte kontrakt i tre sektioner. Lad os se på hvert afsnit og se, hvad der foregår derinde.

Afsnit 1

// afsnit 1b>

 

<b>pragmasoliditet ^ 0.4.19; b>

&nbsp;

<b>indgå min første kontrakt {b>

<b>    b>

<b>    streng offentlig hilsen b>

<b>    adresse offentlig ejer b>

<b>    b>

<b>    begivenhed GreetingChanged (streng oldGreeting, streng newGreeting); b>

“Pragmasoliditet ^ 0.4.19” viser, at vi bruger en version af 0.4.19 af soliditeten. “^” Sørger også for, at vores program også udføres på højere versioner.

“Kontrakt myfirstcontract” erklærer vores kontrakt, som vi har kaldt “myfirstcontract”.

Derefter erklærer vi en streng kaldet “hilsen”, som vi vil bruge til at gemme vores besked. Denne streng er en “offentlig” streng. Vi erklærer også en offentlig variabel med navnet “ejer” af typen adresse for at gemme adressen til ejeren af ​​kontrakten.

Fordelen ved at bruge en “offentlig” variabel er, at den automatisk får en “getter” -funktion tildelt dem. En getter-funktion hjælper med at få adgang til værdien af ​​en variabel, mens en “setter” -funktion giver dig mulighed for at ændre værdien.

Derefter har vi en begivenhed kaldet “GreetingChanged”. Denne begivenhed sørger for, at ændringen sendes, når som helst der sker ændringer i hilsenen.

Afsnit 2

// afsnit 1b>

&nbsp;

<b>pragmasoliditet ^ 0.4.19; b>

&nbsp;

<b>indgå min første kontrakt {b>

<b>    b>

<b>    streng offentlig hilsen b>

<b>    adresse offentlig ejer b>

<b>    b>

<b>    begivenhed GreetingChanged (streng oldGreeting, streng newGreeting); b>

I dette afsnit skal vi erklære en konstruktør. Som du måske har bemærket, deler konstruktøren det samme navn som kontrakten. Konstruktørens job er at initialisere variablerne under runtime. Konstruktøren tager “_hilsen” som en parameter og bruger den til at initialisere “hilsen”. Samtidig gemmes adressen på den person, der sender parameteren, i ejeren. Da konstruktøren kun udfører i starten af ​​kørselstiden, er den person, hvis adresse bliver gemt, kontraktopretteren.

Afsnit 3

// afsnit 3

funktions sætGreeting (streng _greeting) {

kræve (ejer == msg.sender);

GreetingChanged (hilsen, _hilsen);

hilsen = _hilsen;

}

I det tredje afsnit har vi setterfunktionen, som hjælper os med at ændre værdierne i variablerne. Som parameter tager denne funktion den nye hilsen, hvis en ændring er påkrævet.

Så hvad sker der inde i funktionen?

Vi ønsker at introducere adgangskontrol til programmet. Dette er grunden til, at vi kontrollerer, om den, der foretager ændringen, er ejer af kontrakten eller ej. Som vi vil se senere, hvis en anden forsøger at foretage en ændring, vil compileren kaste en undtagelse og returnere en fejl.

Så hvis denne betingelse er opfyldt, udløses begivenheden GreetingChanged, og værdien af ​​”hilsen” opdateres med “_hilsen”.

Okay, så lad os nu sammensætte programmet. Gem dit program og vælg “myfirstcontract” her:

Introduktion til Javascript and Solidity-Part 2: Solidity

Klik derefter på “Implementér” for at udføre kontrakten. I det øjeblik du gør det, skal du bemærke, hvad der sker i loggen.

Introduktion til Javascript and Solidity-Part 2: Solidity

Du ser denne besked?

Det viser, at udførelsen var vellykket. Kan du også se den nedpiletast ud for Debug-knappen? Klik på det, så åbnes detaljerne for transaktionerne:

Introduktion til Javascript and Solidity-Part 2: Solidity

Status: Viser, at transaktionen er lykkedes

Transaktion Hash: Transaktionens unikke hash. Det viser transaktions-id’et.

Kontraktadresse: Adressen til den smarte kontrakt. Hver gang en kontrakt er implementeret med succes, får den tildelt en adresse, som sorta fungerer som kontrakt-ID’et.

Fra: Adressen til ejeren af ​​den kontrakt, vi har valgt

Til: Viser, at konstruktøren har genereret variablerne.

Gas: Den øvre grænse for den gas, som vi har indstillet på forhånd

Transaktionsomkostninger: Hvor meget gas det kostede at sende kontrakten til blockchain.

Udførelsesomkostninger: Hvor meget gas det kostede at udføre kontrakten.

Hash: Transaktionens hash .

Indgang: Dette er den kompilerede soliditetskode, der faktisk læses af Ethereum Virtual Machine.

Dekodet input: Det input, der gives til kontrakten, der sendes via parametrene.

Logfiler: Viser eventuelle begivenheder, som kontrakten kan have genereret.

Værdi: Da kontrakten ikke fik nogen Ether-tokens af os, viser den 0 wei.

Ok, nu vil vi have dig til at fokusere på højre side af din skærm. Ser du dette?

Introduktion til Javascript and Solidity-Part 2: Solidity

Ved siden af ​​feltet “Konto” vil du se, at adressen har lidt mindre end 100 Ether-tokens. Dette viser, at denne meget Ether blev brugt til at implementere kontrakten.

Klik på fanen under Implementerede kontrakter, og den afslører dette:

Introduktion til Javascript and Solidity-Part 2: Solidity

I denne:

  • “Hilsen” og “ejer” er getterfunktioner, der er oprettet som standard på grund af variablerne blev erklæret som “offentlige”.
  • “SetGreeting” er en setterfunktion, hvor du kan indtaste dataene.

Da “setGreeting” indeholder en strengparameter, skal du indtaste dataene med dobbelt anførselstegn. Helt sådan her:

Introduktion til Javascript and Solidity-Part 2: Solidity

Når du har indtastet dataene, skal du trykke på knappen “setGreeting”:

Introduktion til Javascript and Solidity-Part 2: Solidity

Der er to felter, som vi vil have dig til at fokusere på:

Dekodet input: Viser den inputstreng, vi har givet.

Logfiler: Opretter en begivenhed, der viser, at værdien af ​​”hilsen” er ændret.

Okay, lad os nu klikke på knappen “hilsen” på getter-funktionen:

Introduktion til Javascript and Solidity-Part 2: Solidity

Det giver dig straks værdien af ​​hilsenvariablen.

Når du tjekker logfiler, vil du se følgende:

Introduktion til Javascript and Solidity-Part 2: Solidity

Se feltet “dekodet output”, og du vil se “Hello World” der.

Tilsvarende skal du blot klikke på knappen “ejer”:

Introduktion til Javascript and Solidity-Part 2: Solidity

Det viser værdien af ​​ejerens adresse. Nu når du tjekker logfilerne:

Introduktion til Javascript and Solidity-Part 2: Solidity

Det dekodede output viser adressen på ejeren af ​​kontrakten.

Lad os nu gøre noget. Lad os vælge en anden adresse i feltet Konto:

Introduktion til Javascript and Solidity-Part 2: Solidity

Når du ændrer adresse, skal du prøve at komme til at indtaste en ny streng i setter-funktionen, du får følgende besked i loggen:

Introduktion til Javascript and Solidity-Part 2: Solidity

Denne fejl kommer, fordi dette fejler den adgangskontrol, vi lægger i vores kode. Husk denne kodelinje:

kræve (ejer == msg.sender);

Dette sørger for, at ingen anden adresse bortset fra ejeren kan ændre data i kontrakten.

# 2 Navn og alder

//Afsnit 1

pragmasoliditet ^ 0.4.19;

kontrakt mysecondcontract {

streng privat navn;

uint privat alder

// afsnit 2

funktions sætnavn (streng nyt navn) {

navn = nyt navn;

}

funktion getName () returnerer (streng) {

returnere navn;

}

// afsnit 3

function setAge (uint newAge) {

alder = newAge;

}

funktion getAge () returnerer (uint) {

returalder

}

}

Afsnit 1

pragmasoliditet ^ 0.4.19;

kontrakt mysecondcontract {

streng privat navn;

uint privat alder

Vi har erklæret en smart kontrakt med navnet “mysecondcontract”. Dette har to private variabler. En streng kaldet “navn” og et usigneret heltal (et ikke-negativt heltal) kaldet “alder”.

Afsnit 2

funktions sætnavn (streng nyt navn) {

navn = nyt navn;

}

funktion getName () returnerer (streng) {

returnere navn;

}

I dette afsnit har vi setter- og getter-funktionen til navnevariablen. Den første del er en normal setterfunktion, der tager en parameter til at initialisere navnevariablen.

Den anden del er en getter-funktion, som hjælper ejeren med at få adgang til “navn” -variablen.

Afsnit 3

function setAge (uint newAge) {

alder = newAge;

}

funktion getAge () returnerer (uint) {

returalder

}

Denne del definerer en setter- og getter-funktion til alderen.

Lad os udføre kontrakten og angive alder som “28”. Loggen ser nu sådan ud:

Introduktion til Javascript and Solidity-Part 2: Solidity

Som du kan se, afspejles alderen i “dekodet input”.

Lad os nu indstille navnet som “Max”.

Nu viser det afkodede indtastningsfelt navnet “Max”.

Vi kan nu kontrollere alderens getterfunktion for at se output:

Introduktion til Javascript and Solidity-Part 2: Solidity

Outputfeltet viser alderen.

Nu, for getter-funktionen af ​​navnet:

Introduktion til Javascript and Solidity-Part 2: Solidity

Nu viser det det dekodede output, dvs. navnet.

Arv og fasthed

Arv er et af de mest kraftfulde værktøjer til programmering. I soliditet hjælper det dig med at udlede en smart kontrakt fra en ældre smart kontrakt. Formatet ser sådan ud:

kontrakt A {

——-

}

kontrakt B er A {

——

}

Nøgleordet “er” indebærer, at kontrakt B arver værdi fra kontrakt A. Nu kan kontrakt A definere, hvilke af dens elementer den vil dele med kontrakt B via adgangsmodifikatorer. Soliditet giver dig fire adgangsmodifikatorer:

  • Privat: Elementet arves ikke, og det kan heller ikke tilgås af eksterne elementer.
  • Offentlig: Elementet kan nedarves og tilgås af eksterne elementer.
  • Indre: Elementet kan nedarves, men det kan ikke tilgås af eksterne elementer
  • Ekstern: Elementet kan ikke nedarves, men det kan tilgås af eksterne elementer.

Ok, nu hvor vi har nævnt alt det, lad os gøre noget arv på vores kontrakt. Vi ændrer mysecondcontract-koden.

pragmasoliditet ^ 0.4.19;

//Afsnit 1

interface regulator {

funktion checkValue (uint beløb) returnerer (bool);

funktionslån () returnerer (bool);

}

# sektion 2

kontrakt Bank er regulator {

uint privat værdi

funktion Bank (uint beløb) {

værdi = beløb;

}

funktionsindskud (uint beløb) {

værdi + = beløb;

}

udtræk af funktion (uint beløb) {

hvis (checkValue (beløb)) {

værdi – = beløb;

}

}

funktionsbalance () returnerer (uint) {

returværdi

}

funktion checkValue (uint beløb) returnerer (bool) {

returværdi >= beløb;

}

funktionslån () returnerer (bool) {

returværdi > 0;

}

}

// afsnit 3

kontrakt mysecondcontract er Bank {

streng privat navn;

uint privat alder

funktions sætnavn (streng nyt navn) {

navn = nyt navn;

}

funktion getName () returnerer (streng) {

returnere navn;

}

function setAge (uint newAge) {

alder = newAge;

}

funktion getAge () returnerer (uint) {

returalder

}

}

Afsnit 1

Lad os se på den pågældende kode:

interface regulator {

funktion checkValue (uint beløb) returnerer (bool);

funktionslån () returnerer (bool);

}

Lad os se på den pågældende kode:

interface regulator {

funktion checkValue (uint beløb) returnerer (bool);

funktionslån () returnerer (bool);

}

Den første ting, som vi har erklæret, er en grænseflade. Interfacet hjælper dig med at definere funktionerne uden faktisk at afsløre, hvordan de skal arbejde internt. Deres interne mekanismer skal afsløres i de andre kontrakter.

Afsnit 2

kontrakt Bank er regulator {

uint privat værdi

funktion Bank (uint beløb) {

værdi = beløb;

}

funktionsindskud (uint beløb) {

værdi + = beløb;

}

udtræk af funktion (uint beløb) {

hvis (checkValue (beløb)) {

værdi – = beløb;

}

}

funktionsbalance () returnerer (uint) {

returværdi

}

funktion checkValue (uint beløb) returnerer (bool) {

returværdi >= beløb;

}

funktionslån () returnerer (bool) {

returværdi > 0;

}

}

Så vi har erklæret en kontrakt kaldet bank, som arver dens værdier fra grænsefladen. Den første ting, vi laver, er at erklære en konstruktør, der initialiserer den variable værdi.

Derefter har vi et par sætfunktioner kaldet “træk” og “indbetaling”, som hjælper kontrakten med at trække og indbetale fra brugerens konto.

Se især på tilbagetrækningsfunktionen.

udtræk af funktion (uint beløb) {

hvis (checkValue (beløb)) {

værdi – = beløb;

}

Før vi kan trække, kalder funktionen checkValue-funktionen, som den har arvet fra grænsefladen for at sikre, om brugeren har nok værdi på deres konto til at trække pengene ud eller ej.

Efter setterfunktionerne har vi getterfunktionerne, som returnerer i rækkefølge:

  • Saldoen på brugerens konto
  • Uanset om brugeren har penge nok til en tilbagetrækning eller ej.
  • Hvis brugeren er åben for et lån eller ej. Til dette kontrollerer vi bare, om brugerens saldo er > 0 eller ej.

Afsnit 3

kontrakt mysecondcontract er Bank {

streng privat navn;

uint privat alder

funktions sætnavn (streng nyt navn) {

navn = nyt navn;

}

funktion getName () returnerer (streng) {

returnere navn;

}

function setAge (uint newAge) {

alder = newAge;

}

funktion getAge () returnerer (uint) {

returalder

}

}

Denne del af kontrakten er den samme som før. Den eneste forskel er, at det arver ejendomme fra bankkontrakten.

Import af faste stoffer og biblioteker

Dernæst er vi nødt til vigtige soliditetsfunktioner, som du skal være fortrolig med, import og biblioteker. Til dette skal vi oprette to separate kontraktfiler, som vi vil kalde “library.sol” og “testLibrary.sol”.

Vores bibliotek.sol-program ser sådan ud:

pragmasoliditet ^ 0.4.19;

kontraktbiblioteker {

funktionstest () {}

}

Og testBibliotek ser sådan ud:

pragmasoliditet ^ 0.4.19;

importere "browser / bibliotek.sol";

kontrakt testBibliotek er biblioteker {

}

TestLibrary-programmet importerer simpelthen biblioteksfilen, der er gemt på placeringen: browser / library.sol. Alle soliditetsprogrammer er som standard gemt i browsermappen.

Adgang til modifikatorer og tilbagefaldsfunktioner

Adgangsmodifikatorer og tilbagefaldsfunktioner er sjove små værktøjer, som du kan bruge til at krydre dine kontrakter. Lad os begynde med reservefunktioner. Tjek følgende kode:

pragmasoliditet ^ 0.4.19;

kontrakt testTransaktion {

begivenhed SenderLogger (adresse);

begivenhed ValueLogger (uint);

funktion () betales {

SenderLogger (msg.sender);

ValueLogger (msg.værdi);

}

}

Dette er en simpel smart kontrakt, der lader dig udtrække detaljerne i en transaktion. Dybest set, hvis nogen sender Ether til denne kontrakt, vil denne kontrakt udtrække:

  • Afsenderens adresse
  • Mængden af ​​ether, de sender.

Tilbagefaldsfunktionen er lige her:

 funktion () betales {

SenderLogger (msg.sender);

ValueLogger (msg.værdi);

}

Som du kan se, har funktionen intet navn, og du kan kun sætte en reservefunktion i hver kontrakt. Ideen er at gøre det muligt for enhver at komme i kontakt med kontrakten og sende Ether-tokens til den.

Så lad os udføre programmet og se nogle data. Vi vil implementere kontrakten. Sæt 1 Ether i feltet “værdi” og tryk på knappen “tilbagefald”.

Introduktion til Javascript and Solidity-Part 2: Solidity

Så lad os nu kontrollere logfiler.

Introduktion til Javascript and Solidity-Part 2: Solidity

Det sidste felt i tabellen i værdifeltet, der viser mængden af ​​Ether in wei, der er sendt til kontrakten.

Okay, så lad os nu sætte nogle modifikatorer i programmet og ændre tingene rundt.

pragmasoliditet ^ 0.4.19;

kontrakttransaktion {

begivenhed SenderLogger (adresse);

begivenhed ValueLogger (uint);

adresse privat ejer

modifikator isOwner {

kræve (ejer == msg.sender);

_;

}

modifikator validValue {

hævde (msg.værdi >= 1 ether);

_;

}

funktionstransaktion () {

ejer = msg.sender;

}

funktion () betales isOwner validValue {

SenderLogger (msg.sender);

ValueLogger (msg.værdi);

}

}

Ok, så denne kontrakt er den samme som den forrige. Vi vil stadig udtrække transaktionsoplysninger. Vi har dog tilføjet følgende to betingelser:

  • Kun ejeren af ​​kontrakten kan sende transaktionen
  • Transaktionen skal være mindst 1 Ether

Så lad os se på en modifikator og se, hvordan vi udfører den:

modifikator isOwner {

       kræve (ejer == msg.sender);

       _;

   }

Så hvad gør vi lige her??

Vi har erklæret en modifikator, som grundlæggende er en brugerdefineret adgangskontrolfunktion, der kører en “krævende” funktion for at sikre, at kun ejeren kan bruge kontrakten.

Bemærk du også “_;”?

Dette indikerer, at efter at adgangsmodifikatoren er udført, skal den funktion, hvis indgang den beskytter, også køre.

Lad os tjekke vores næste modifikator:

modifikator validValue {

       hævde (msg.værdi >= 1 ether);

       _;

   }

Dette er igen en ligetil modifikator, der kontrollerer, om værdien, der sendes til kontrakten, er større end 1 ether eller ej.

Ok, så nu hvor vi har defineret disse modifikatorer, hvordan skal vi nøjagtigt bruge dem til funktionen? Nå, lad os tjekke det ud:

funktion () betales isOwner validValue {

       SenderLogger (msg.sender);

       ValueLogger (msg.værdi);

   }

Se vores tilbagefaldsfunktion nu? Vi har tilføjet adgangsmodifikatorerne til funktionsoverskriften for at begrænse adgangen til den. Lad os nu køre kontrakten gennem Remix og se, hvad vi får her.

Lad os tilføje en ether til værdifeltet og se, hvad vi får.

Introduktion til Javascript and Solidity-Part 2: Solidity

Loggen viser:

  • Afsenderens adresse
  • Værdien af ​​Ether sat inde i kontrakten

Hvad sker der nu, hvis vi:

  • Send mindre end 1 ether
  • Send ether fra en anden adresse

Mindre end 1 ether

Vi sendte 0,2 Ether i værdifeltet, og programmet gav straks en fejl:

Introduktion til Javascript and Solidity-Part 2: Solidity

Fra en anden adresse

Vi sendte 1 Ether fra en anden adresse. Endnu en gang får vi en fejl:

Introduktion til Javascript and Solidity-Part 2: Solidity

Strukturer og kortlægning i fasthed

Før vi afslutter denne vejledning, vil vi gøre dig bekendt med yderligere to begreber, som du vil løbe ind under kodning.

  • Strukturer
  • Kortlægning

Strukturer er objekter, der mangler metoder. De definerer kun variablerne.

Kortlægning i soliditet er ligesom en hash-tabel, som initialiseres næsten, så hver potentiel nøgle eksisterer. Kortlægning kan erklæres således:

kortlægning (A => B).

A = Kan være af enhver type bortset fra kortlægning, array, enum, kontrakt og struct.

B = Kan være af enhver type (inklusive kortlægning).

Lad os udføre et program, der indeholder begge disse funktioner:

pragmasoliditet ^ 0.4.19;

kontrakt showmap {

//Afsnit 1

struct-konto {

uint balance

}

Konto min konto;

funktion structFunc () {

myAccount.balance = 100;

}

// afsnit 2

kortlægning (adresse => Konto) _konti;

funktion () betales {

_accounts [msg.sender] .balance + = msg.value;

}

funktion getBalance () returnerer (uint) {

returnere _konti [msg.sender] .balance;

}

}

Afsnit 1

Så vi har erklæret en struktur med navnet Konto, der har en uint datatype med navnet “balance”. Vi initialiserede derefter en variabel med navnet myAccount af typen Account og brugte derefter structFunc () -funktionen til at tildele en værdi på 100 til myAccount.balance.

Afsnit 2

Ved at bruge kortlægningsnøgleordet kortlægger vi adresser til vores kontostruktur og kalder det “_konti”.

Vi har derefter en tilbagefaldsfunktion til at tilføje den ether, som brugeren har givet den, i deres balance. Funktionen getBalance () returnerer derefter værdien af ​​den opdaterede saldo til brugeren.

Lad os se på dette i aktion.

Vi sender 10 Ether til den smarte kontrakt.

Så ved hjælp af reservefunktionen sendte vi 10 Ether til kontoen, som du kan se i loggen her:

Introduktion til Javascript and Solidity-Part 2: Solidity

Så hvis vi får balance lige nu, er det hvad vi får:

Introduktion til Javascript and Solidity-Part 2: Solidity

Bemærk feltet “dekodet output” og bemærk, hvordan balancen reflekteres som 10 Ether.

Introduktion til Javascript and Solidity-Part 2: Solidity

Lad os nu sende 10 mere Ether til kontrakten via tilbagefaldsfunktionen og lad os kontrollere saldoen igen via getBalance ().

Hvis du ser getBalance () -feltet, vil du bemærke, at balancen afspejler 20 Ether.

Konklusion

Der er meget mere til soliditet end hvad vi har dækket her. I den nærmeste fremtid vil vi vise dig, hvordan du kan oprette din egen kryptokurrency ved hjælp af soliditet.

Men indtil videre, hvis du vil uddanne dig endnu mere, så tilmeld dig vores soliditetskurser. Vi har ekstremt veluddannede lærere, der vil guide dig gennem din rejse som udvikler.

Du kan også tjekke ud disse serier af videoer af “Hvad er soliditet”. De har fantastiske videoer, og størstedelen af ​​koden, der bruges her, er taget fra deres gitHub-side.

Formålet med disse to artikler var at give dig en introduktion til både JavaScript og soliditet. Vi håber, at du har dine grundlæggende klare nu for at påtage dig mere udfordrende programmer / kontrakter.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me