Go
Konstanter anter~~POS=HEADCOMP

Anmärkningar

Förklarar en konstant

Konstanter deklareras som variabler, men använder const nyckelordet:

const Greeting string = "Hello World"
const Years int = 10
const Truth bool = true

Liksom för variabler exporteras namn som börjar med en stor bokstav ( offentligt ), namn som börjar med gemener är inte.

// not exported
const alpha string = "Alpha"
// exported
const Beta string = "Beta"

Konstanter kan användas som alla andra variabler, förutom att värdet inte kan ändras. Här är ett exempel:

package main

import (
    "fmt"
    "math"
)

const s string = "constant"

func main() {
    fmt.Println(s) // constant

    // A `const` statement can appear anywhere a `var` statement can.
    const n = 10
    fmt.Println(n)                           // 10
    fmt.Printf("n=%d is of type %T\n", n, n) // n=10 is of type int

    const m float64 = 4.3
    fmt.Println(m) // 4.3

    // An untyped constant takes the type needed by its context.
    // For example, here `math.Sin` expects a `float64`.
    const x = 10
    fmt.Println(math.Sin(x)) // -0.5440211108893699
}

Lekplats

Förklaring av flera konstanter

Du kan förklara flera konstanter inom samma const block:

const (
    Alpha = "alpha"
    Beta  = "beta"
    Gamma = "gamma"
)

Och automatiskt öka konstanter med nyckelordet iota :

const (
    Zero = iota // Zero == 0
    One         // One  == 1
    Two         // Two  == 2
)

För fler exempel på att använda iota att förklara konstanter, se Iota .

Du kan också förklara flera konstanter med hjälp av flera uppdrag. Emellertid kan denna syntax vara svårare att läsa och den undviks i allmänhet.

const Foo, Bar = "foo", "bar"

Typade mot obestämda konstanter

Konstanter i Go kan skrivas eller inte skrivas in. Till exempel med tanke på följande sträng bokstavligen:

"bar"

man kan säga att typ av bokstav är string , men detta är inte semantiskt korrekt. I stället är bokstäver otypade strängkonstanter . Det är en sträng (mer korrekt, dess standardtyp är string ), men det är inte ett Go- värde och har därför ingen typ förrän den har tilldelats eller används i ett sammanhang som skrivs. Detta är en subtil distinktion, men en användbar att förstå.

På samma sätt, om vi tilldelar det bokstavliga till en konstant:

const foo = "bar"

Det förblir otypat eftersom, som standard, konstanter är inskrivna. Det är också möjligt att förklara det som en typsträng konstant :

const typedFoo string = "bar"

Skillnaden kommer in i spelet när vi försöker tilldela dessa konstanter i ett sammanhang som har typ. Tänk till exempel på följande:

var s string
s = foo      // This works just fine
s = typedFoo // As does this

type MyString string
var mys MyString
mys = foo      // This works just fine
mys = typedFoo // cannot use typedFoo (type string) as type MyString in assignment