Go er et av de moderne programmeringsspråkene som får gjennomslag i mange undersøkelser ettersom utviklere foretrakk språk. Go har en enkel å bruke og forstå syntaks samtidig som den gir ytelse på toppnivå.

Du kan bruke Go til å bygge ulike applikasjoner, fra nettapper til kommandolinjeapper, skytjenester og nettverk. Gos økosystem av tredjepartspakker støtter mange andre brukstilfeller.

Go har de fleste funksjonene du kan forvente på et moderne språk: generikk, samtidighet, typeslutning, søppelinnsamling og mange flere.

Komme i gang med Go

Du kan kjøre Go på de fleste operativsystemer. Drar mot installasjonssiden og last ned en foretrukket Go-versjon for ditt operativsystem.

Når du har lastet ned og installert Go, kan du begynn å skrive og kjøre Go-kode i filer med en .gå filutvidelse.

Du vil finne at Go har de fleste funksjonene og mye av funksjonaliteten til andre programmeringsspråk. Hvis du har tidligere programmeringserfaring, bør du finne Go straightforward.

Variabler i Go

Go er ganske uttrykksfull på det grunnleggende nivået. Det er to måter du kan deklarere variabler i Go. Du kan bruke

instagram viewer
var nøkkelord for å deklarere variabler av ulike datatyper. Etter å ha spesifisert identifikatoren, må du angi variabelens datatype.

var en streng
var b int
var kan Y
var alder streng = "fem år gammel"
var alder = 5// tilsvarende var alder int = 5
fmt. Println (alder)

Du kan bruke noen som datatype hvis du er usikker på variabelens datatype.

Du kan også erklære konstanter med konst nøkkelord på en lignende måte som å deklarere variabler.

konst alder = "fem år gammel"

Det er umulig å endre konstanter etter deklarasjonen.

Go gir en alternativ måte å deklarere variabler i funksjoner. Legg merke til bruken av et kolon før likhetstegnet:

funchoved-() {
 alder := "fem år gammel" // tilsvarende var alder = "fem år gammel"
}

Betingelser i Go

Go har også betingelser for beslutningstaking i programmer. Du kan bruke hvis og ellers uttalelser i koden din for å håndtere beslutninger.

Her er et eksempel hvis uttalelse som sammenligner to heltall for likhet:

var en int = 12
hvis a == 12 {
 fmt. Println("a er lik tolv")
}

Du kan bare bruke ellers uttalelser etter å ha spesifisert en hvis uttalelse, og du må spesifisere ellers blokk etter stenging hvis blokkere:

var en int = 12
hvis a == 12 {
 fmt. Println("a er lik tolv")
} ellers {
 fmt. Println("a er ikke lik tolv")
}

De ellers blokken kjører bare når hvis påstanden vurderes til å være falsk. Go gir ikke else-if-utsagn, men du kan bruke bytte om utsagn for komplekse betingede utsagn.

Her er anatomien til en bytte om uttalelse i Go.

alder := 7
bytte om alder {
sak1:
 fmt. Println("en")
sak2:
 fmt. Println("to")
sak3:
 fmt. Println("tre")
misligholde:
 fmt. Println("null")
}

Du kan lage brytersetninger med bytte om nøkkelord, hvoretter du kan spesifisere forskjellige tilfeller med sak nøkkelord. Du kan håndtere standardsaken ved å bruke en misligholde nøkkelord.

For Loops in Go

Go gir for-løkker for repeterende oppgaver, og i motsetning til de fleste språk, er det ingen while eller do-while-løkke i Go.

Du kan bruke den populære C-stilen for-loop eller område for-loop som visse datastrukturer støtter.

Her er et eksempel på bruk av C-stilen for loop i et Go-program:

funcskriver() {
til jeg := 0; jeg <= 3; i++ {
 fmt. Println (i)
 }
}

Du kan bruke Gos innebygde rekkevidde for løkke på sammensatte datastrukturer som skiver, kart og matriser. De område funksjonen returnerer indeksen og elementet i indeksen når den går gjennom datastrukturen.

til indeks, verdi := område data struktur {
}

Arrays i Go

Matriser er en av de sammensatte datatypene i Go. Go-matriser ligner på C-stil-matriser og har en bestemt lengde ved deklarasjon og instansiering.

Slik kan du deklarere matriser i Go:

var arr [5]streng
arr := [7]int{0, 1, 2, 3, 4, 5, 6}

Du kan bruke indeksering for å få tilgang til, tilordne og oppdatere elementer i en posisjon av matrisen:

arr[3] = "tre"

Koden ovenfor oppdaterer eller setter inn strengen som den fjerde oppføringen i arr matrisevariabel.

Skiver i Go

Go tilbyr skiver som et alternativ til arrays for å håndtere data av ubestemt lengde. Skiver ligner på matriser, bortsett fra at du kan endre lengden på skivene.

Du må bruke den innebygde gjøre funksjon for å lage en skive. Send inn skivens datatype og startlengde til make-funksjonen.

skive := gjøre([]streng, 9)
skive[2] = "to"

Du kan bruke tilføy-funksjonen til å sette inn elementer i skiver. Som standard er legge til funksjonen setter inn elementer på slutten av skiven.

skive = legge til(skive, "ti")

Legg til operasjoner på skiver kan være dyrt å jobbe med siden Go oppretter en ny matrise for hver tilleggsoperasjon.

Kart i Go

Kart er den innebygde assosiative (nøkkelverdi-par) datatypen i Go. Du kan bruke gjøre funksjon for å lage et kart eller en enkel erklæring der du må instansiere kartet.

kart := gjøre(kart[streng]int) // ved å bruke make-funksjonen
kart := kart[streng]int{"en": 1, "to": 2, "tre": 3} // erklære og instansiere et kart

Du kan få tilgang til verdier i et kart ved å spesifisere nøklene. Du kan også sette inn verdier i et kart ved å spesifisere et nøkkelverdi-par.

maps["one"] = 1// setter inn på kartet
ett := kart["ett"] // tilgang til element fra kartet

Du kan bruke slette funksjon for å fjerne nøkkelverdi-par fra kart. De slette funksjonen tar inn kartets identifikator og nøkkelen til paret du vil fjerne:

slette(kart, "ett")

Funksjoner i Go

Funksjoner er verktøyet for gjenbruk av kode i Go. Du kan deklarere funksjoner med func nøkkelord etterfulgt av funksjonens identifikator:

funchoved-() {
}

Funksjoner kan akseptere argumenter og returnere verdier. Du må spesifisere argumenttypen ved siden av identifikatoren for argumenter.

funcLegg til(x streng, y int)int {
komme tilbake x + y
}

Du spesifiserer returtypen før funksjonens kodeblokk og returnerer en verdi av den angitte typen for funksjoner som returnerer verdier.

Strukturer i Go

Go er ikke en objektorientert språk etter design, men du kan implementere objektorienterte funksjoner i Go ved hjelp av strukturer.

Strukturer er brukerdefinerte typer for å gruppere andre datatyper i en enkelt enhet. Go-strukturer kan inneholde verdier av alle Go-støttede typer, og funksjoner kan implementere strukturer.

Slik kan du erklære en struktur i Go:

type Spill struktur {
 Navn streng
 År int
 Spilletid flyte64
 Spillere noen
 Land kart[streng]streng
}

De Spill struct har felt med typer kart, streng, heltall og flytende komma. Du kan instansiere strukturer med standardverdier eller tilordne verdier til dem.

var mko spill // instansiering av standardverdi
// instansierer med verdier
mko := Spill{
 Navn: "Verdi",
 År: 1231,
 Spilletid: 1345412,
 Spillere: [2]streng{"9", "ting"},
 data: kart[streng]int{"en": 1, "to": 2, "tre": 2},
}

Funksjoner kan implementere og få tilgang til strukturtyper. Du må spesifisere struct-parameteren før funksjonens identifikator.

func(g Spill)Finn Spill(Navn streng) {
 a := g. År // tilgang til struct-felt
var b = g. Land // tilgang til struct-felt
}

Når du sender en struktur til en funksjon, har funksjonen tilgang til strukturens felt, og funksjonen blir en strukturmetode.

Go har mange bruksområder

Du har lært det grunnleggende om Go-programmeringsspråket og syntaksen for å begynne å skrive Go-programmer.

Det er mange felt og applikasjoner der du kan bruke Go. Go er populært brukt som et serversidespråk, og du kan også alltid utforske å bygge nettbaserte applikasjoner med det.