Go
costanti

Osservazioni

Dichiarare una costante

Le costanti sono dichiarate come variabili, ma usando la parola chiave const :

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

Come per le variabili, i nomi che iniziano con una lettera maiuscola vengono esportati ( pubblici ), i nomi che iniziano con lettere minuscole non lo sono.

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

Le costanti possono essere utilizzate come qualsiasi altra variabile, ad eccezione del fatto che il valore non può essere modificato. Ecco un esempio:

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
}

Terreno di gioco

Dichiarazione di costanti multiple

È possibile dichiarare più costanti all'interno dello stesso blocco const :

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

E incrementa automaticamente le costanti con la parola chiave iota :

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

Per ulteriori esempi sull'utilizzo di iota per dichiarare le costanti, vedere Iota .

Puoi anche dichiarare più costanti usando il compito multiplo. Tuttavia, questa sintassi potrebbe essere più difficile da leggere ed è generalmente evitata.

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

Costanti tipizzate e non tipizzate

Le costanti in Go possono essere digitate o non tipizzate. Ad esempio, data la seguente stringa letterale:

"bar"

si potrebbe dire che il tipo di letterale è una string , tuttavia, questo non è semanticamente corretto. Invece, i letterali sono costanti di stringa non tipizzate . È una stringa (più correttamente, il suo tipo predefinito è string ), ma non è un valore Go e quindi non ha alcun tipo fino a quando non viene assegnato o utilizzato in un contesto che viene digitato. Questa è una sottile distinzione, ma utile per capire.

Allo stesso modo, se assegniamo il letterale a una costante:

const foo = "bar"

Rimane non tipizzato poiché, per impostazione predefinita, le costanti non sono tipizzate. È possibile dichiararlo anche come costante stringa digitato :

const typedFoo string = "bar"

La differenza entra in gioco quando tentiamo di assegnare queste costanti in un contesto che ha tipo. Ad esempio, considera quanto segue:

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