Conceptos básicos de las constantes en Go

Introducción

En las lecciones anteriores, aprendimos sobre variables en Go. En esta lección, exploraremos el concepto de constantes, cómo usarlas y por qué son importantes. Sumergámonos en el mundo de las constantes.

Puntos de conocimiento:

• ¿Qué son las constantes?
• Declaración de constantes
• El generador de constantes iota
• Uso de constantes

Skills Graph

¿Qué son las constantes?

En términos simples, una constante es un valor que se declara y no se puede modificar durante la ejecución del programa. Las constantes permiten que el compilador conozca sus valores antes de la ejecución del programa, durante la fase de compilación.

Las declaraciones de constantes pueden tener valores específicos asignados a ellas. Su sintaxis es similar a la de las variables, pero una vez que se declara un valor constante, no se puede cambiar.

Las constantes son útiles cuando se desea declarar un valor que no debe cambiar, como una dirección web o un valor significativo específico como π.

Declaración de constantes

La declaración de constantes es similar a la de variables. La palabra clave var se reemplaza con la palabra clave const.

Nota: Las constantes deben tener un valor asignado al momento de declararse.

En Go, todas las variables deben ser utilizadas después de definirse, pero las constantes son una excepción. Incluso si no se utilizan, no habrá error.

La sintaxis para declarar una constante es la siguiente:

const name [type] = value

name es el nombre de la constante que se está declarando. type es el tipo de dato de la constante, pero se puede omitir porque Go puede inferirlo automáticamente. El valor al final es el valor asignado a la constante.

Tenga en cuenta que solo se pueden utilizar los siguientes tipos para declaraciones de constantes:

• Tipos enteros
• Tipos de punto flotante
• Tipos complejos
• Tipos booleanos
• Tipos de cadena

Veamos un ejemplo. Crea un nuevo archivo llamado const.go en el directorio ~/project:

touch ~/project/const.go

Ingresa el siguiente código en const.go:

package main

import "fmt"

// Declare a single constant
const labex string = "LabEx" // explicitly specify the type as string
const labs = "LABS"    // automatically inferred as string by the compiler

// Declare multiple constants
const (
    hangzhou, chengdu = "HANGZHOU", "CHENGDU"
    monday, tuesday, wednesday = "MONDAY", "TUESDAY", "WEDNESDAY"
)

func main() {
    fmt.Printf("The type of labex is: %T, and its value is %s\n", labex, labex)
    fmt.Printf("The type of labs is: %T, and its value is %s\n", labs, labs)

    fmt.Println()

    fmt.Println(hangzhou, chengdu)
    fmt.Println(monday, tuesday, wednesday)
}

go run ~/project/const.go

Después de ejecutar el programa, la salida es la siguiente:

The type of labex is: string, and its value is LabEx
The type of labs is: string, and its value is LABS

HANGZHOU CHENGDU
MONDAY TUESDAY WEDNESDAY

Aquí, demostramos la declaración de constantes individuales y múltiples. Al declarar múltiples constantes, se recomienda utilizar paréntesis.

En el programa, solo demostramos la declaración de constantes de tipo cadena. Sin embargo, las constantes también pueden tener otros tipos, como enteros y booleanos.

Al declarar múltiples constantes utilizando paréntesis, si una constante no se inicializa, heredará el valor de la constante anterior.

Ingresa el siguiente código en const.go:

package main

import "fmt"

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday
    friday
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

La salida es la siguiente:

MONDAY TUESDAY WEDNESDAY WEDNESDAY WEDNESDAY

Aquí, thursday y friday no tienen valores explícitos. De acuerdo con las reglas de Go, cuando una constante no se inicializa explícitamente, hereda el valor de la constante anterior. En este caso:

• thursday hereda el valor de wednesday.
• friday también hereda el valor de wednesday.

Este comportamiento permite un código conciso, pero puede llevar a resultados inesperados si no se tiene en cuenta.

Si quieres que thursday y friday tengan valores distintos, debes asignarlos explícitamente:

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday  = "THURSDAY"
    friday    = "FRIDAY"
)

Esto producirá la salida esperada:

MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY

El generador de constantes iota

Además de declarar constantes una por una, también podemos usar iota para declararlas por lotes. Veamos un ejemplo. Escribe el siguiente código en el archivo const.go:

package main

import "fmt"

const (
    monday    = iota // initial value is 0
    tuesday   = iota // increments by 1 each time
    wednesday = iota
    thursday  = iota
    friday    = iota
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

La salida es la siguiente:

0 1 2 3 4

Cuando se usa iota, el valor inicial es 0 y se incrementa en 1 para cada elemento subsiguiente.

Después de declarar el primer elemento, las constantes subsiguientes no necesitan ser asignadas usando iota. El siguiente código también se ejecutará correctamente:

package main

import "fmt"

const (
    monday    = iota // 0
    tuesday          // 1
    wednesday        // 2
    thursday         // 3
    friday           // 4
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

¿Qué pasa si queremos saltar un valor específico? En este caso, podemos usar un guión bajo. El siguiente código salta la constante para el miércoles:

package main

import "fmt"

const (
    monday  = iota // 0
    tuesday        // 1
    _
    thursday // 3
    friday   // 4
)

func main() {
    fmt.Println(monday, tuesday, thursday, friday)
}

go run ~/project/const.go

Como se puede ver, la salida es la siguiente:

0 1 3 4

El operador iota también se puede usar para operaciones aritméticas. Ingresa el siguiente código en const.go:

package main

import "fmt"

const (
    a = iota     // 0
    b = iota * 3 // 1 * 3
    c = iota + 4 // 2 + 4
)

const (
    B  = 1 << (iota * 10) // equals 1 << (0 * 10)
    KB                    // 1024
    MB                    // 1048576
)

func main() {
    fmt.Println(a, b, c)
    fmt.Println(B, KB, MB)
}

go run ~/project/const.go

La salida es la siguiente:

0 3 6
1 1024 1048576

En el primer lote de declaraciones de constantes, usamos iota para realizar operaciones aritméticas simples.

En el segundo lote, usamos iota con el operador de desplazamiento a la izquierda << para expresar los valores de 1 KB y 1 MB en términos de B. Por ejemplo, 1 KB es igual a 1024B, y 1 MB es igual a 1024 * 1024, que es 1048576B.

Quiz

Ahora, reforcemos lo que hemos aprendido. Crea un nuevo archivo llamado iota.go y utiliza iota y constantes para mostrar los valores de 1GB y 1TB en términos de B.

Requisitos:

1. No muestres directamente los números convertidos. Utiliza iota para la conversión.
2. El archivo iota.go debe estar ubicado en el directorio ~/project.

Pista: Puedes consultar el código de la sección "iota".

El formato de salida requerido es el siguiente:

1GB is equal to 1073741824B
1TB is equal to 1099511627776B

Resumen

Repasemos lo que hemos aprendido en esta lección:

• Las constantes no se pueden modificar después de declararse.
• Las constantes se pueden declarar utilizando la palabra clave const.
• Al declarar múltiples constantes, se prefiere utilizar paréntesis.
• El generador de constantes iota se puede utilizar para declaraciones de enumeración.
• iota también se puede utilizar en operaciones aritméticas.

En esta lección, aprendimos sobre constantes y también se introdujo el generador de constantes iota. Las cadenas, enteros, números de punto flotante y constantes son los tipos de datos básicos en Go.