Introduktion till Javascript and Solidity – Del 1: Javascript

Ethereum har fått en unik nisch för sig själv i kryptospacen som en smart kontraktsplattform. Utvecklare från hela världen kan delta i att skapa sina egna decentraliserade applikationer direkt ovanpå Ethereum blockchain. Men för att göra det måste utvecklare vara mycket välbevandrade i soliditet, språket som används för att koda smarta kontrakt.

Introduktion till Javascript and Solidity, del 1

Introduktion till Javascript and Solidity

Syftet med den här guiden är att rensa upp dina grunder i soliditet. Om du vill ha en mer avancerad kurs föreslår vi att du går igenom våra soliditetskurser. Den här guiden kommer bara att rensa dina grunder.

Så innan du börjar soliditet finns det två saker du bör veta:

  • Grunderna i Ethereum blockchain
  • Grunderna i JavaScript

Om du vill lära dig grunderna i blockchain-tekniken och Ethereum i allmänhet kan du leta upp våra guider för att rensa detta för dig.

Så nu kommer vi till den andra punkten.

Varför behöver du grundläggande kunskaper om JavaScript?

För det första, som soliditetsdokumentet säger, påverkas det av JavaScript. För det andra, som många har noterat, är soliditeten ganska lik JavaScript när det gäller syntax. Anledningen till detta är ganska enkel.

JavaScript råkar vara ett av de mest efterfrågade och populära språken i världen. Ethereum-grundarna ansåg att utvecklare kommer att kunna hämta det snabbare om de modellerade soliditet efter JavaScript. Så låt oss börja med JavaScript innan vi fördjupar oss i soliditet, som vi kommer att täcka i del 2 i denna artikel.

Javascript and Solidity Introduction

JavaScript skapades av Brendan Eich, som senare fortsätter att hitta Mozilla Firefox och Brave browser. JavaScript eller JS är ett lätt, dynamiskt och objektorienterat programmeringsspråk. JavaScript utgör tillsammans med HTML och CSS de tre pelarna för webbdesign. HTML hjälper till att sätta innehåll på din webbplats medan CSS hjälper dig med designlayouten.

Så vad gör JS exakt?

Innan JavaScript kom fram brukade webbplatser vara extremt statiska. JavaScript förde tiden med mer användarvänliga och dynamiska webbplatser. När du håller detta i sitt sammanhang och inser hur mycket affärer som görs online kan du se varför du kan göra ett så starkt argument för Javascript. JS gjorde ensamma webbplatser mer användarvänliga.

Även om JavaScript ursprungligen skulle vara ett skript på klientsidan, har flera implementeringar som node.js också möjliggjort implementering på serversidan. JavaScript hanteras officiellt av Mozilla Foundation och nya språkfunktioner läggs till regelbundet.

Funktioner i JavaScript

Följande är funktioner i JavaScript

  • Alla moderna webbläsare har en inbyggd JavaScript-motor. I själva verket kommer vi att ta en närmare titt på detta senare
  • JavaScript har en strukturerad programmeringssyntax och har funktionell och blockering. Oroa dig inte, vi kommer att täcka omfattningen lite
  • JavaScript är dynamiskt skrivet. Det betyder att en variabel som lagrade helvärden för ett ögonblick sedan kan lagra en sträng under körning
  • JavaScript är ett objektorienterat programmeringsspråk. Vi kommer att täcka detta lite
  • JavaScript är ett funktionellt språk. Så det stöder modulering via funktioner
  • JavaScript stöder också implicit och uttrycklig delegering.
  • JavaScript är skiftlägeskänsligt, så “bredd” skiljer sig från “bredd”.

Okej, så låt oss bara titta på var och en av dessa funktioner i detalj.

Funktion nr 1: Webbläsare med inbyggd JS

Vi kommer att använda Google Chrome för detta.

Öppna bara en ny flik i din webbläsare. Högerklicka var som helst i webbläsaren och klicka på “Inspektera”.

Introduktion till Javascript and Solidity (Blockgeeks)

När du klickar på det kommer du att se det här fönstret:

Introduktion till Javascript and Solidity (Blockgeeks)

Detta är den inbyggda konsolen i Google Chrome-webbläsarna. För att fissa med JS-verktygen kan du helt enkelt gå till konsoldelen. Vilket är här:

Introduktion till Javascript and Solidity (Blockgeeks)

Okej … så låt oss få kodning!!!

Du kan göra enkla matematiska operationer här:

Introduktion till Javascript and Solidity (Blockgeeks)

Eller om du vill kan du göra det enkla “Hello World” -programmet här.

För detta ska vi skriva “console.log (” Hello World “);”

Introduktion till Javascript and Solidity (Blockgeeks)

“Console.log ()” är den funktion som låter oss skriva ut utdata på konsolen. Lägg också märke till hur vi avslutade funktionen med “;”. I JS måste du använda semikolon för att avsluta instruktionerna.

I det ögonblick du anger kommandot och trycker på “Enter” kommer du att få utdata i själva konsolen.

Intressant nog, om du vill att utdata ska dyka upp på din skärm kan du helt enkelt använda funktionen “alert ()”. Så om du skriver “alert (” Hello World “);” på din konsol så kommer du att se detta.

Introduktion till Javascript and Solidity (Blockgeeks)

Ganska coolt rätt?

Nu ville vi bara komma igång med den mest grundläggande formen av programmering för att visa dig JS-motorn inuti webbläsarna. Vi kommer att gå djupare in i programmeringen lite senare.

Funktion # 2: Funktionell och Block Scoping

För att förstå skillnaden mellan funktionell och block scoping, måste du veta lite om variabeldeklaration i JS.

I C ++ kan du göra detta när du vill deklarera en heltalsvariabel:

int a;

I Java behöver du inte oroa dig för den enskilda datatypen, eftersom språket är dynamiskt skrivet. Du har tre alternativ som du kan använda för att deklarera din variabel: var, let och const.

Var

Var är ett mycket enkelt sätt att tilldela och variabler.

var a = 10;

console.log (a);

// det återkommer

10

a = 20;

// för att visa dynamisk omplacering

console.log (a);

20

Så, var verkar ganska enkelt, eller hur?

Det anses dock inte vara någon bra metod att använda var i programmering längre eftersom var-variabler är ”funktionsomfång”. Detta innebär att var-variablerna deklareras inuti en funktion så att de bara är tillgängliga inuti funktionen, eller om de inte skapas inuti en funktion är de “globalt omfattade”, vilket betyder att de är tillgängliga överallt.

Låt oss se hur detta fungerar. Tänk på följande program (Hämtad från Denna artikel):

function setWidth () {

var bredd = 100;

console.log (bredd);

}

bredd;

Om du försöker köra det här programmet kommer du att se följande fel.

Introduktion till Javascript and Solidity (Blockgeeks)

Kan du gissa varför?

Den “bredd” som vi har deklarerat som “var” förklarades inuti funktionen. Det är därför den är giltig endast inom funktionens omfång och ingen annanstans.

På samma sätt har vi nu den andra ytterligheten.

Tänk på följande kod:

var ålder = 100;

om (ålder > 12) {

var dogYears = ålder * 7;

console.log (`Du är $ {dogYears} hund år gammal!`);

}

Två saker som du behöver notera om koden ovan.

För det första, användningen av “$ (dogYears)”, detta säkerställer att du skriver ut värdet på variabeln. För det andra deklareras inte var-variablerna i en funktion. På grund av detta är de inte bundna av ett omfång och kan därför kallas även efter utförande.

Du är 700 hund år gammal!

Men nu, om du går på konsolen och ringer dogYears kommer det att returnera 700 till dig.

Vet du varför detta hände?

Genom att inte förklara variabeln i en funktion gjorde vi den global.

Så kom ihåg detta för framtida referens, var är inte begränsad till de lockiga parenteserna. Det är funktionen som definierar omfattningen.

Det är därför vi istället för var använder let och const.

Varför använda låt och konst?

I skarp kontrast är låt och konst scoper till ett block som fungerar. Ett block definieras som en uppsättning öppningsbara “{” och stängande “}” lockiga parenteser.

Så om vi hade förklarat hundår med “låt” i motsats till “var” vad tror du kommer att hända?

var ålder = 100;

om (ålder > 12) {

låt dogYears = ålder * 7;

console.log (`Du är $ {dogYears} hund år gammal!`);

}

Den förklaras inuti ett ”if” -block, så variabelns livstid är över så snart blocket slutar.

Notera: Vi kommer att täcka if-else-funktionen lite.

Så nu när du kör programmet (inuti visuell kod) och ringer dogYears i konsolen får du följande meddelande:

“Uncaught ReferenceError: dogYears definieras inte.”

Du kan också använda const istället för att låta deklarera dessa variabler. Att använda const gör dock dina variabler oföränderliga. Så om du planerar att ändra värdet under körning får du ett fel:

Introduktion till Javascript and Solidity (Blockgeeks)

Funktion # 3: Dynamiskt skriven

Dynamiskt skriven betyder att variablerna kan ändra sina typer under hela genomförandet av programmet. Så om du har en variabel som lagrar en sträng kan den under körningen också spara ett heltal.

Så gå på din konsol och kör detta:

låt var2 = 10;

var2 = ‘Hej’;

Om du ringer till var2 nu kommer den att returnera ”Hej”, trots att du ursprungligen förklarade det med ett heltal.

I själva verket varför inte göra något mer djupgående och faktiskt observera hur variabeln ändrar sitt tillstånd?

För detta använder vi funktionen “typeof ()”. Denna funktion berättar specifikt vilken typ av variabel du använder. Tänk på samma exempel som vi gav ovan.

Introduktion till Javascript and Solidity (Blockgeeks)

Så när var2 hade ett nummer, var dess typ nummer. Men när ögonblicket lagrades “Hello” ändrades det till sträng.

Funktion # 5: Objektorienterat programmeringsspråk

JavaScript är ett objektorienterat programmeringsspråk (OOP) i motsats till ett processorienterat språk. Processorienterade språk som C använde program där en lista med instruktioner som fungerade på minnet.

OOP: er, å andra sidan, möjliggör skapandet av en ritning som kallas “klass” varifrån man kan generera objekt som kan interagera med varandra. Dessa objekt kör programmet.

Nu finns det fyra pelare till OOP: er:

  • Inkapsling
  • Abstraktion
  • Polymorfism
  • Arv

Introduktion till Javascript and Solidity (Blockgeeks)

Inkapsling

Inkapsling är tanken på att slå samman data och funktion inom en enhet. Tanken är att dölja föremålens ursprungliga tillstånd och att binda allt i en fast förpackning.

Abstraktion

Abstraktion innebär att en användare kan använda programmet utan att komma in i komplikationerna bakom det.

Tänk på en bil.

När du kör bil är allt du bryr dig om att sätta in nyckeln och manövrera fordonet på ett sätt som du inte träffar något annat. Du bryr dig inte om hur motorerna fungerar och hur tändningen bränner ditt bränsle.

Arv

Arv är en av de viktigaste egenskaperna hos OOP.

Med arv kan ett objekt eller en klass baseras på ett annat objekt eller en klass och behålla några av dess implementeringar. På de flesta klassbaserade objektorienterade språk förvärvar ett objekt som skapas genom arv de flesta egenskaper och beteenden hos det överordnade objektet

Polymorfism

Polymorfism är den egenskap genom vilken en operatör på språket kan ha mer än en egenskap. Det mest kända exemplet på detta är “+”. Det används inte bara som den matematiska tilläggsoperatören, men det kan också användas för att kombinera två strängar till en också. Detta kallas sammanfogning.

Introduktion till Javascript and Solidity (Blockgeeks)

Feature # 6: Implicit och Explicit Delegation

Delegering innebär i princip att ett objekt kan definieras i termerna av ett annat objekt. Delegering betyder i stort sett delegering av ansvar. Nu kan delegering vara både explicit eller implicit.

Med uttrycklig delegering kan ett objekt uttryckligen delegera ett meddelande till alla andra objekt det har kunskap om. Med implicit delegering kan ett objekt uttryckligen beteckna ett annat objekt som “förälder”. Meddelanden som inte förstås av det mottagande objektet delegeras automatiskt (implicit) till denna förälder.

Implicit delegering kan delas upp i ytterligare två kategorier:

  • Oförutsedd delegering, där delegationsstrukturen kan ändras dynamiskt under körning.
  • Förväntad delegering, där objekten inte kan ändra det överordnade objektet som de har ärvt från under sin livstid.

Innan vi börjar koda

Nu när vi är klara med teorin, för det mesta, låt oss börja koda! För att kunna genomföra dessa program behöver du en miljö där du kan köra dem.

Vi använder Visual Studio-koden. För att göra det, gå till code.visualstudio.com och ladda ner den senaste versionen av Visual Studio.

När du är klar med installationen ser du den här skärmen.

Introduktion till Javascript and Solidity (Blockgeeks)

Gå vidare till Arkiv ->Öppen

Därefter måste du skapa en mapp. Låt oss kalla den här mappen “Blockgeeks-JS”.

Introduktion till Javascript and Solidity (Blockgeeks)

Efter det finns det två saker du behöver göra:

Introduktion till Javascript and Solidity (Blockgeeks)

Och efter att ha klickat på den knappen skapar du en fil som heter “index.html”.

Introduktion till Javascript and Solidity (Blockgeeks)

Skriv “!” På den första koden i den här nya filen. följt av en flik.

Introduktion till Javascript and Solidity (Blockgeeks)

I det ögonblick du gör det ser du ett block med HTML-kod visas på skärmen. Du behöver inte riktigt bry dig om den här koden. Det ger i grunden en värd där vi kan använda vår JS-kod.

Klicka därefter på tilläggsknappen enligt nedan:

Introduktion till Javascript and Solidity (Blockgeeks)

Sök nu efter “Live Server” och installera tillägget.

Introduktion till Javascript and Solidity (Blockgeeks)

När det är installerat, gå till din “index.html” -fil och välj “Öppna med Live Server”.

Introduktion till Javascript and Solidity (Blockgeeks)

Vad detta nu gör är att det låter dig köra JS-programmen i din standardwebbläsare. I det ögonblick du väljer det här alternativet bör en ny flik öppnas i din webbläsare.

Okej, nu ska vi titta på vår HTML-kod i “index.html”.

<!DOCTYPE html>

<html lang ="sv">

<huvud>

<metatecken ="UTF-8">

<metanamn ="visningsport" innehåll ="bredd = enhetsbredd, initialskala = 1.0">

<meta http-equiv ="X-UA-kompatibel" innehåll ="dvs = kant">

<titel>Dokument titel>

huvud>

<kropp>

kropp>

html>

Nu kan du börja koda i kroppsområdet. T.ex. låt oss lägga till en rubriktagg i kroppsområdet och fylla den med lite innehåll.

<!DOCTYPE html>

<html lang ="sv">

<huvud>

<metatecken ="UTF-8">

<metanamn ="visningsport" innehåll ="bredd = enhetsbredd, initialskala = 1.0">

<meta http-equiv ="X-UA-kompatibel" innehåll ="dvs = kant">

<titel>Dokument titel>

huvud>

<kropp>

<h1> VÄLKOMMEN TILL BLOCKGEEKS! H1>

kropp>

html>

Spara nu den här filen och titta på den nya fliken som öppnades.

Ganska coolt rätt!

Så nu ska vi börja med JavaScript.

I kroppen, precis under rubriktaggen, låt oss lägga till skriptetiketten och skriva ut “Hello World” på konsolen.

<!DOCTYPE html>

<html lang ="sv">

<huvud>

<metatecken ="UTF-8">

<metanamn ="visningsport" innehåll ="bredd = enhetsbredd, initialskala = 1.0">

<meta http-equiv ="X-UA-kompatibel" innehåll ="dvs = kant">

<titel>Dokument titel>

huvud>

<kropp>

<h1> VÄLKOMMEN TILL BLOCKGEEKS! H1>

<manus> console.log (‘Hello World’); skript>

kropp>

html>

Efter det är det bara att gå till fliken. Högerklicka på den och välj “inspektera” och gå sedan till konsolfliken som vi har visat dig tidigare.

Det här är vad du kommer att se:

NOTERA: Anledningen till att vi lägger in skriptdelen i avsnittet Body istället för Head-avsnittet är att vi inte vill att JavaScript ska köras även innan webbplatsinnehållet laddas upp.

Nu anger standardmetoder för bästa programmering att du inte ska koda JS-saker i HTML-programmet. HTML-delen och JS-delen bör hållas åtskilda.

Skript kan också bli riktigt långa och komplicerade så det är inte meningsfullt att försöka pressa in all kod inuti HTML-koden.

Så det är därför vi kommer att skapa en ny ny fil och ge den namnet “index.js”..

Introduktion till Javascript and Solidity (Blockgeeks)

I den här delen kommer vi att lägga allt vi har lagt in i skriptetiketten, nämligen:

Men “index.html” -filen är huvudfilen. Vi bör lägga in en ny kodrad som hjälper huvudfilen att hänvisa till JS-filen. Hur vi ska göra det är att göra en liten modifiering.

<!DOCTYPE html>

<html lang ="sv">

<huvud>

<metatecken ="UTF-8">

<metanamn ="visningsport" innehåll ="bredd = enhetsbredd, initialskala = 1.0">

<meta http-equiv ="X-UA-kompatibel" innehåll ="dvs = kant">

<titel>Dokument titel>

huvud>

<kropp>

<h1> VÄLKOMMEN TILL BLOCKGEEKS! H1>

<skript src = ”index.js”>manus>

kropp>

html>

Vad detta gör är att det visar HTML-programmet var exakt JS-programmet finns. Se också till att SPARA ALLTID dina .html- och .js-filer.

Vad detta gör är att det visar HTML-programmet var exakt JS-programmet finns.

Se också till att SPARA ALLTID dina .html- och .js-filer.

Okej, så det täcker ganska mycket grunderna. Låt oss göra lite kodning!

Enkel kodning

# 1 Matematiska operationer

Låt oss göra några grundläggande matematiska operationer på JS.

låt a = 10;

låt b = 20;

låt c = 30;

låt d = a + b * c;

console.log (d);

Vad tror du att svaret blir?

Tror du att svaret är 900?

Tja, låt oss genomföra programmet och se vad vi får?

Introduktion till Javascript and Solidity (Blockgeeks)

610.

Varför tror du att vi har det?

Du förstår, istället för att gå från vänster till höger, följer JS PEMDAS där:

P = Parentes

E = Exponent

M = multiplikation

D = Division

A = tillägg

S = Subtraktion

Så, operationen följer denna prioritetsordning i stigande ordning:

P

E

MD

SOM

Multiplikation och division har samma preferensordning. Så gör Addition och Subtraktion.

# 2 Arrayer

En matris är en datastruktur som innehåller en grupp av element. Normalt är alla dessa element av samma datatyp (inte nödvändigt för JavaScript), till exempel ett heltal eller en sträng. Arrayer används ofta i program för att organisera data så att en relaterad uppsättning värden enkelt kan sorteras eller sökas.

Kolla in koden nedan:

let names = [‘Mark’, ‘Will’];

console.log (namn);

Introduktion till Javascript and Solidity (Blockgeeks)

Ser du pilen bredvid “(2)”? När du klickar på det expanderar det för att avslöja följande:

Enligt det här:

  • Matrisens längd är 2 eftersom den har två element
  • Indexet för det första elementet “Mark” är 0
  • Indexet för det andra elementet ”Will” är 1

Vi kan dynamiskt lägga till element i matrisen också under körning. Här kolla in det:

let names = [‘Mark’, ‘Will’];

namn [2] = ‘Kumar’;

console.log (namn);

När du skriver ut detta i konsolen får du:

Som du kan se har vi matrisen att expandera med ett enda element under körning. Nu, i Javascript, behöver du inte lägga till samma datatyp. Vad sägs om att vi lägger till ett nummer i matrisen?

let names = [‘Mark’, ‘Will’];

namn [2] = ‘Kumar’;

namn [3] = 1;

console.log (namn);

Resultatet ser nu ut så här:

Introduktion till Javascript and Solidity (Blockgeeks)

Innan vi avslutar arrays. Det finns en sak till.

Du kan kontrollera längden på matrisen så här:

let names = [‘Mark’, ‘Will’];

namn [2] = ‘Kumar’;

namn [3] = 1;

console.log (namn.längd);

Nu ser produktionen ut så här:

Introduktion till Javascript and Solidity (Blockgeeks)

Arrayens längd är 4.

# 3 Funktioner

Nästa steg har vi funktioner som lätt är en av de viktigaste delarna av programmen. Genom att förklara funktioner kommer du att göra ditt arbete mycket enklare och minska mycket repetition. Funktionerna innehåller en kodenhet som fungerar på olika ingångar, varav många är variabler, och ger konkreta resultat med ändringar av variabla värden eller faktiska operationer baserat på ingångarna. Man kan anropa dessa funktioner under programkörningen och köra koden.

Låt oss se ett exempel.

funktion brådskande () {

console.log (‘Watch JRE 1169’);

}

brådskande();

Funktionen ovan skriver ut ett meddelande. När vi har deklarerat funktionen kallar vi helt enkelt funktionen för att utföra den. Låt oss titta på produktionen:

Introduktion till Javascript and Solidity (Blockgeeks)

Nu ska vi lägga till lite mer krydda till mixen.

funktion brådskande (num) {

console.log (‘Watch JRE’ + num);

}

brådskande (1169);

Låt oss titta på produktionen:

Introduktion till Javascript and Solidity (Blockgeeks)

Låt oss nu öka antalet parametrar i funktionen och antalet funktionssamtal.

funktionsanvändarnamn (förnamn, efternamn) {

console.log (‘Namnet är’ + förnamn + ” + efternamn);

}

användarnamn (‘Vitalik’, ‘Buterin’);

användarnamn (‘Satoshi’, ‘Nakamoto’);

Så när du kör den här koden får du följande utdata:

Introduktion till Javascript and Solidity (Blockgeeks)

En av funktionens bästa egenskaper är att returnera värden. Så du kan ha en funktion som gör komplexa matematiska processer och använda den för att returnera värden till en variabel.

Vad sägs om att vi deklarerar en funktion som beräknar kvadraten på ett tal och returnerar värdet:

funktions kvadrat (num) {

returnera num * num;

}

låt resultat = kvadrat (2);

console.log (‘Kvadraten på 2 är’ + resultat);

Utgången blir:

Introduktion till Javascript and Solidity (Blockgeeks)

# 4 Villkorliga uttalanden

Villkorliga uttalanden som “if-else” är en hörnsten i programmeringen. Du kan göra detsamma i JavaScript som vi redan har sett tidigare. Tänk på den här koden:

låt a = 20;

låt b = 30;

Om en > b) {

console.log (a + ‘är större’);

} annat {

console.log (b + ‘är större’);

}

Detta är ett enkelt program som kontrollerar och skriver ut det större antalet.

Ovanstående kod ger följande utdata:

Introduktion till Javascript and Solidity (Blockgeeks)

# 5 loopar

Looping gör att programmet kan köra den kod som ges inuti slingan för att köras ett visst antal gånger.

Innan vi fortsätter måste du veta vad inkrementering (eller dekrementering betyder).

Inkrementering innebär att värdet på en viss variabel ökas med ett visst belopp. Så om vi vill öka värdet som lagras i en viss variabel, som “a”, med 1 gör vi:

a = a +1;

ELLER för att göra det mer effektivt gör vi helt enkelt “a ++”, vilket är detsamma som a = a + 1;

På samma sätt gör vi för att minska värdet:

a = a-1;

Eller

a–;

Okej, så tillbaka till öglor.

Loop-uttalandena som används i JavaScript är:

  • Medan
  • Göra medan
  • För

While Loop

While-loop är den enklaste formen av ett loop-uttalande. Det fungerar så här:

medan (villkor) {

Påstående;

Ökning;

}

Tänk på detta:

låt i = 1;

medan jag < 3) {

console.log (i);

i ++;

}

Att köra den här koden ger följande utdata:

Så vad hände här?

Vi initierade en variabel till 1 och instruerade programmet att skriva ut variabeln så länge värdet på den är mindre än 1. Inom slingan fortsatte vi att öka värdet “i”. Om vi ​​inte hade ökat det hade programmet varit i en oändlig slinga.

Do-While Loop

Do-While-slingan ser ut så här:

do{

Påstående;

Ökning;

} medan (villkor);

Så, i motsats till while-loop, kör-while-looparna koden först och kontrollerar tillståndet senare.

Se nu den här koden:

låt i = 1;

do{

console.log (i);

i ++;

} medan jag<3);

Detta kommer att skriva ut:

Så, vad är skillnaden mellan medan och under tiden som programmet körs. Tja, kontrollera följande exempel:

låt i = 1;

console.log (‘Först kommer vi att kontrollera stundslingan’);

medan jag < 1) {

console.log (‘Detta är inne i while-slingan’);

}

console.log (‘Nu ska vi kolla under tiden’);

do{

console.log (‘This is inside the do-while loop’);

} medan jag < 1);

console.log (‘Vi är utanför slingorna nu’);

Utgången är:

Introduktion till Javascript and Solidity (Blockgeeks)

Så vad gör vi här?

Först körde vi stundslingan. Eftersom denna slinga kontrollerar tillståndet i förväg tillät det inte ens kompilatorn att gå in i kroppen. Därför utfördes inte uttalandet inuti while-slingan.

Eftersom do-while-slingan utför uttalandet innan tillståndet kontrollerades, kördes dock uttalandet inuti kroppen.

För Loop

For-loop har följande struktur:

för (Initialisering; Villkor; Inkrementering)

{

Påstående;

}

Så, för slingan tar hand om tillståndet och inkrementeringen i dess parametrar i sig. Hur ser detta ut under körning?

för (låt i = 1; i <= 5; i ++)

{

console.log (i);

}

Detta program ger följande resultat:

Introduktion till Javascript and Solidity (Blockgeeks)

Objektorienterad programmering i JavaScript

Okej, så nu kommer vi till en av de viktigaste aspekterna av JavaScript, objektorienterad programmering. Tänk på följande kod:

låt Max = {

skola: ‘Central High’,

ålder: 14,

födelseplats: ‘New York’

};

console.log (Max);

Så vi har förklarat ett objekt som heter “Max” och förklarar elementen i detta objekt, namn:

  • Där Max går i skolan
  • Vad är Maxs ålder
  • Var föddes han

Så när du skriver ut objektet Max får du det här:

Okej, antag nu att Max just hade sin födelsedag. Hur ändrar vi hans ålder?

låt Max = {

skola: ‘Central High’,

ålder: 14,

födelseplats: ‘New York’

};

Max. Ålder = 15;

console.log (Max);

;

Så det här är den produktion vi fick nu:

Introduktion till Javascript and Solidity (Blockgeeks)

Nu ska vi förklara ett objekt med en funktion inuti det:

låt cirkel = {

område: funktion () {

låt radie = 2;

låt a = 3,14 * radie * radie;

console.log (‘Området är’ + a);

}

};

circle.area ();

Återigen ett ganska enkelt föremål. Vi har förklarat ett objekt som kallas cirkel som har en areafunktion inuti som beräknar och skriver ut området.

Fabriksfunktioner

Sättet vi har förklarat vårt objekt ovan är extremt ineffektivt när vi måste hantera flera objekt. Kom ihåg koden vi just använde. Vad händer om vi måste beräkna ytan för två cirklar? I så fall har vi inget annat val än att bara upprepa koden med olika värden.

låt cirkel = {

område: funktion () {

låt radie = 1;

låt a = 3,14 * radie * radie;

console.log (‘Området är’ + a);

}

};

circle.area ();

låt cirkel1 = {

område: funktion () {

låt radie = 2;

låt a = 3,14 * radie * radie;

console.log (‘Området är’ + a);

}

};

cirkel1.area ();

Tänk nu, om vi istället för bara en funktion har 10 funktioner per objekt. Kan du föreställa dig hur rörig den koden kommer att bli?

Tänk dig också hur svårt att felsöka koden (skanna koden för potentiella fel) kommer att bli om vi följer det här formatet.

Det är därför vi använder något som kallas ”fabriksfunktioner” för att göra vår kod mer användbar och ren.

Tänk på följande kod:

// skapa fabriksfunktionen som tar in en parameter

funktion createCircle (radie) {

// funktionen returnerar detta värde som är ett objekt

lämna tillbaka {

område: funktion () {

låt området = 3,14 * radie * radie;

console.log (område);

}

};

}

// skapa objektet som får sitt värde från fabriksfunktionen

låt cirkel = createCircle (1);

circle.area ();

// dynamiskt uppdatera objektet med samma fabriksfunktion

cirkel = createCircle (2);

circle.area ();

Okej, så låt oss se vad som händer här.

Vi har en fabriksfunktion som heter “createCircle ()” som anger ritningen för alla objekt som vi ska skapa.

Det tar in en parameter som kallas “radie” som hjälper oss att skapa olika objekt med unika värden. Funktionen returnerar värdena till ett nytt objekt. Så när vi kör ovanstående kod får vi följande utdata:

Introduktion till Javascript and Solidity (Blockgeeks)

En fabriksfunktion är inte det enda sättet att initiera ett objekt, du har också konstruktörer.

Konstruktörer

Så hur ser en konstruktör ut?

funktion Cirkel (radie) {

this.area = funktion () {

låt a = 3,14 * radie * radie;

console.log (a);

}

}

låt cirkel = ny cirkel (1);

circle.area ();

låt cirkel1 = ny cirkel (2);

cirkel1.area ();

Circle () är den konstruktör som vi har använt här. Enligt namngivningskonventioner måste en konstruktör alltid börja med en stor bokstav. Det finns ytterligare två saker du kanske har lagt märke till i koden som vi inte har pratat om tidigare:

  • Det “nya” nyckelordet
  • Nyckelordet “detta”

Det “nya” nyckelordet hjälper till med att skapa objekt via konstruktören. Det skapar i grunden ett tomt, tomt objekt.

Nyckelordet “detta” hjälper till att specificera att variabeln eller funktionen tillhör just detta objekt. T.ex. i koden ovan, “this.area” visar kompilatorn att antingen områdesfunktionen antingen tillhör cirkelobjektet eller cirkel1-objektet. Värdet av “detta” i en funktion beror effektivt på objektet som kallade det.

Låt oss se vad som händer om vi tar bort “nyckelordet” i koden ovan. Låt oss se resultatet. Så vår modifierade kod är:

funktion Cirkel (radie) {

område = funktion () {

låt a = 3,14 * radie * radie;

console.log (a);

}

}

låt cirkel = ny cirkel (1);

circle.area ();

låt cirkel1 = ny cirkel (2);

circle1.area ()

När du kör det här programmet får du det här felet:

Introduktion till Javascript and Solidity (Blockgeeks)

Javaskript och fasthet: Slutsats

Vad vi har gett dig här är en extremt grundläggande introduktion. JavaScript är ett brett ämne med många potentialer. Om du vill hålla dig uppdaterad krävs kontinuerlig utbildning. Vi har använt följande videor som referens:

https://www.youtube.com/watch?v=PwsigsH4oXw

https://www.youtube.com/watch?v=PFmuCDHHpwk

Om du vill utbilda dig själv, gå och kolla in deras respektive kanaler.

Detta är det också för del 1.

I nästa del kommer vi att starta soliditet!!

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