Go
constanten

Opmerkingen

Een constante verklaren

Constanten worden als variabelen gedeclareerd, maar met het sleutelwoord const :

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

Net als voor variabelen worden namen die met een hoofdletter beginnen geëxporteerd ( openbaar ), namen die met kleine letters beginnen niet.

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

Constanten kunnen worden gebruikt als elke andere variabele, behalve dat de waarde niet kan worden gewijzigd. Hier is een voorbeeld:

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
}

Speelplaats

Meerdere constantenverklaring

U kunt meerdere constanten binnen hetzelfde const blok declareren:

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

En verhoog automatisch constanten met het iota trefwoord:

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

Zie Iota voor meer voorbeelden van het gebruik van iota om constanten te declareren.

U kunt ook meerdere constanten declareren met behulp van de meervoudige toewijzing. Deze syntaxis kan echter moeilijker te lezen zijn en wordt over het algemeen vermeden.

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

Getypt versus ongetrapt constanten

Constanten in Go kunnen worden getypt of losgemaakt. Bijvoorbeeld, gegeven de volgende letterlijke tekenreeks:

"bar"

je zou kunnen zeggen dat het lettertype van het type string , maar dit is niet semantisch correct. In plaats daarvan zijn literalen Untyped-tekenreeksconstanten . Het is een tekenreeks (correcter, het standaardtype is een string ), maar het is geen Go- waarde en heeft daarom geen type totdat het wordt toegewezen of gebruikt in een context die wordt getypt. Dit is een subtiel onderscheid, maar nuttig om te begrijpen.

Evenzo, als we het letterlijke toewijzen aan een constante:

const foo = "bar"

Het blijft ongetypeerd omdat standaard constanten ongetyped zijn. Het is mogelijk om het ook als een getypte stringconstante te declareren:

const typedFoo string = "bar"

Het verschil speelt een rol wanneer we proberen deze constanten toe te wijzen in een context die wel type heeft. Overweeg bijvoorbeeld het volgende:

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