Go
Stałe

Uwagi

Deklarowanie stałej

Stałe są deklarowane jak zmienne, ale przy użyciu słowa kluczowego const :

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

Podobnie jak w przypadku zmiennych, nazwy rozpoczynające się od dużej litery są eksportowane ( publiczne ), nazwy rozpoczynające się od małej litery nie są.

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

Stałych można używać jak każdej innej zmiennej, z wyjątkiem faktu, że wartości nie można zmienić. Oto przykład:

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
}

Plac zabaw

Deklaracja wielu stałych

Możesz zadeklarować wiele stałych w tym samym bloku const :

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

I automatycznie zwiększaj stałe za pomocą słowa kluczowego iota :

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

Aby uzyskać więcej przykładów używania iota do deklarowania stałych, zobacz Iota .

Można również zadeklarować wiele stałych przy użyciu wielokrotnego przypisania. Jednak ta składnia może być trudniejsza do odczytania i na ogół można jej uniknąć.

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

Stałe typowane a nietypowe

Stałe w Go mogą być wpisywane lub bez typu. Na przykład, biorąc pod uwagę następujący literał ciągu:

"bar"

można powiedzieć, że typem literału jest string , jednak nie jest to poprawne semantycznie. Zamiast tego literały są stałymi ciągów Untyped . Jest to ciąg znaków (dokładniej, jego domyślnym typem jest string ), ale nie jest to wartość Go i dlatego nie ma żadnego typu, dopóki nie zostanie przypisany lub użyty w kontekście, który jest wpisany. Jest to subtelne rozróżnienie, ale przydatne do zrozumienia.

Podobnie, jeśli przypiszemy literał do stałej:

const foo = "bar"

Pozostaje bez typu, ponieważ domyślnie stałe są bez typu. Możliwe jest również zadeklarowanie go jako stałej ciągowej:

const typedFoo string = "bar"

Różnica pojawia się, gdy próbujemy przypisać te stałe w kontekście, który ma typ. Rozważ na przykład:

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