Go
Konstanten

Bemerkungen

Konstante deklarieren

Konstanten werden wie Variablen deklariert, verwenden jedoch das Schlüsselwort const :

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

Wie bei Variablen werden Namen, die mit einem Großbuchstaben beginnen, exportiert ( öffentlich ), Namen, die mit Kleinbuchstaben beginnen, sind nicht zulässig.

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

Konstanten können wie jede andere Variable verwendet werden, mit der Ausnahme, dass der Wert nicht geändert werden kann. Hier ist ein Beispiel:

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
}

Spielplatz

Deklaration mehrerer Konstanten

Sie können mehrere Konstanten innerhalb desselben const Blocks deklarieren:

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

Und erhöht automatisch Konstanten mit dem Schlüsselwort iota :

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

Weitere Beispiele für die Verwendung von iota zum Deklarieren von Konstanten finden Sie unter Iota .

Sie können auch mehrere Konstanten mithilfe der Mehrfachzuweisung deklarieren. Diese Syntax kann jedoch schwieriger zu lesen sein und wird im Allgemeinen vermieden.

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

Typisierte und nicht typisierte Konstanten

Konstanten in Go können typisiert oder nicht typisiert sein. Zum Beispiel das folgende String-Literal:

"bar"

Man könnte sagen, dass der Typ des Literal string ist, dies ist jedoch nicht semantisch korrekt. Literale sind stattdessen Zeichenkettenkonstanten ohne Typ . Es ist eine Zeichenfolge (genauer gesagt, der Standardtyp ist string ), aber es ist kein Go- Wert und hat daher keinen Typ, bis er zugewiesen oder in einem Kontext verwendet wird, der eingegeben wird. Dies ist eine subtile Unterscheidung, die jedoch verständlich ist.

Ähnlich, wenn wir das Literal einer Konstanten zuweisen:

const foo = "bar"

Es bleibt untypisiert, da Konstanten standardmäßig nicht typisiert sind. Es ist auch möglich, es als typisierte String-Konstante zu deklarieren:

const typedFoo string = "bar"

Der Unterschied kommt zum Tragen, wenn wir versuchen, diese Konstanten in einem Kontext mit Typ zuzuweisen. Betrachten Sie zum Beispiel Folgendes:

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