Introduksjon til Javascript and Solidity-Part 2: Solidity

I den første delen taklet vi JavaScript og viste deg det grunnleggende i programmeringsspråket. I del 2 skal vi snakke om soliditet og hvordan du kan bruke dette programmeringsspråket til din fordel. Før vi begynner med kodingsdelen, noen grunnleggende om soliditet.

Solidity – En introduksjon

For alle som ønsker å lære å lage DAPPs (desentraliserte applikasjoner) eller komme inn i ICO-spillet, er å lære soliditet et absolutt must. Soliditet ble utviklet av Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai og flere tidligere Ethereum-kjerne bidragsytere for å muliggjøre skriving av smarte kontrakter på blockchain-plattformer som Ethereum.

Soliditet er ment å være et målrettet slanket, løst skrevet språk med en syntaks som ligner på JavaScript. Du kan sjekke ut Solidity Docs akkurat her.

Ved å bruke Solidity vil du kode smarte kontrakter som skal utføres i Ethereum Virtual Machine aka EVM. Ethereum-utviklere nevner en bestemt mengde gass som tildeles kontraktene deres. Hver linje i kontrakten krever en viss mengde gass å utføre. Gassgrensen bør være nok til at kontrakten kan gjennomføres helt.

Når det er sagt, la oss begynne å kode.

Remix – IDE

Vi skal utføre kodene våre på Remix. Klikk her å gå til Remix-nettstedet. Remix er et miljø i nettleseren der du kan utføre smarte kontrakter på en testblokkjede. Dette ble opprettet av Ethereum Foundation selv, slik at du kan begynne å utvikle kontrakter, når som helst.

Så øyeblikket du går på dette nettstedet, vil du se dette skjermbildet:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Nå kan dette brukergrensesnittet være ekstremt skremmende når du ser på det for første gang. La oss imidlertid dele den opp seksjon for seksjon. Vi skal gå fra venstre.

Introduksjon til Javascript and Solidity-Part 2: Solidity

Venstre side av nettleseren har alle kontraktene du jobber med.

Neste har du dette:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Dette er redaktøren der du faktisk skal kode. Som standard har Remix-brukergrensesnittet den smarte avstemningsavtalen som du kan ignorere for nå. Det er ikke nødvendig å komme inn på dette.

Etter det har du:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Dette er programloggen.

Eventuelle feil du møter under koding og alle utgangene til programmet ditt vil bli beskrevet i denne loggen.

På høyre side har du:

Introduksjon til Javascript and Solidity-Part 2: Solidity

På høyre side har du den delen som kommer til å gjøre det meste av arbeidet. Som standard vil det være på “Compile Tab”, men det er på “Run Tab” hvor du skal gjøre det meste av arbeidet.

Introduksjon til Javascript and Solidity-Part 2: Solidity

Miljø: Det er tre miljøer der du kan utføre smarte kontrakter, som er: JavaScript VM, Injected Web3 og Web3 Provider.

Regnskap: Det er fem kontoadresser du kan bruke som eier av denne kontrakten. Hver adresse har 100 testetertegn knyttet til seg.

Introduksjon til Javascript and Solidity-Part 2: Solidity

Gassgrense: Den totale gassgrensen som er tildelt for utførelsen av denne smarte kontrakten.

Verdi: Hvor mye Ether-tokens du vil gi for transaksjonene dine.

Dette burde være nok for nå. La oss komme i gang med noen enkle, grunnleggende programmer.

Datatyper i fasthet

For det første, la oss dekke datatypene du vil bruke i soliditet. I datavitenskap og dataprogrammering er en datatype eller ganske enkelt en klassifisering av data som forteller kompilatoren eller tolken hvordan programmereren har til hensikt å bruke dataene.

Er dataene et heltall eller en streng eller en matrise?

Måten kompilatoren tar disse beslutningene på er å se på datatypen.

Så, først, la oss sjekke heltall datatyper som du vil ha i soliditet:

  • Normal heltallerklæring kalt “int” som går fra -128 til 127
  • Usignert heltal “uint” som går fra 0-255 og ikke lagrer noen negative verdier

Neste har vi boolsk datatyper som bare lagrer “true” eller “false”. For å erklære boolske verdier gjør du dette: bool a;

Etter det har du Strenger og Bytes.

Du kan bruke streng i soliditet som dette: strengnavn. Strenger lagres som en rekke verdier i soliditet.

Bytes er en rekke bytes som går fra 1-32 tegn. Så hva er forskjellen mellom strenger og byte?

Soliditetsdokumentasjon sier:

Som tommelfingerregel bruker du byte for råbyte-data med vilkårlig lengde og streng for data med vilkårlig lengde (UTF-8). Hvis du kan begrense lengden til et visst antall byte, bruk alltid en av byte1 til bytes32 fordi de er mye billigere.

Neste gang har vi noe kult som heter “enum”. Enums er en måte å lage en brukerdefinert type i Solidity. Slik erklærer du dem:

enum Action {FJERN, OPPDATER}

 Så hvordan bruker du dem i programmet?

Handling myAction = Action.UPDATE;

Du oppretter en variabel av typen Handling, som er navnet på enummet som vi har brukt i eksemplet ovenfor. Og så tilordner de bare en handling.

Du kan les soliditetsdokumentene for å få en mer inngående kunnskap om ulike datatyper.

Grunnleggende programmer

# 1 Hello World

pragmasoliditet ^ 0.4.19;

//seksjon 1

kontrakt min første kontrakt {

streng offentlig hilsen;

adresse offentlig eier;

event GreetingChanged (streng oldGreeting, string newGreeting);

// seksjon 2

funksjon myfirstcontract (streng _hilsen) {

hilsen = _hilsen;

eier = msg.sender;

}

// seksjon 3

funksjonssett Hilsen (streng _hilsen) {

krever (eier == msg.sender);

GreetingChanged (hilsen, _hilsen);

hilsen = _hilsen;

}

}

Så vi har delt den smarte kontrakten i tre seksjoner. La oss se på hver av seksjonene og se hva som skjer der inne.

Seksjon 1

// avsnitt 1b>

 

<b>pragmasoliditet ^ 0.4.19; b>

&nbsp;

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

<b>    b>

<b>    streng offentlig hilsen; b>

<b>    adresse offentlig eier; b>

<b>    b>

<b>    event GreetingChanged (streng oldGreeting, string newGreeting); b>

“Pragmasoliditet ^ 0.4.19” viser at vi bruker en 0.4.19-versjon av soliditeten. “^” Sørger også for at programmet vårt også kjøres på høyere versjoner.

“Kontrakt myfirstcontract” erklærer kontrakten vår som vi har kalt “myfirstcontract”.

Etter det erklærer vi en streng kalt “hilsen” som vi vil bruke til å lagre meldingen. Denne strengen er en “offentlig” streng. Vi erklærer også en offentlig variabel kalt “eier” av typen adresse for å lagre adressen til eieren av kontrakten.

Fordelen med å bruke en “offentlig” variabel er at den automatisk får en “getter” -funksjon tildelt dem. En getter-funksjon hjelper deg med å få tilgang til verdien til en variabel, mens en “setter” -funksjon lar deg endre verdien.

Etter det har vi et arrangement kalt “GreetingChanged”. Denne hendelsen sørger for at endringen sendes når som helst det skjer en endring i hilsenen.

Avsnitt 2

// avsnitt 1b>

&nbsp;

<b>pragmasoliditet ^ 0.4.19; b>

&nbsp;

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

<b>    b>

<b>    streng offentlig hilsen; b>

<b>    adresse offentlig eier; b>

<b>    b>

<b>    event GreetingChanged (streng oldGreeting, string newGreeting); b>

I denne delen skal vi erklære en konstruktør. Konstruktøren, som du kanskje har lagt merke til, deler samme navn som kontrakten. Jobben til konstruktøren er å initialisere variablene under kjøretiden. Konstruktøren tar “_hilsen” som parameter og bruker den til å initialisere “hilsen”. Samtidig lagres adressen til personen som sender parameteren i eieren. Siden konstruktøren bare utfører i begynnelsen av kjøretiden, er personen som har adresse lagret kontraktsskaperen.

Avsnitt 3

// seksjon 3

funksjonssett Hilsen (streng _hilsen) {

krever (eier == msg.sender);

GreetingChanged (hilsen, _hilsen);

hilsen = _hilsen;

}

I den tredje delen har vi setterfunksjonen, som vil hjelpe oss med å endre verdiene som holdes i variablene. Som parameter tar denne funksjonen inn den nye hilsenen, i tilfelle en endring er nødvendig.

Så, hva som skjer inne i funksjonen?

Vi ønsker å introdusere noe tilgangskontroll til programmet. Dette er grunnen til at vi sjekker om den som gjør endringen er eier av kontrakten eller ikke. Som vi vil se senere, vil kompilatoren kaste et unntak og returnere en feil hvis noen andre prøver å gjøre en modifikasjon.

Så hvis denne betingelsen er oppfylt, blir GreetingChanged-hendelsen utløst, og verdien av “hilsen” blir oppdatert med “_greeting”.

OK, så la oss nå lage programmet. Lagre programmet og velg “myfirstcontract” her:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Deretter klikker du på “Deploy” for å utføre kontrakten. I det øyeblikket du gjør det, legg merke til hva som skjer i loggen.

Introduksjon til Javascript and Solidity-Part 2: Solidity

Du ser den meldingen?

Det viser at henrettelsen var vellykket. Ser du også den nedpiltasten ved siden av feilsøkingsknappen? Klikk på den for å åpne detaljene for transaksjonene:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Status: Viser at transaksjonen har lykkes

Transaksjon Hash: Transaksjons unike hasj. Det viser transaksjons-ID.

Kontraktsadresse: Adressen til den smarte kontrakten. Hver gang en kontrakt er distribuert, får den en adresse som sorta fungerer som kontraktens ID.

Fra: Adressen til eieren av kontrakten som vi har valgt

Til: Viser at konstruktøren har generert variablene.

Gass: Den øvre grensen for gassen som vi har satt på forhånd

Transaksjonskostnad: Hvor mye gass det kostet å sende kontrakten til blockchain.

Utførelseskostnad: Hvor mye gass det koster å utføre kontrakten.

Hash: Transaksjonens hash .

Inngang: Dette er den kompilerte soliditetskoden som faktisk blir lest av Ethereum Virtual Machine.

Dekodet inngang: Inngangene gitt til kontrakten som sendes via parametrene.

Tømmerstokker: Viser hendelser som kontrakten kan ha generert.

Verdi: Siden kontrakten ikke fikk noen Ether-tokens av oss, viser den 0 wei.

Ok, nå vil vi at du skal fokusere på høyre side av skjermen. Ser du dette?

Introduksjon til Javascript and Solidity-Part 2: Solidity

Ved siden av “Konto” -feltet vil du se at adressen har litt mindre enn 100 Ether-tokens. Dette viser at så mye Ether ble brukt til å distribuere kontrakten.

Klikk på fanen under Distribuerte kontrakter, og den vil avsløre dette:

Introduksjon til Javascript and Solidity-Part 2: Solidity

I dette:

  • “Hilsen” og “eier” er getterfunksjoner som er opprettet som standard på grunn av at variablene ble erklært som “offentlige”.
  • “SetGreeting” er en setterfunksjon der du kan legge inn dataene.

Siden “setGreeting” tar inn en strengparameter, må du legge inn dataene med to anførselstegn. Ganske slik:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Når du har tastet inn dataene, trykker du på “setGreeting” -knappen:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Det er to felt som vi vil at du skal fokusere på:

Dekodet inngang: Viser inngangsstrengen vi har gitt.

Tømmerstokker: Oppretter en hendelse som viser at verdien til “hilsen” er endret.

OK, la oss nå klikke på “hilsen” -knappen på getter-funksjonen:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Det gir deg umiddelbart verdien av hilsenvariabelen.

Når du sjekker loggene, vil du se følgende:

Introduksjon til Javascript and Solidity-Part 2: Solidity

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

På samme måte er det bare å klikke på “eier” -knappen:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Den viser verdien til eieren. Nå når du sjekker loggene:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Det dekodede resultatet viser adressen til eieren av kontrakten.

La oss gjøre noe. La oss velge en annen adresse i Konto-feltet:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Når du endrer adresse, prøver å komme inn en ny streng i setterfunksjonen, får du følgende melding i loggen:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Denne feilen kommer fordi dette mislykkes tilgangskontrollen vi legger i koden vår. Husk denne kodelinjen:

krever (eier == msg.sender);

Dette sørger for at ingen annen adresse bortsett fra eieren kan endre dataene i kontrakten.

# 2 Navn og alder

//seksjon 1

pragmasoliditet ^ 0.4.19;

kontrakt minecondcontract {

streng privat navn;

uint privat alder;

// seksjon 2

funksjonssettnavn (streng newName) {

navn = nytt navn;

}

funksjon getName () returnerer (streng) {

returnavn;

}

// seksjon 3

function setAge (uint newAge) {

alder = nyAlder;

}

funksjon getAge () returnerer (uint) {

returalder;

}

}

Seksjon 1

pragmasoliditet ^ 0.4.19;

kontrakt minecondcontract {

streng privat navn;

uint privat alder;

Vi har erklært en smart kontrakt kalt “mysecondcontract”. Dette har to private variabler. En streng kalt “navn” og et usignert heltall (et ikke-negativt heltall) kalt “alder”.

Avsnitt 2

funksjonssettnavn (streng newName) {

navn = nytt navn;

}

funksjon getName () returnerer (streng) {

returnavn;

}

I denne delen vil vi ha setter- og getter-funksjonen for navnevariabelen. Den første delen er en normal setterfunksjon som tar inn en parameter for å initialisere navnevariabelen.

Den andre delen er en getter-funksjon som hjelper eieren med å få tilgang til “navn” -variabelen.

Avsnitt 3

function setAge (uint newAge) {

alder = nyAlder;

}

funksjon getAge () returnerer (uint) {

returalder;

}

Denne delen definerer en setter- og getterfunksjon for alder.

La oss utføre kontrakten og sette alder som “28”. Loggen ser nå slik ut:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Som du ser, gjenspeiles alderen i “dekodet inngang”.

La oss nå sette navnet som “Maks”.

Nå viser det dekodede inndatafeltet navnet “Max”.

Vi kan nå sjekke alderens getterfunksjon for å se utdataene:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Utgangsfeltet viser alderen.

Nå, for getter-funksjonen til navnet:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Nå viser den dekodede utdata, dvs. navnet.

Arv og soliditet

Arv er et av de kraftigste verktøyene i programmering. I soliditet hjelper det deg å utlede en smart kontrakt fra en eldre smart kontrakt. Formatet ser slik ut:

kontrakt A {

——-

}

kontrakt B er A {

——

}

Nøkkelordet “er” innebærer at kontrakten B arver verdien fra kontrakt A. Nå kan kontrakt A definere hvilke av elementene den vil dele med kontrakt B via tilgangsmodifikatorer. Solidity gir deg fire tilgangsmodifikatorer:

  • Privat: Elementet blir ikke arvet, og det er heller ikke tilgang til det av eksterne elementer.
  • Offentlig: Elementet kan arves og nås av eksterne elementer.
  • Innvendig: Elementet kan arves, men det er ikke tilgang til eksterne elementer
  • Utvendig: Elementet kan ikke arves, men det kan nås av eksterne elementer.

Ok, nå som vi har nevnt alt dette, la oss gjøre noen arv på kontrakten vår. Vi vil endre mysecondcontract-koden.

pragmasoliditet ^ 0.4.19;

//seksjon 1

grensesnittregulator {

function checkValue (uint beløp) returnerer (bool);

funksjonslån () returnerer (bool);

}

#avsnitt 2

kontrakt Bank er regulator {

uint privat verdi;

funksjon Bank (uint beløp) {

verdi = beløp;

}

funksjonsinnskudd (uint beløp) {

verdi + = beløp;

}

funksjon uttak (uint beløp) {

hvis (checkValue (beløp)) {

verdi – = beløp;

}

}

funksjonsbalanse () returnerer (uint) {

returverdi;

}

function checkValue (uint amount) returnerer (bool) {

returverdi >= beløp;

}

funksjonslån () returnerer (bool) {

returverdi > 0;

}

}

// seksjon 3

kontrakten minsecondcontract er Bank {

streng privat navn;

uint privat alder;

funksjonssettnavn (streng newName) {

navn = nytt navn;

}

funksjon getName () returnerer (streng) {

returnavn;

}

function setAge (uint newAge) {

alder = nyAlder;

}

funksjon getAge () returnerer (uint) {

returalder;

}

}

Seksjon 1

La oss se på den aktuelle koden:

grensesnittregulator {

function checkValue (uint beløp) returnerer (bool);

funksjonslån () returnerer (bool);

}

La oss se på den aktuelle koden:

grensesnittregulator {

function checkValue (uint beløp) returnerer (bool);

funksjonslån () returnerer (bool);

}

Det første vi har erklært er et grensesnitt. Grensesnittet hjelper deg med å definere funksjonene uten å avsløre hvordan de skal fungere internt. Deres interne mekanismer skal avsløres i de andre avtalene.

Avsnitt 2

kontrakt Bank er regulator {

uint privat verdi;

funksjon Bank (uint beløp) {

verdi = beløp;

}

funksjonsinnskudd (uint beløp) {

verdi + = beløp;

}

funksjon uttak (uint beløp) {

hvis (checkValue (beløp)) {

verdi – = beløp;

}

}

funksjonsbalanse () returnerer (uint) {

returverdi;

}

function checkValue (uint amount) returnerer (bool) {

returverdi >= beløp;

}

funksjonslån () returnerer (bool) {

returverdi > 0;

}

}

Så vi har erklært en kontrakt som heter bank som arver verdiene fra grensesnittet. Det første vi gjør er å erklære en konstruktør som vil initialisere variabelverdien.

Etter det har vi et par setterfunksjoner kalt “uttak” og “innskudd” som hjelper kontrakten med å trekke og sette inn fra brukerens konto.

Se spesielt på trekkfunksjonen.

funksjon uttak (uint beløp) {

hvis (checkValue (beløp)) {

verdi – = beløp;

}

Før vi kan trekke ut, kaller funksjonen checkValue-funksjonen som den har arvet fra grensesnittet for å sikre om brukeren har nok verdi på kontoen sin til å ta ut pengene eller ikke.

Etter setterfunksjonene har vi getterfunksjonene som returnerer, i rekkefølge:

  • Saldoen på brukerens konto
  • Om brukeren har nok penger til uttak eller ikke.
  • Hvis brukeren er åpen for et lån eller ikke. For dette sjekker vi bare om brukerens saldo er > 0 eller ikke.

Avsnitt 3

kontrakten minsecondcontract er Bank {

streng privat navn;

uint privat alder;

funksjonssettnavn (streng newName) {

navn = nytt navn;

}

funksjon getName () returnerer (streng) {

returnavn;

}

function setAge (uint newAge) {

alder = nyAlder;

}

funksjon getAge () returnerer (uint) {

returalder;

}

}

Denne delen av kontrakten er den samme som før. Den eneste forskjellen er at det arver eiendommer fra bankkontrakten.

Import av soliditet og biblioteker

Neste gang må vi ha viktige soliditetsfunksjoner som du bør være komfortabel med, import og biblioteker. For dette skal vi lage to separate kontraktsfiler som vi skal kalle “library.sol” og “testLibrary.sol”.

Biblioteket vårt.sol-program ser slik ut:

pragmasoliditet ^ 0.4.19;

kontraktsbiblioteker {

funksjonstest() {}

}

Og testLibrary ser slik ut:

pragmasoliditet ^ 0.4.19;

import "nettleser / library.sol";

kontraktstest Bibliotek er biblioteker {

}

TestLibrary-programmet importerer ganske enkelt biblioteksfilen som er lagret på nettstedet: browser / library.sol. Alle soliditetsprogrammer er som standard lagret i nettlesermappen.

Få tilgang til modifikatorer og reservefunksjoner

Tilgangsmodifikatorer og tilbakeslagsfunksjoner er morsomme små verktøy som du kan bruke til å krydre kontraktene dine. La oss begynne med reservefunksjoner. Sjekk ut følgende kode:

pragmasoliditet ^ 0.4.19;

kontraktstestTransaksjon {

hendelse SenderLogger (adresse);

hendelse ValueLogger (uint);

funksjon () betales {

SenderLogger (msg.sender);

ValueLogger (msg.value);

}

}

Dette er en enkel smart kontrakt som lar deg trekke ut detaljene i en transaksjon. I utgangspunktet, hvis noen sender Ether til denne kontrakten, vil denne kontrakten trekke ut:

  • Adressen til avsenderen
  • Mengden Ether som de sender.

Reservefunksjonen er akkurat her:

 funksjon () betales {

SenderLogger (msg.sender);

ValueLogger (msg.value);

}

Som du kan se, har funksjonen ikke noe navn, og du kan bare sette inn en reservefunksjon i hver kontrakt. Ideen er å gjøre det mulig for alle å komme i kontakt med kontrakten og sende Ether-tokens til den.

Så la oss kjøre programmet og se noen data. Vi skal distribuere kontrakten. Sett 1 eter i “verdi” -feltet og trykk på “tilbakeslag” -knappen.

Introduksjon til Javascript and Solidity-Part 2: Solidity

La oss nå sjekke loggene.

Introduksjon til Javascript and Solidity-Part 2: Solidity

Det siste feltet i tabellen i verdifeltet som viser mengden Ether i wei som er sendt til kontrakten.

Ok, så la oss sette noen modifikatorer i programmet og endre ting rundt.

pragmasoliditet ^ 0.4.19;

kontraktstransaksjon {

hendelse SenderLogger (adresse);

hendelse ValueLogger (uint);

adresse privat eier;

modifikator isOwner {

krever (eier == msg.sender);

_;

}

modifier validValue {

hevde (msg.verdi >= 1 eter);

_;

}

funksjonstransaksjon () {

eier = msg.sender;

}

funksjon () betales isOwner validValue {

SenderLogger (msg.sender);

ValueLogger (msg.value);

}

}

Ok, så denne kontrakten er den samme som den forrige. Vi vil fortsatt trekke ut transaksjonsdetaljer. Vi har imidlertid lagt til følgende to betingelser:

  • Bare eieren av kontrakten kan sende transaksjonen
  • Transaksjonen skal være minst 1 Ether

Så, la oss se på en modifikator og se hvordan vi utfører den:

modifikator isOwner {

       krever (eier == msg.sender);

       _;

   }

Så, hva gjør vi akkurat her?

Vi har erklært en modifikator, som i utgangspunktet er en tilpasset tilgangskontrollfunksjon, som kjører en “krever” -funksjon for å sikre at bare eieren kan bruke kontrakten..

Merker du også “_;”?

Dette indikerer at etter at tilgangsmodifisereren er utført, må funksjonen hvis inngang den beskytter også kjøre.

La oss sjekke vår neste modifikator:

modifier validValue {

       hevde (msg.verdi >= 1 eter);

       _;

   }

Dette er igjen en grei modifikator som sjekker om verdien som sendes inn i kontrakten er større enn 1 eter eller ikke.

Ok, så nå når vi har definert disse modifikatorene, hvordan skal vi bruke dem i funksjonen? Vel, la oss sjekke det ut:

funksjon () betales isOwner validValue {

       SenderLogger (msg.sender);

       ValueLogger (msg.value);

   }

Ser du vår reservefunksjon nå? Vi har lagt til tilgangsmodifikatorer til funksjonsoverskriften for å begrense tilgangen til den. La oss nå kjøre kontrakten gjennom Remix og se hva vi får her.

La oss legge til en eter i verdifeltet og se hva vi får.

Introduksjon til Javascript and Solidity-Part 2: Solidity

Loggen viser:

  • Adressen til avsenderen
  • Verdien av Ether satt i kontrakten

Hva skjer nå hvis vi:

  • Send mindre enn 1 eter
  • Send eter fra en annen adresse

Mindre enn 1 eter

Vi sendte 0,2 Ether i verdifeltet, og programmet ga umiddelbart en feil:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Fra en annen adresse

Vi sendte 1 Ether fra en annen adresse. Nok en gang får vi en feil:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Strukturer og kartlegging i fasthet

Før vi avslutter denne veiledningen, vil vi gjøre deg kjent med to konsepter til som du kommer til å støte på mens du koder.

  • Strukturer
  • Kartlegging

Strukturer er gjenstander som mangler metoder. De definerer bare variablene.

Kartlegging i soliditet er liksom en hash-tabell som initialiseres praktisk talt slik at hver potensielle nøkkel eksisterer. Kartlegging kan erklæres slik:

kartlegging (A => B).

A = Kan være av hvilken som helst type bortsett fra kartlegging, matrise, enum, kontrakt og struktur.

B = Kan være av hvilken som helst type (inkludert kartlegging).

La oss utføre et program som inkluderer begge disse funksjonene:

pragmasoliditet ^ 0.4.19;

kontraktsvisningskart {

//Seksjon 1

struct-konto {

uint balanse;

}

Konto myAccount;

funksjon structFunc () {

myAccount.balance = 100;

}

// seksjon 2

kartlegging (adresse => Konto) _kontoer;

funksjon () betales {

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

}

funksjon getBalance () returnerer (uint) {

returnere _accounts [msg.sender] .balanse;

}

}

Seksjon 1

Så vi har erklært en struktur med navnet Konto som har en uint datatype kalt “saldo”. Vi initialiserte deretter en variabel kalt myAccount av typen Account og brukte deretter structFunc () -funksjonen til å tilordne en verdi på 100 til myAccount.balance.

Avsnitt 2

Ved å bruke kartleggingsnøkkelordet, tilordner vi adressene til kontostrukturen vår og kaller det “_kontoer”..

Vi har da en reservefunksjon for å legge til eteren gitt av brukeren i balansen. Funksjonen getBalance () returnerer deretter verdien av den oppdaterte saldoen til brukeren.

La oss se på dette i aksjon.

Vi skal sende 10 Ether til den smarte kontrakten.

Så ved å bruke reservefunksjonen sendte vi 10 Ether til kontoen som du kan se i loggen her:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Så hvis vi får balanse akkurat nå, vil vi få dette:

Introduksjon til Javascript and Solidity-Part 2: Solidity

Legg merke til feltet “dekodet utdata” og legg merke til hvordan balansen reflekteres som 10 eter.

Introduksjon til Javascript and Solidity-Part 2: Solidity

La oss nå sende 10 flere Ether til kontrakten via reservefunksjonen, og la oss sjekke saldoen igjen via getBalance ().

Hvis du ser getBalance () -feltet, vil du legge merke til at balansen gjenspeiler 20 Ether.

Konklusjon

Det er mye mer med soliditet enn det vi har dekket her. I den nærmeste fremtiden skal vi vise deg hvordan du kan lage din egen kryptovaluta ved hjelp av soliditet.

Men for nå, hvis du vil utdanne deg enda mer, kan du registrere deg for våre soliditetskurs. Vi har ekstremt godt trente lærere som skal veilede deg gjennom reisen din som utvikler.

Du kan også sjekke ut disse videoseriene av “What’s Solidity”. De har supre videoer, og flertallet av koden som brukes her, er hentet fra gitHub-siden deres.

Hensikten med disse to artiklene var å gi deg en innføring i både JavaScript og soliditet. Vi håper at du har det grunnleggende klart for å ta på deg mer utfordrende programmer / kontrakter.

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