Introduktion till Javascript and Solidity-Part 2: Solidity

I den första delen tacklade vi JavaScript och visade dig grunderna i programmeringsspråket. I del 2 kommer vi att prata om soliditet och hur du kan använda detta programmeringsspråk till din fördel. Innan vi börjar med kodningsdelen, några grunder om soliditet.

Soliditet – En introduktion

För alla som vill lära sig att skapa DAPPs (Decentralized Applications) eller komma in i ICO-spelet är att lära sig soliditet ett absolut måste. Soliditet utvecklades av Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai och flera tidigare Ethereum-kärnbidragare för att möjliggöra att skriva smarta kontrakt på blockchain-plattformar som Ethereum.

Soliditet är tänkt att vara ett målmedvetet avsmalnat, löst skrivet språk med en syntax som liknar JavaScript. Du kan kolla in Solidity Docs precis här.

Med Solidity kommer du att koda smarta kontrakt som kommer att köras i Ethereum Virtual Machine aka EVM. Ethereum-utvecklare nämner en viss mängd gas som tilldelas deras kontrakt. Varje linje i kontraktet kräver en viss mängd gas att utföra. Gasgränsen bör vara tillräcklig för att kontraktet ska kunna genomföras helt.

Med detta sagt, låt oss börja koda.

Remix – IDE

Vi kommer att köra våra koder på Remix. Klicka här att gå till Remix-webbplatsen. Remix är en miljö i webbläsaren där du kan utföra dina smarta kontrakt på en testblockchain. Detta skapades av Ethereum Foundation själva så att du kan börja utveckla kontrakt, när och när du vill.

Så när du besöker den här webbplatsen ser du den här skärmen:

Introduktion till Javascript and Solidity-Part 2: Solidity

Nu kan det här användargränssnittet vara extremt skrämmande när du tittar på det för första gången. Låt oss dock dela upp det avsnitt för avsnitt. Vi kommer att gå från vänster.

Introduktion till Javascript and Solidity-Part 2: Solidity

Vänster sida av webbläsaren har alla kontrakt som du för närvarande arbetar med.

Nästa steg har du det här:

Introduktion till Javascript and Solidity-Part 2: Solidity

Det här är redigeraren där du faktiskt ska koda. Som standard har Remix-användargränssnittet ett smartavtal för val som du kan ignorera för tillfället. Det finns inget behov av att gå in på detta.

Efter det har du:

Introduktion till Javascript and Solidity-Part 2: Solidity

Det här är programloggen.

Alla fel som du möter när du kodar och alla utdata från ditt program kommer att beskrivas i denna logg.

På höger sida har du:

Introduktion till Javascript and Solidity-Part 2: Solidity

På höger sida har du det avsnitt som kommer att göra det mesta av jobbet. Som standard kommer den att vara på “Compile Tab” men det är på “Run Tab” där du ska göra det mesta av arbetet.

Introduktion till Javascript and Solidity-Part 2: Solidity

Miljö: Det finns tre miljöer där du kan utföra dina smarta kontrakt som är: JavaScript VM, Injected Web3 och Web3 Provider.

konto: Det finns fem kontoadresser som du kan använda som ägare till detta kontrakt. Varje adress har 100 testetermärken bifogade.

Introduktion till Javascript and Solidity-Part 2: Solidity

Gasgräns: Den totala gasgränsen som tilldelats för genomförandet av detta smarta kontrakt.

Värde: Hur mycket Ether-tokens du vill tillhandahålla för dina transaktioner.

Detta borde vara tillräckligt för nu. Låt oss komma igång med några enkla, grundläggande program.

Datatyper i fasthet

Låt oss först täcka datatyperna som du kommer att använda i soliditet. Inom datavetenskap och datorprogrammering är en datatyp eller helt enkelt typ en klassificering av data som berättar för kompilatorn eller tolken hur programmeraren avser att använda data.

Är data ett heltal eller en sträng eller en matris?

Sättet som kompilatorn fattar dessa beslut är genom att titta på datatypen.

Så, först, låt oss kontrollera heltal datatyper som du kommer att ha i soliditet:

  • Normal heltalsdeklaration kallad “int” som går från -128 till 127
  • Osignerat heltal “uint” som går från 0-255 och inte lagrar några negativa värden

Nästa gång har vi booleska datatyper som endast lagrar ”true” eller ”false”. För att förklara booleska värden gör du detta: bool a;

Efter det har du Strängar och Byte.

Du kan använda sträng i soliditet som detta: strängnamn. Strängar lagras som en uppsättning värden i soliditet.

Bytes är en rad byte som går från 1-32 tecken. Så vad är skillnaden mellan strängar och byte?

I soliditetsdokumentationen står:

Som en tumregel använder du byte för rå byte-data med godtycklig längd och sträng för data med godtycklig längd (UTF-8). Om du kan begränsa längden till ett visst antal byte, använd alltid en av byte1 till bytes32 eftersom de är mycket billigare.

Nästa steg har vi något coolt som heter ”enum”. Enum är ett sätt att skapa en användardefinierad typ i Solidity. Så här förklarar du dem:

enum Action {REMOVE, UPDATE}

 Så, hur använder du dem i programmet?

Åtgärd myAction = Action.UPDATE;

Du skapar en variabel av typen Action, vilket är namnet på det enum som vi har använt i exemplet ovan. Och sedan bara tilldela en handling till dem.

Du kan läs soliditetsdokumenten för att få mer fördjupad kunskap om olika datatyper.

Grundläggande program

# 1 Hello World

pragmasoliditet ^ 0.4.19;

//sektion 1

kontrakt mitt första kontrakt {

sträng offentlig hälsning;

adressera allmän ägare;

event GreetingChanged (string oldGreeting, string newGreeting);

//sektion 2

function myfirstcontract (string _greeting) {

hälsning = _ hälsning;

ägare = msg.sändare;

}

// avsnitt 3

funktionssetGreeting (string _greeting) {

kräver (ägare == msg.sender);

GreetingChanged (hälsning, _hälsning);

hälsning = _ hälsning;

}

}

Så vi har delat det smarta kontraktet i tre avsnitt. Låt oss titta på varje avsnitt och se vad som händer där inne.

Sektion 1

// avsnitt 1b>

 

<b>pragmasoliditet ^ 0.4.19; b>

&nbsp;

<b>kontrakt med min första kontrakt {b>

<b>    b>

<b>    sträng offentlig hälsning, b>

<b>    adressera allmän ägare, b>

<b>    b>

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

“Pragmasoliditet ^ 0.4.19” visar att vi använder en version av 0.4.19 av soliditeten. “^” Ser också till att vårt program körs på högre versioner också.

“Kontrakt myfirstcontract” förklarar vårt kontrakt som vi har kallat “myfirstcontract”.

Därefter förklarar vi en sträng som heter ”hälsning” som vi kommer att använda för att spara vårt meddelande. Denna sträng är en “allmän” sträng. Vi förklarar också en offentlig variabel som heter “ägare” av typadress för att spara adressen till kontraktets ägare.

Fördelen med att använda en “offentlig” variabel är att den automatiskt tilldelas en “getter” -funktion. En getter-funktion hjälper till att få tillgång till värdet på en variabel medan en “setter” -funktion låter dig ändra värdet.

Efter det har vi ett evenemang som heter “GreetingChanged”. Denna händelse ser till att när som helst det sker någon förändring i hälsningen sänds ändringen.

Sektion 2

// avsnitt 1b>

&nbsp;

<b>pragmasoliditet ^ 0.4.19; b>

&nbsp;

<b>kontrakt med min första kontrakt {b>

<b>    b>

<b>    sträng offentlig hälsning, b>

<b>    adressera allmän ägare, b>

<b>    b>

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

I det här avsnittet ska vi förklara en konstruktör. Konstruktören delar, som du kanske har märkt, samma namn som kontraktet. Konstruktörens jobb är att initialisera variablerna under körning. Konstruktören tar “_greeting” som en parameter och använder den för att initiera “hälsning”. Samtidigt sparas adressen till den person som skickar parametern i ägaren. Eftersom konstruktören endast kör i början av körtiden är den person vars adress sparas kontraktets skapare.

Avsnitt 3

// avsnitt 3

funktionssetGreeting (string _greeting) {

kräver (ägare == msg.sender);

GreetingChanged (hälsning, _hälsning);

hälsning = _ hälsning;

}

I det tredje avsnittet har vi setterfunktionen, som hjälper oss att ändra värdena i variablerna. Som parameter tar denna funktion in den nya hälsningen, om en ändring krävs.

Så vad händer inuti funktionen?

Vi vill införa åtkomstkontroll till programmet. Det är därför vi kontrollerar om den som gör ändringen är ägare till kontraktet eller inte. Som vi kommer att se senare, om någon annan försöker göra en modifiering, kommer kompilatorn att kasta ett undantag och returnera ett fel.

Så om detta villkor är uppfyllt utlöses GreetingChanged-händelsen och värdet av “hälsning” uppdateras med “_hälsning”.

Okej, så låt oss nu sammanställa programmet. Spara ditt program och välj “myfirstcontract” här:

Introduktion till Javascript and Solidity-Part 2: Solidity

Klicka därefter på “Distribuera” för att utföra kontraktet. När du gör det, märker du vad som händer i loggen.

Introduktion till Javascript and Solidity-Part 2: Solidity

Du ser det meddelandet?

Det visar att utförandet lyckades. Ser du också den nedåtpiltangenten bredvid felsökningsknappen? Klicka på den så öppnas detaljerna för transaktionerna:

Introduktion till Javascript and Solidity-Part 2: Solidity

Status: Visar att transaktionen har lyckats

Transaktion Hash: Transaktionens unika hash. Det visar transaktions-ID.

Kontraktsadress: Adressen till det smarta kontraktet. När ett kontrakt har distribuerats framgångsrikt får det en adress som sorta fungerar som kontraktets ID.

Från: Adressen till ägaren till det kontrakt som vi har valt

Till: Visar att konstruktören har genererat variablerna.

Gas: Den övre gränsen för gasen som vi har ställt in i förväg

Transaktions kostnad: Hur mycket gas det kostade att skicka kontraktet till blockchain.

Kostnad för utförande: Hur mycket gas det kostade att genomföra kontraktet.

Hash: Transaktionens hash .

Inmatning: Detta är den sammanställda soliditetskoden som faktiskt läses av Ethereum Virtual Machine.

Avkodad ingång: Ingången till kontraktet som skickas via parametrarna.

Loggar: Visar alla händelser som kontraktet kan ha genererat.

Värde: Eftersom kontraktet inte gav oss några Ether-tokens, visar det 0 wei.

Okej, nu vill vi att du ska fokusera på höger sida av skärmen. Ser du det här?

Introduktion till Javascript and Solidity-Part 2: Solidity

Bredvid fältet “Konto” ser du att adressen har lite mindre än 100 Ether-token. Detta visar att så mycket eter användes för att distribuera kontraktet.

Klicka på fliken under Distribuerade kontrakt och det kommer att avslöja detta:

Introduktion till Javascript and Solidity-Part 2: Solidity

I denna:

  • “Hälsning” och “ägare” är getterfunktioner som har skapats som standard på grund av att variablerna förklarades som ”offentliga”.
  • “SetGreeting” är en setterfunktion där du kan mata in data.

Eftersom “setGreeting” tar in en strängparameter måste du mata in data i dubbla citat. Ganska så här:

Introduktion till Javascript and Solidity-Part 2: Solidity

När du har angett data, tryck på “setGreeting” -knappen:

Introduktion till Javascript and Solidity-Part 2: Solidity

Det finns två fält som vi vill att du ska fokusera på:

Avkodad ingång: Visar den ingångssträng som vi har gett.

Loggar: Skapar en händelse som visar att värdet på “hälsning” har ändrats.

Okej, nu ska vi klicka på “hälsning” -knappen på getter-funktionen:

Introduktion till Javascript and Solidity-Part 2: Solidity

Det ger dig omedelbart värdet på hälsningsvariabeln.

När du kontrollerar loggarna ser du följande:

Introduktion till Javascript and Solidity-Part 2: Solidity

Se fältet “avkodad utmatning” och du kommer att se “Hello World” där.

På samma sätt klickar du bara på knappen “ägare”:

Introduktion till Javascript and Solidity-Part 2: Solidity

Det visar värdet på ägarens adress. Nu när du kontrollerar loggarna:

Introduktion till Javascript and Solidity-Part 2: Solidity

Den avkodade produktionen visar adressen till kontraktets ägare.

Nu ska vi göra något. Låt oss välja någon annan adress i fältet Konto:

Introduktion till Javascript and Solidity-Part 2: Solidity

När du ändrar adress, försöker komma in i en ny sträng i setterfunktionen får du följande meddelande i loggen:

Introduktion till Javascript and Solidity-Part 2: Solidity

Det här felet kommer eftersom detta misslyckas med den åtkomstkontroll vi lägger in i vår kod. Kom ihåg denna kodrad:

kräver (ägare == msg.sender);

Detta säkerställer att ingen annan adress förutom ägaren kan ändra uppgifterna i kontraktet.

# 2 Namn och ålder

//sektion 1

pragmasoliditet ^ 0.4.19;

kontrakt mina andra kontrakt {

sträng privat namn;

uint privat ålder;

//sektion 2

funktionsuppsättningsnamn (sträng newName) {

namn = nytt namn;

}

funktionen getName () returnerar (sträng) {

returnamn;

}

// avsnitt 3

function setAge (uint newAge) {

age = newAge;

}

funktionen getAge () returnerar (uint) {

returålder

}

}

Sektion 1

pragmasoliditet ^ 0.4.19;

kontrakt mina andra kontrakt {

sträng privat namn;

uint privat ålder;

Vi har förklarat ett smart kontrakt med namnet “mysecondcontract”. Detta har två privata variabler. En sträng som heter “namn” och ett osignerat heltal (ett icke-negativt heltal) som heter “ålder”.

Sektion 2

funktionsuppsättningsnamn (sträng newName) {

namn = nytt namn;

}

funktionen getName () returnerar (sträng) {

returnamn;

}

I det här avsnittet har vi setter- och getter-funktionen för namnvariabeln. Den första delen är en normal setterfunktion som tar in en parameter för att initiera namnvariabeln.

Den andra delen är en getter-funktion som hjälper ägaren att komma åt variabeln “namn”.

Avsnitt 3

function setAge (uint newAge) {

age = newAge;

}

funktionen getAge () returnerar (uint) {

returålder

}

Denna del definierar en setter- och getter-funktion för ålder.

Låt oss genomföra kontraktet och ställa in åldern som “28”. Loggen ser nu ut så här:

Introduktion till Javascript and Solidity-Part 2: Solidity

Som du kan se återspeglas åldern i den “avkodade ingången”.

Nu ska vi ställa in namnet som “Max”.

Nu visar det avkodade inmatningsfältet namnet “Max”.

Vi kan nu kontrollera åldersfunktionen för att se resultatet:

Introduktion till Javascript and Solidity-Part 2: Solidity

Outputfältet visar åldern.

Nu, för getterfunktionen för namnet:

Introduktion till Javascript and Solidity-Part 2: Solidity

Nu visar den avkodade utdata dvs namnet.

Arv och fasthet

Arv är ett av de mest kraftfulla verktygen i programmering. I soliditet hjälper det dig att få ett smart kontrakt från ett äldre smart kontrakt. Formatet ser ut så här:

kontrakt A {

——-

}

kontrakt B är A {

——

}

Nyckelordet “är” innebär att kontraktet B ärver värdet från kontraktet A. Nu kan kontrakt A definiera vilka av dess element det vill dela med kontrakt B via åtkomstmodifierare. Soliditet ger dig fyra åtkomstmodifierare:

  • Privat: Elementet ärvs inte och det kan inte heller nås av externa element.
  • offentlig: Elementet kan ärvas och nås av externa element.
  • Inre: Elementet kan ärvas men det kan inte nås av externa element
  • Extern: Elementet kan inte ärvas men det kan nås av externa element.

Ok, nu när vi har nämnt allt detta, låt oss göra något arv på vårt kontrakt. Vi kommer att ändra mysecondcontract-koden.

pragmasoliditet ^ 0.4.19;

//sektion 1

gränssnittsregulator {

function checkValue (uint amount) returnerar (bool);

funktionslån () returnerar (bool);

}

#sektion 2

kontrakt Bank är tillsynsmyndighet {

uint privat värde;

funktion Bank (det totala beloppet) {

värde = belopp;

}

funktionsdeposition (uint belopp) {

värde + = belopp;

}

funktionsuttag (uint belopp) {

if (checkValue (belopp)) {

värde – = belopp;

}

}

funktionsbalans () returnerar (uint) {

returvärde;

}

function checkValue (uint amount) returnerar (bool) {

returvärde >= belopp;

}

funktionslån () returnerar (bool) {

returvärde > 0;

}

}

// avsnitt 3

kontrakt mysecondcontract är Bank {

sträng privat namn;

uint privat ålder;

funktionsuppsättningsnamn (sträng newName) {

namn = nytt namn;

}

funktionen getName () returnerar (sträng) {

returnamn;

}

function setAge (uint newAge) {

age = newAge;

}

funktion getAge () returnerar (uint) {

returålder

}

}

Sektion 1

Låt oss titta på koden i fråga:

gränssnittsregulator {

function checkValue (uint amount) returnerar (bool);

funktionslån () returnerar (bool);

}

Låt oss titta på koden i fråga:

gränssnittsregulator {

function checkValue (uint amount) returnerar (bool);

funktionslån () returnerar (bool);

}

Det första vi har förklarat är ett gränssnitt. Gränssnittet hjälper dig att definiera funktionerna utan att faktiskt avslöja hur de ska fungera internt. Deras interna mekanismer ska avslöjas i de andra kontrakten.

Sektion 2

kontrakt Bank är tillsynsmyndighet {

uint privat värde;

funktion Bank (det totala beloppet) {

värde = belopp;

}

funktionsdeposition (uint belopp) {

värde + = belopp;

}

funktionsuttag (uint belopp) {

if (checkValue (belopp)) {

värde – = belopp;

}

}

funktionsbalans () returnerar (uint) {

returvärde;

}

function checkValue (uint amount) returnerar (bool) {

returvärde >= belopp;

}

funktionslån () returnerar (bool) {

returvärde > 0;

}

}

Så vi har förklarat ett avtal som kallas bank som ärver sina värden från gränssnittet. Det första vi gör är att deklarera en konstruktör som initialiserar variabelvärdet.

Efter det har vi ett par setterfunktioner som kallas “ta ut” och “insättning” vilket hjälper kontraktet att ta ut och sätta in från användarens konto.

Titta speciellt på uttagsfunktionen.

funktionsuttag (uint belopp) {

if (checkValue (belopp)) {

värde – = belopp;

}

Innan vi kan ta ut, kallar funktionen checkValue-funktionen som den har ärvt från gränssnittet för att säkerställa om användaren har tillräckligt med värde på sitt konto för att ta ut pengarna eller inte.

Efter setterfunktionerna har vi getterfunktionerna som returnerar, i ordning:

  • Saldot på användarens konto
  • Oavsett om användaren har tillräckligt med pengar för ett uttag eller inte.
  • Om användaren är öppen för ett lån eller inte. För detta kontrollerar vi bara om användarens balans är > 0 eller inte.

Avsnitt 3

kontrakt mysecondcontract är Bank {

sträng privat namn;

uint privat ålder;

funktionsuppsättningsnamn (sträng newName) {

namn = nytt namn;

}

funktionen getName () returnerar (sträng) {

returnamn;

}

function setAge (uint newAge) {

age = newAge;

}

funktionen getAge () returnerar (uint) {

returålder

}

}

Detta avsnitt i kontraktet är detsamma som tidigare. Den enda skillnaden är att den ärver fastigheter från bankavtalet.

Import och bibliotek av fasthet

Därefter måste vi ha viktiga soliditetsfunktioner som du bör vara bekväm med, import och bibliotek. För detta ska vi skapa två separata kontraktsfiler som vi kommer att kalla “library.sol” och “testLibrary.sol”.

Vårt bibliotek.sol-program ser ut så här:

pragmasoliditet ^ 0.4.19;

kontraktsbibliotek {

funktionstest() {}

}

Och testBiblioteket ser ut så här:

pragmasoliditet ^ 0.4.19;

importera "webbläsare / library.sol";

kontraktstest Bibliotek är bibliotek {

}

TestLibrary-programmet importerar helt enkelt biblioteksfilen som lagras på platsen: browser / library.sol. Alla soliditetsprogram sparas som standard i webbläsarmappen.

Få åtkomst till modifierare och reservfunktioner

Åtkomstmodifierare och Fallback-funktioner är roliga små verktyg som du kan använda för att krydda dina kontrakt. Låt oss börja med reservfunktioner. Kolla in följande kod:

pragmasoliditet ^ 0.4.19;

kontraktstestTransaktion {

händelse SenderLogger (adress);

händelse ValueLogger (uint);

funktion () betalas {

SenderLogger (msg.sender);

ValueLogger (msg.value);

}

}

Detta är ett enkelt smart kontrakt som låter dig extrahera detaljerna i en transaktion. I grund och botten, om någon skickar Ether till detta kontrakt, kommer detta kontrakt att extrahera:

  • Avsändarens adress
  • Mängden eter som de skickar.

Reservfunktionen finns här:

 funktion () betalas {

SenderLogger (msg.sender);

ValueLogger (msg.value);

}

Som du kan se har funktionen inget namn och du kan bara sätta in en reservfunktion i varje kontrakt. Tanken är att göra det möjligt för alla att komma i kontakt med kontraktet och skicka Ether-tokens till det.

Så låt oss köra programmet och se lite data. Vi ska distribuera kontraktet. Sätt 1 eter i fältet “värde” och tryck på “reserv” -knappen.

Introduktion till Javascript and Solidity-Part 2: Solidity

Så nu ska vi kontrollera loggarna.

Introduktion till Javascript and Solidity-Part 2: Solidity

Det sista fältet i tabellen i värdefältet som visar mängden eter i wei som har skickats till kontraktet.

Okej, så låt oss nu sätta några modifierare i programmet och ändra saker.

pragmasoliditet ^ 0.4.19;

kontraktstransaktion {

händelse SenderLogger (adress);

händelse ValueLogger (uint);

adressera privat ägare;

modifierare isOwner {

kräver (ägare == msg.sender);

_;

}

modifier validvalue {

hävda (msg.värde >= 1 eter);

_;

}

funktionstransaktion () {

ägare = msg.sändare;

}

function () betalas isOwner validValue {

SenderLogger (msg.sender);

ValueLogger (msg.value);

}

}

Ok, så det här kontraktet är detsamma som det tidigare. Vi vill fortfarande extrahera transaktionsinformation. Vi har dock lagt till följande två villkor:

  • Endast ägaren av kontraktet kan skicka transaktionen
  • Transaktionen bör vara minst 1 eter

Så, låt oss titta på en modifierare och se hur vi utför den:

modifierare isOwner {

       kräver (ägare == msg.sender);

       _;

   }

Så vad gör vi exakt här??

Vi har förklarat en modifierare, som i grunden är en anpassad åtkomstkontrollfunktion, som kör en ”kräver” -funktion för att se till att endast ägaren kan använda kontraktet.

Märker du också “_;”?

Detta indikerar att efter att åtkomstmodifieraren har körts, måste funktionen vars ingång den skyddar också köras.

Låt oss kolla vår nästa modifierare:

modifier validvalue {

       hävda (msg.värde >= 1 eter);

       _;

   }

Detta är återigen en enkel modifierare som kontrollerar om värdet som överförs till kontraktet är större än 1 eter eller inte.

Okej, så nu när vi har definierat dessa modifierare, hur exakt ska vi använda dem i funktionen? Tja, låt oss kolla in det:

function () betalas isOwner validValue {

       SenderLogger (msg.sender);

       ValueLogger (msg.value);

   }

Ser du vår reservfunktion nu? Vi har lagt till åtkomstmodifierarna i funktionshuvudet för att begränsa åtkomsten till den. Nu ska vi köra kontraktet genom Remix och se vad vi får här.

Låt oss lägga till en eter i värdefältet och se vad vi får.

Introduktion till Javascript and Solidity-Part 2: Solidity

Loggen visar:

  • Avsändarens adress
  • Värdet av Ether placerat i kontraktet

Vad händer nu om vi:

  • Skicka mindre än 1 eter
  • Skicka eter från en annan adress

Mindre än 1 eter

Vi skickade 0,2 eter i värdefältet och programmet gav omedelbart ett fel:

Introduktion till Javascript and Solidity-Part 2: Solidity

Från en annan adress

Vi skickade 1 eter från en annan adress. Återigen får vi ett fel:

Introduktion till Javascript and Solidity-Part 2: Solidity

Strukturer och kartläggning i fasthet

Innan vi avslutar den här guiden vill vi bekanta dig med ytterligare två begrepp som du kommer att stöta på när du kodar.

  • Strukturer
  • Kartläggning

Strukturer är objekt som saknar metoder. De definierar bara variablerna.

Kartläggning i soliditet är ungefär som en hash-tabell som initialiserades praktiskt taget så att varje potentiell nyckel finns. Kartläggning kan förklaras så här:

mapping (A => B).

A = Kan vara av vilken typ som helst, förutom mappning, array, enum, kontrakt och struktur.

B = Kan vara av vilken typ som helst (inklusive kartläggning).

Låt oss köra ett program som innehåller båda dessa funktioner:

pragmasoliditet ^ 0.4.19;

kontraktsvisningskarta {

//Sektion 1

strukturera konto {

obalans

}

Konto myAccount;

funktion structFunc () {

myAccount.balance = 100;

}

//sektion 2

mapping (adress => Konto) _konton;

funktion () betalas {

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

}

funktion getBalance () returnerar (uint) {

returnera _accounts [msg.sender] .balance;

}

}

Sektion 1

Så vi har förklarat en struktur med namnet Konto som har en icke-datatyp som heter “balans”. Vi initierade sedan en variabel med namnet myAccount av typen konto och använde sedan structFunc () -funktionen för att tilldela värdet 100 till myAccount.balance.

Sektion 2

Genom att använda nyckelordet kartläggning kartlägger vi adresser till vår kontostruktur och kallar det “_konton”.

Vi har sedan en reservfunktion för att lägga till den eter som användaren har fått i sin balans. Funktionen getBalance () returnerar sedan värdet på det uppdaterade saldot till användaren.

Låt oss titta på detta i aktion.

Vi kommer att skicka 10 Ether till det smarta kontraktet.

Så med hjälp av reservfunktionen skickade vi 10 Ether till kontot som du kan se i loggen här:

Introduktion till Javascript and Solidity-Part 2: Solidity

Så om vi får Balans just nu är det vad vi får:

Introduktion till Javascript and Solidity-Part 2: Solidity

Lägg märke till fältet “avkodat utmatning” och se hur balansen återspeglas som 10 eter.

Introduktion till Javascript and Solidity-Part 2: Solidity

Nu ska vi skicka ytterligare 10 Ether till kontraktet via reservfunktionen och låt oss kontrollera saldot igen via getBalance ().

Om du ser getBalance () -fältet kommer du att märka att balansen återspeglar 20 Ether.

Slutsats

Det ligger mycket mer i soliditet än vad vi har täckt här. Inom en snar framtid kommer vi att visa dig hur du kan skapa din egen kryptovaluta med soliditet.

Men för nu, om du vill utbilda dig ännu mer, kan du anmäla dig till våra soliditetskurser. Vi har extremt välutbildade lärare som kommer att vägleda dig genom din resa som utvecklare.

Du kan också kolla in dessa serier av videor av “What’s Solidity”. De har fantastiska videor och majoriteten av koden som används här har hämtats från deras gitHub-sida.

Syftet med dessa två artiklar var att ge dig en introduktion till både JavaScript och soliditet. Vi hoppas att du har dina grunder tydliga nu för att ta på dig mer utmanande program / kontrakt.

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