Constantes del lenguaje Go

Una constante es un identificador de un valor simple, una cantidad que no se modifica durante la ejecución del programa. Los tipos de datos en las constantes solo pueden ser booleanos, numéricos (enteros, flotantes y complejos) y cadenas de caracteres.

Definición de la palabra: constSíconstantAbreviatura de (constante), indica un valor inmutable en el programa.


Sintaxis básica y parámetros

El formato de definición de constantes:

const identifier [type] = value

Explicación de sintaxis

  • identifier: nombre de la constante, sigue las reglas de nomenclatura de identificadores de Go (letras, dígitos, guiones bajos, y no puede comenzar con un dígito).
  • type(opcional): nombre del tipo; si se omite, el compilador lo infiere automáticamente.
  • value: el valor de la constante.

Forma de definición

  • Definición con tipo explícito:const b string = "abc"
  • Definición con tipo implícito:const b = "abc"
  • Definición por lotes:const c_name1, c_name2 = value1, value2

Ejemplo

Ejemplo 1: Definición básica de constantes

Ejemplo

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5
   var area int
   const a, b, c = 1, false, "str" // Asignación múltiple

   area = LENGTH * WIDTH
   fmt.Printf("El área es: %d", area)
   println()
   println(a, b, c)
}

Resultado esperado de la ejecución:

面积为 : 50
1 false str

Análisis del código:

  1. const LENGTH int = 10Se define una constante entera LENGTH con valor 10.
  2. const WIDTH int = 5Se define una constante entera WIDTH con valor 5.
  3. const a, b, c = 1, false, "str"Se utiliza la asignación múltiple para definir varias constantes de diferentes tipos al mismo tiempo.
  4. area = LENGTH * WIDTHSe calcula el área y se asigna a la variable area.

Grupo de constantes y enumeraciones

El lenguaje Go no tiene una palabra clave de enumeración (enum); normalmente se utiliza un grupo de constantes para lograr el efecto de enumeración:

Ejemplo

package main

import "fmt"

// Definir enumeración de género
const (
    Unknown = 0
    Female  = 1
    Male    = 2
)

func main() {
    fmt.Printf("Desconocido=%d, Femenino=%d, Masculino=%d\n", Unknown, Female, Male)
}

Resultado esperado de la ejecución:

未知=0, 女性=1, 男性=2

Análisis del código:

  • Usar un grupo de constantes permite definir un conjunto de valores constantes relacionados.
  • Los números 0, 1 y 2 representan sexo desconocido, femenino y masculino, respectivamente.

Uso de funciones integradas en constantes

En las expresiones constantes se pueden usarlen()、cap()、unsafe.Sizeof()y otras funciones integradas para calcular el valor de la expresión.

Nota:Las funciones en expresiones constantes deben ser funciones integradas.

Ejemplo

package main

import (
    "fmt"
    "unsafe"
)

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main() {
    fmt.Printf("a=%s, b=%d, c=%d\n", a, b, c)
}

Resultado esperado de la ejecución:

a=abc, b=3, c=16

Análisis del código:

  • a = "abc": constante de cadena.
  • b = len(a): usando len() para obtener la longitud de la cadena, el resultado es 3.
  • c = unsafe.Sizeof(a): usando unsafe.Sizeof() para obtener el uso de memoria de la variable, el resultado es 16 bytes (la estructura de cadena ocupa 16 bytes en sistemas de 64 bits).

Contador de constantes iota

iotaiota es una constante especial del lenguaje Go, también llamada contador de constantes. Puede generar automáticamente valores de secuencia creciente dentro de un bloque de declaración const.

Características importantes:

  • iotaEnconstCuando aparece la palabra clave const, se restablece a 0.
  • Por cada nueva línea de declaración de constante en const, iota se incrementa automáticamente en 1.
  • Se puede entender como el índice de línea dentro del bloque de sentencias const (comenzando desde 0).

Ejemplo 1: Uso básico de iota

Ejemplo

package main

import "fmt"

// iota comienza en 0 y aumenta en 1 por línea
const (
    a = iota   // 0
    b          // 1 (valor omitido, por defecto usa el iota de la línea anterior)
    c          // 2
)

func main() {
    fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c)
}

Resultado esperado de la ejecución:

a=0, b=1, c=2

Análisis del código:

  • Cuando se omite el valor de la constante, se usa por defecto el valor de iota de la línea anterior.
  • Por lo tanto, b=1, c=2.

Ejemplo 2: Uso detallado de iota

Ejemplo

package main

import "fmt"

func main() {
    const (
        a = iota   // 0
        b          // 1
        c          // 2
        d = "ha"   // Valor independiente, iota += 1
        e          // "ha",iota += 1
        f = 100    // Valor independiente, iota += 1
        g          // 100,iota += 1
        h = iota   // 7, se reanuda el uso del valor de iota
        i          // 8
    )
    fmt.Printf("a=%d, b=%d, c=%d, d=%s, e=%s, f=%d, g=%d, h=%d, i=%d\n", a, b, c, d, e, f, g, h, i)
}

Resultado esperado de la ejecución:

a=0, b=1, c=2, d=ha, e=ha, f=100, g=100, h=7, i=8

Análisis del código:

  • Cuando se asigna explícitamente, se usa ese valor, pero iota sigue incrementándose.
  • Cuando se omite la asignación, se usa el valor de la línea anterior.
  • Enh = iotaEn ese momento se reanuda el uso del valor actual de iota (7).

Ejemplo 3: iota y operaciones de desplazamiento

Ejemplo

package main

import "fmt"

const (
    i = 1 << iota  // 1 << 0 = 1
    j = 3 << iota  // 3 << 1 = 6
    k              // 3 << 2 = 12
    l              // 3 << 3 = 24
)

func main() {
    fmt.Printf("i=%d, j=%d, k=%d, l=%d\n", i, j, k, l)
}

Resultado esperado de la ejecución:

i=1, j=6, k=12, l=24

Análisis del código:

  • <<es el operador de desplazamiento a la izquierda,x << nes equivalente ax * 2^n。
  • i = 1 << 0 = 1: 1 desplazado 0 bits, el resultado es 1.
  • j = 3 << 1 = 6: 3 desplazado 1 bit, el binario 11 se convierte en 110, es decir, 6.
  • k = 3 << 2 = 12: 3 desplazado 2 bits, el binario 11 se convierte en 1100, es decir, 12.
  • l = 3 << 3 = 24: 3 desplazado 3 bits, el binario 11 se convierte en 11000, es decir, 24.

Notas complementarias

  • 1 << n = 1 * 2^n
  • 3 << n = 3 * 2^n
Otras extensiones