Deklarera och använda variabler

6 minuter

Nu ska vi starta den här modulen genom att titta på hur du deklarerar och använder variabler i Go. Det finns olika sätt att deklarera en variabel. Vi tittar på var och en av dem, och du väljer den som passar bäst för dina behov eller stil. Vi kommer att notera några saker som är specifika för Go som du vanligtvis inte hittar i andra programmeringsspråk när vi utforskar kärnbegreppen för variabler.

Vi inkluderar kodfragment i det här avsnittet som du kan köra i Visual Studio Code eller i Go Playground.

Deklarera variabler

Om du vill deklarera en variabel måste du använda nyckelordet var :

var firstName string

Föregående instruktion deklarerar en variabel med namnet firstName av typen string. (Vi ska prata om datatyper i det kommande avsnittet.) Det här exemplet visar det mest grundläggande sättet att deklarera en variabel. Om du vill deklarera en annan variabel lägger du bara till en liknande instruktion som den föregående. Du kan deklarera mer än en variabel på en enda rad om de är av samma typ:

var firstName, lastName string

Genom att lägga till ett kommatecken (,) efter ett variabelnamn säger du att du håller på att deklarera en annan variabel. I det här fallet deklarerar föregående -instruktion två variabler med namnet firstName och lastName av typen string. Om du vill lägga till en tredje variabel av typen intser koden ut så här:

var firstName, lastName string
var age int

Ett annat sätt att skriva föregående instruktion är att använda parenteser efter nyckelordet var , som om du hade ett dedikerat block för att deklarera variabler, så här:

var (
    firstName, lastName string
    age int
)

Initiera variabler

Du har bara deklarerat variabler just nu, men det finns tillfällen då du behöver dem för att ha ett initialt värde. I Go kan du initiera variabler på olika sätt. Om du till exempel fortsätter med samma exempel från tidigare kan du initiera varje variabel med hjälp av den här koden:

var (
    firstName string = "John"
    lastName  string = "Doe"
    age       int    = 32
)

Om du bestämmer dig för att initiera en variabel behöver du inte ange dess typ eftersom Go härleder typen när du initierar variabeln med ett värde. Du kan till exempel deklarera och initiera variabler så här:

var (
    firstName = "John"
    lastName  = "Doe"
    age       = 32
)

Go kommer att dra slutsatsen att variablerna firstName och lastName är av string typen och att variabeln age är en int typ.

Olika sätt att initiera variabler

I Go kan du deklarera och initiera variabler på en enda rad. Du separerar varje variabelnamn med ett kommatecken och gör samma sak för varje värde (i samma ordning), så här:

var (
    firstName, lastName, age = "John", "Doe", 32
)

Det finns ett annat sätt att deklarera och initiera variabler. Den här metoden är det vanligaste sättet att göra det på i Go. Samma exempel som vi har använt kan se ut så här:

package main

import "fmt"

func main() {
    firstName, lastName := "John", "Doe"
    age := 32
    fmt.Println(firstName, lastName, age)
}

Kommentar

Lägg märke till instruktionen import "fmt" . Vi använder nyckelordet import för att föra in innehållet i ett paket i omfånget. Vi importerar "fmt"-paketet så att vi kan använda Println metoden i vår kod. Vi tar en närmare titt på det här nyckelordet i en senare lektion.

Kör föregående kod för att bekräfta att det här sättet att deklarera och initiera variabler fungerar.

Observera att du måste inkludera ett kolon likhetstecken (:=) och dess motsvarande värde direkt efter att du har definierat variabelnamnet. När du använder kolonets likhetstecken måste variabeln som du deklarerar vara ny. Om du använder ett likhetstecken för kolon och variabeln redan har deklarerats kompileras inte programmet. Lägg till åldern som en konstant (se nästa avsnitt), men använd kolonets likhetstecken (:=) och försök igen.

Slutligen kan du bara använda kolonets likhetstecken i en funktion. När du deklarerar variabler utanför en funktion måste du göra det med hjälp av nyckelordet var . Oroa dig inte om du inte är bekant med funktioner. Vi introducerar funktioner i en senare lektion.

Deklarera konstanter

Det kommer att finnas tillfällen då du behöver ha statiska värden i koden, så kallade konstanter. Go stöder användning av konstanter. Nyckelordet för att deklarera ett är const.

Du kan till exempel deklarera en konstant så här:

const HTTPStatusOK = 200

Precis som med variabler härleds typen av en konstant från det tilldelade värdet. I Go skrivs konstanta namn vanligtvis i MixedCased eller alla versaler.

Om du behöver deklarera flera konstanter i ett block kan du göra det så här:

const (
    StatusOK              = 0
    StatusConnectionReset = 1
    StatusOtherError      = 2
)

Kommentar

Go har ett intressant koncept relaterat till konstanter som kallas iota, som vi inte täcker i den här modulen. Men du kan lära dig mer om det genom att titta på Go-wikin på GitHub. Tänk bara på att iota är ett nyckelord som Go använder för att förenkla konstanta definitioner när värdena är sekventiella.

Även om det finns likheter mellan konstanter och variabler finns det några viktiga skillnader. Du kan till exempel deklarera konstanter utan att använda dem och du får inget felmeddelande. Du kan inte använda likhetstecknet kolon för att deklarera konstanter. Go klagar om du gör det.

Go utlöser ett fel om du deklarerar variabler och inte använder dem

Det finns något grundläggande du måste tänka på i Go. När du deklarerar en variabel och inte använder den genererar Go ett fel, inte en varning som i vissa andra programmeringsspråk.

Vi går till exempel tillbaka till något av våra tidigare exempel och tar bort anropet fmt.Println :

func main() {
    firstName, lastName := "John", "Doe"
    age := 32
}

När du kör den här koden i Visual Studio Code eller Go Playground ser du att det finns ett fel på raderna där du deklarerar variablerna. Du ser följande felmeddelanden:

./main.go:4:2: firstName declared but not used
./main.go:4:13: lastName declared but not used
./main.go:5:2: age declared but not used