1. Variables and Constants

En Golang, las variables y constantes son dos conceptos fundamentales que juegan un papel muy importante en un programa.

  • Una variable es un identificador nominado utilizado para almacenar datos en un programa. En Golang, se utiliza la palabra clave var para declarar variables.
  • Una constante es un identificador cuyo valor no puede cambiar en el programa. En Golang, se utiliza la palabra clave const para declarar constantes.

2 Declaración e Inicialización de Variables en Golang

2.1 Declaración y Asignación de una Variable Única

En el lenguaje Go, se usa la palabra clave var para declarar una variable con el formato var nombre_variable tipo. Después de la declaración, la variable puede recibir un valor en el código subsecuente, o puede ser inicializada directamente al momento de la declaración. Por ejemplo:

var edad int // Declarar una variable de tipo entero llamada edad
edad = 25    // Asignar un valor a la variable

var nombre string = "Alice" // Declarar e inicializar la variable nombre

2.2 Declaración de Múltiples Variables

El lenguaje Go soporta la declaración simultánea de múltiples variables, lo cual puede hacer el código más conciso. La declaración múltiple generalmente se realiza al inicio de una función o a nivel de paquete. Por ejemplo:

var (
    primerNombre, apellido string
    edad                   int
)

primerNombre = "John"
apellido = "Doe"
edad = 30

En la declaración múltiple anterior, primerNombre y apellido son declarados como strings, mientras que edad es un entero.

2.3 Inferencia de Tipo y Declaración Abreviada de Variables

En el lenguaje Go, no siempre es necesario especificar explícitamente el tipo de la variable. Si se provee una expresión de inicialización al declarar una variable, Go puede inferir el tipo de la variable. Esto se conoce como inferencia de tipo. La declaración abreviada de variables utilizando := puede simplificar la declaración e inicialización de variables basada en la inferencia de tipo. Por ejemplo:

ciudad := "Pekín" // Usando la declaración abreviada de variables para declarar e inicializar ciudad
pais := "China" // se infiere que país es de tipo string

Vale la pena señalar que las declaraciones abreviadas de variables solo pueden ser utilizadas dentro de funciones y no pueden ser usadas a nivel global.

2.4 Declaración de Variables Fuera de Funciones

Las variables declaradas fuera de funciones tienen un alcance a nivel de paquete. Estas variables son visibles y accesibles en todo el paquete. Por ejemplo:

var varGlobal string = "Soy global" // Declaración de una variable global

func imprimirVarGlobal() {
    fmt.Println(varGlobal) // Accediendo a la variable global dentro de la función
}

Las variables globales pueden ser compartidas entre cualquier función dentro del paquete, pero deben ser utilizadas con cuidado para evitar posibles conflictos de nombres y referencias poco claras.

Consejo: Entender el código de las funciones básicas aquí es suficiente, explicaciones detalladas de las funciones se proporcionarán en secciones posteriores.

3 Tipos de Datos Básicos y Valores Cero

3.1 Tipos de Datos Básicos en Golang

En el lenguaje Go, cada tipo de variable proporciona semántica explícita y características de comportamiento. Aquí están algunos tipos de datos básicos comunes:

  • int, int8, int16, int32, int64: Diferentes rangos de enteros
  • uint, uint8, uint16, uint32, uint64: Enteros sin signo
  • float32, float64: Números de punto flotante
  • bool: Valores booleanos (verdadero o falso)
  • string: Cadenas

3.2 Concepto de Valores Cero

En el lenguaje Go, las variables se inicializan automáticamente con el valor cero de su tipo después de la declaración. El valor cero se refiere al valor predeterminado del tipo correspondiente cuando una variable no es inicializada explícitamente. Esto no es común en algunos otros lenguajes, pero en Go, asegura que todas las variables siempre tengan un valor inicial válido. Aquí están los valores cero para cada tipo de datos básico:

  • El valor cero para un entero es 0
  • El valor cero para un número de punto flotante es 0.0
  • El valor cero para un booleano es false
  • El valor cero para una cadena es una cadena vacía ""

Por ejemplo:

var i int     // El valor cero es 0
var f float64 // El valor cero es 0.0
var b bool    // El valor cero es false
var s string  // El valor cero es ""

Comprender el concepto de valores cero es muy importante, ya que puede ayudar a los desarrolladores a entender el comportamiento de la inicialización de variables y puede ser utilizado para prevenir errores de puntero nulo o no inicializado.

4. Alcance de las Variables

4.1 Variables locales

Las variables locales son variables definidas dentro de una función, y solo se pueden acceder dentro de esa función. Los parámetros de la función también pertenecen a las variables locales. Desde el momento en que se crean, hasta que la ejecución de la función se completa, las variables locales desaparecerán. Cada vez que se llama a una función, las variables locales son recreadas.

func ejemploVariableLocal() {
    var variableLocal int = 10 // Esta es una variable local
    fmt.Println(variableLocal)
}

func main() {
    ejemploVariableLocal() // Salida: 10
    // fmt.Println(variableLocal) // Esto causará un error de compilación porque variableLocal no es visible aquí
}

En el ejemplo anterior, variableLocal solo puede ser accedida dentro de la función ejemploVariableLocal.

4.2 Variables globales

Las variables globales son variables definidas fuera de las funciones, y se pueden acceder en cualquier archivo dentro del mismo paquete. Si deseas usar variables globales en otros paquetes, el nombre de la variable debe comenzar con una letra mayúscula, de acuerdo con las reglas de control de acceso de Go.

package main

import "fmt"

var variableGlobal int = 20 // Esta es una variable global

func main() {
    fmt.Println(variableGlobal) // Salida: 20
    cambiarGlobal()
    fmt.Println(variableGlobal) // Salida: 30
}

func cambiarGlobal() {
    variableGlobal = 30 // Cambiar el valor de la variable global
}

En este ejemplo, variableGlobal es visible tanto en la función main como en la función cambiarGlobal.

5 Declaración y Uso de Constantes

5.1 La palabra clave const

Usamos la palabra clave const para definir constantes. Las constantes son valores que no se pueden modificar y una vez definidos, su valor no puede ser cambiado. Las constantes pueden ser de cualquier tipo de dato básico como enteros, números de punto flotante, booleanos o cadenas de texto.

const Pi = 3.14 // Declarar una constante de punto flotante
const StrConst string = "¡Hola, Mundo!" // Declarar una constante de cadena de texto

func main() {
    fmt.Println(Pi)
    fmt.Println(StrConst)
}

5.2 Constantes Enumeradas

El lenguaje Go no tiene un tipo de enumeración específico, pero puedes usar la palabra clave iota para lograr la enumeración. Dentro de un bloque const, cada declaración adicional de constante incrementará el valor de iota en 1.

const (
    Domingo = iota  // 0
    Lunes          // 1
    Martes         // 2
    Miércoles      // 3
    Jueves       // 4
    Viernes         // 5
    Sábado      // 6
)

func main() {
    fmt.Println(Domingo)    // Salida: 0
    fmt.Println(Sábado)  // Salida: 6
}

El código anterior declara una enumeración para los días de la semana, donde iota se inicializa en 0 dentro del bloque const y se incrementa en 1 para cada declaración subsiguiente.

5.3 Alcance de las constantes

El alcance de las constantes es similar al de las variables. Si una constante se define dentro de una función, su alcance se limita a esa función. Si una constante se define fuera de una función (globalmente), su alcance es todo el paquete, y si la primera letra es mayúscula, se puede acceder en otros paquetes.

Gestionar el alcance de las constantes ayuda a reducir la contaminación del alcance global y mejora mantenibilidad y legibilidad del programa.

const ConstGlobal = "Esta es una constante global"

func main() {
    const ConstLocal = "Esta es una constante local"
    fmt.Println(ConstGlobal)  // Esto es válido
    fmt.Println(ConstLocal)   // Esto es válido
}

func otraFuncion() {
    // fmt.Println(ConstLocal) // Esto causará un error de compilación: ConstLocal no es visible en esta función
    fmt.Println(ConstGlobal)  // Esto es válido
}

En este ejemplo, ConstLocal solo se puede acceder dentro de la función main, mientras que ConstGlobal se puede acceder en todo el paquete.