Go
Constantes

Observaciones

Declarando una constante

Las constantes se declaran como variables, pero usando la palabra clave const :

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

Al igual que para las variables, los nombres que comienzan con mayúsculas se exportan ( público ), los nombres que comienzan con minúsculas no se exportan.

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

Las constantes se pueden usar como cualquier otra variable, excepto por el hecho de que el valor no se puede cambiar. Aquí hay un ejemplo:

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
}

Patio de recreo

Declaración de constantes múltiples

Puedes declarar múltiples constantes dentro del mismo bloque const :

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

E incrementa automáticamente las constantes con la palabra clave iota :

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

Para obtener más ejemplos del uso de iota para declarar constantes, consulte Iota .

También puede declarar constantes múltiples utilizando la asignación múltiple. Sin embargo, esta sintaxis puede ser más difícil de leer y generalmente se evita.

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

Constantes mecanografiadas vs. no tipificadas

Las constantes en Go pueden ser escritas o sin tipo. Por ejemplo, dada la siguiente cadena literal:

"bar"

se podría decir que el tipo del literal es una string , sin embargo, esto no es semánticamente correcto. En cambio, los literales son constantes de cadena sin tipo . Es una cadena (más correctamente, su tipo predeterminado es string ), pero no es un valor Ir y, por lo tanto, no tiene ningún tipo hasta que se asigna o se usa en un contexto que se escribe. Esta es una distinción sutil, pero útil para entender.

Del mismo modo, si asignamos el literal a una constante:

const foo = "bar"

Permanece sin tipo ya que, por defecto, las constantes están sin tipo. También es posible declararlo como una constante de cadena con tipo :

const typedFoo string = "bar"

La diferencia entra en juego cuando intentamos asignar estas constantes en un contexto que tiene tipo. Por ejemplo, considere lo siguiente:

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