Go är ett av de moderna programmeringsspråken som vinner dragkraft i många undersökningar eftersom utvecklare föredrog språk. Go har en syntax som är lätt att använda och förstå samtidigt som den ger prestanda i toppklass.
Du kan använda Go för att bygga olika applikationer, från webbappar till kommandoradsappar, molntjänster och nätverk. Gos ekosystem av tredjepartspaket stöder många andra användningsfall.
Go har de flesta funktioner du kan förvänta dig på ett modernt språk: generika, samtidighet, typinferens, sophämtning och många fler.
Komma igång med Go
Du kan köra Go på de flesta operativsystem. Bege dig till installationssidan och ladda ner en föredragen Go-version för ditt operativsystem.
När du har laddat ner och installerat Go kan du börja skriva och köra Go-kod i filer med en .gå filtillägget.
Du kommer att upptäcka att Go har de flesta funktionerna och mycket av funktionaliteten hos andra programmeringsspråk. Om du har tidigare erfarenhet av programmering bör du hitta Go straightforward.
Variabler i Go
Go är ganska uttrycksfullt på det grundläggande planet. Det finns två sätt du kan deklarera variabler i Go. Du kan använda var nyckelord för att deklarera variabler av olika datatyper. När du har angett identifieraren måste du ställa in variabelns datatyp.
var a sträng
var b int
var c någon
var ålder sträng = "fem år gammal"
var ålder = 5// motsvarande var age int = 5
fmt. Println (ålder)
Du kan använda några som datatyp om du är osäker på variabelns datatyp.
Du kan också deklarera konstanter med konst nyckelord på ett liknande sätt som att deklarera variabler.
konst ålder = "fem år gammal"
Det är omöjligt att ändra konstanter efter att de har deklarerats.
Go ger ett alternativt sätt att deklarera variabler i funktioner. Notera användningen av ett kolon före likhetstecknet:
funchuvud() {
ålder := "fem år gammal" // motsvarar var ålder = "fem år gammal"
}Villkor i Go
Go har även villkor för beslutsfattande i program. Du kan använda om och annan uttalanden i din kod för att hantera beslut.
Här är ett exempel om påstående som jämför två heltal för likhet:
var a int = 12
om a == 12 {
fmt. Println("a är lika med tolv")
}
Du kan bara använda annan uttalanden efter att ha angett en om uttalande, och du måste ange annan block efter stängning om blockera:
var a int = 12
om a == 12 {
fmt. Println("a är lika med tolv")
} annan {
fmt. Println("a är inte lika med tolv")
}
De annan blocket körs endast när om påståendet utvärderas till falskt. Go tillhandahåller inte else-if-uttalanden, men du kan använda växla uttalanden för komplexa villkorliga uttalanden.
Här är anatomin hos en växla uttalande i Go.
ålder := 7
växla ålder {
fall1:
fmt. Println("ett")
fall2:
fmt. Println("två")
fall3:
fmt. Println("tre")
standard:
fmt. Println("noll")
}
Du kan skapa switch-satser med växla nyckelord, varefter du kan ange olika fall med fall nyckelord. Du kan hantera standardfallet med en standard nyckelord.
För Loops in Go
Go tillhandahåller for-loopar för repetitiva uppgifter, och till skillnad från de flesta språk finns det ingen while eller do-while loop i Go.
Du kan använda den populära C-stilen for-loop eller räckvidd for-loop som vissa datastrukturer stöder.
Här är ett exempel på hur man använder C-stilen för loop i ett Go-program:
funcskrivare() {
för jag := 0; jag <= 3; i++ {
fmt. Println (i)
}
}
Du kan använda Gos inbyggda intervall för loop på sammansatta datastrukturer som segment, kartor och arrayer. De räckvidd funktion returnerar indexet och elementet i indexet när det går igenom datastrukturen.
för index, värde := räckvidd datastruktur {
}Arrayer i Go
Matriser är en av de sammansatta datatyperna i Go. Go-arrayer liknar C-stilarrayer och har en bestämd längd vid deklaration och instansiering.
Så här kan du deklarera arrayer i Go:
var arr [5]sträng
arr := [7]int{0, 1, 2, 3, 4, 5, 6}
Du kan använda indexering för att komma åt, tilldela och uppdatera element i en position i arrayen:
arr[3] = "tre"
Koden ovan uppdaterar eller infogar strängen som den fjärde posten i arr arrayvariabel.
Skivor i Go
Go tillhandahåller skivor som ett alternativ till arrayer för att hantera data av obestämd längd. Skivor liknar arrayer, förutom att du kan ändra längden på skivor.
Du måste använda den inbyggda göra funktion för att skapa en skiva. Skicka in segmentets datatyp och initiala längd till make-funktionen.
skiva := göra([]sträng, 9)
skiva[2] = "två"
Du kan använda funktionen tillägg för att infoga element i skivor. Som standard är bifoga funktion infogar element i slutet av segmentet.
skiva = bifoga(skiva, "tio")
Lägg till operationer på segment kan vara dyrt att arbeta med eftersom Go skapar en ny array för varje append operation.
Kartor i Go
Kartor är den inbyggda associativa (nyckel-värdepar) datatypen i Go. Du kan använda göra funktion för att skapa en karta eller en enkel deklaration där du måste instansiera kartan.
kartor := göra(Karta[sträng]int) // med hjälp av make-funktionen
kartor := Karta[sträng]int{"ett": 1, "två": 2, "tre": 3} // deklarera och instansiera en karta
Du kan komma åt värden i en karta genom att ange nycklarna. Du kan också infoga värden i en karta genom att ange ett nyckel-värdepar.
maps["one"] = 1// infogar på kartan
en := kartor["en"] // komma åt element från kartan
Du kan använda radera funktion för att ta bort nyckel-värdepar från kartor. De radera funktionen tar in kartans identifierare och nyckeln för paret du vill ta bort:
radera(kartor, "en")
Funktioner i Go
Funktioner är verktyget för kodåteranvändning i Go. Du kan deklarera funktioner med func nyckelord följt av funktionens identifierare:
funchuvud() {
}
Funktioner kan acceptera argument och returnera värden. Du måste ange argumenttypen bredvid identifieraren för argument.
funcLägg till(x sträng, y int)int {
lämna tillbaka x + y
}
Du anger returtypen före funktionens kodblock och returnerar ett värde av den angivna typen för funktioner som returnerar värden.
Strukturer i Go
Go är inte en objektorienterat språk av design, men du kan implementera objektorienterade funktioner i Go med hjälp av strukturer.
Strukturer är användardefinierade typer för att gruppera andra datatyper i en enda enhet. Go-strukturer kan innehålla värden av alla typer som stöds av Go, och funktioner kan implementera strukturer.
Så här kan du deklarera en struktur i Go:
typ Spel struktur {
namn sträng
År int
Speltid flyta64
Spelare någon
Länder Karta[sträng]sträng
}
De Spel struct har fält med typer av karta, sträng, heltal och flyttal. Du kan instansiera strukturer med standardvärden eller tilldela värden till dem.
var mko spel // instansiering av standardvärde
// instansiera med värden
mko := Spel{
Namn: "Värde",
År: 1231,
Speltid: 1345412,
Spelare: [2]sträng{"9", "grejer"},
data: Karta[sträng]int{"ett": 1, "två": 2, "tre": 2},
}
Funktioner kan implementera och komma åt strukturtyper. Du måste ange struct-parametern före funktionens identifierare.
func(g Spel)Hitta spel(namn sträng) {
a := g. År // åtkomst till struct-fält
var b = g. Länder // åtkomst till struct-fält
}
När du skickar en struktur till en funktion har funktionen tillgång till strukturens fält och funktionen blir en strukturmetod.
Go har många användningsfall
Du har lärt dig grunderna i Go-programmeringsspråket och syntaxen för att börja skriva Go-program.
Det finns många fält och applikationer där du kan använda Go. Go används populärt som ett språk på serversidan, och du kan alltid utforska att bygga webbaserade applikationer med det också.
