Tutorial Go: Tipos de datos, variables y constantes

Declaración y asignación de variables

En Go, la declaración de variables es un proceso fundamental que permite especificar el nombre y el tipo de las variables que se utilizarán en el programa. La sintaxis básica para declarar una variable en Go es mediante la palabra clave var, seguida del nombre de la variable y su tipo. Por ejemplo:

var nombre string
var edad int

En estos ejemplos, se han declarado dos variables: nombre de tipo string y edad de tipo int. Es importante destacar que, al declarar una variable de esta manera, se le asigna automáticamente el valor cero correspondiente a su tipo: una cadena vacía para string y 0 para int.

Go también permite la declaración y asignación simultánea de variables utilizando el operador de asignación =. Esto se puede hacer en una sola línea, lo cual es útil para inicializar variables con valores específicos desde el principio:

var altura float64 = 1.75

En este caso, la variable altura se declara como un float64 y se inicializa con el valor 1.75. Esta forma de declaración es común cuando se conoce el valor inicial que debe tener la variable.

Además, Go proporciona una sintaxis más concisa para la declaración y asignación de variables a través de la declaración corta con el operador :=. Esta forma se utiliza habitualmente dentro de funciones y permite al compilador inferir el tipo de la variable basado en el valor asignado:

nombre := "Juan"
edad := 30

Aquí, las variables nombre y edad son declaradas e inicializadas con valores específicos, y el compilador deduce que nombre es de tipo string y edad es de tipo int.

Es importante mencionar que el uso de := está restringido al ámbito local de las funciones y no puede ser utilizado para la declaración de variables a nivel de paquete. Por otro lado, la declaración con var es más versátil y puede ser utilizada tanto a nivel de paquete como dentro de funciones.

Las variables en Go pueden ser agrupadas en una sola declaración para mejorar la legibilidad del código. Esto se realiza envolviendo múltiples declaraciones de variables dentro de un bloque:

var (
    nombre   string
    edad     int
    altura   float64
)

Este enfoque es especialmente útil cuando se declaran varias variables relacionadas, ya que reduce la repetición de la palabra clave var y organiza el código de manera más clara.

Finalmente, es crucial entender que la asignación de una variable puede ser cambiada en cualquier momento después de su declaración inicial, siempre que el nuevo valor sea compatible con el tipo de la variable. Esto permite que las variables en Go sean flexibles y adaptables a las necesidades cambiantes del programa.

Tipos de datos primitivos: enteros, flotantes, booleanos, cadenas

En Go, los tipos de datos primitivos son fundamentales para el manejo de datos básicos. Estos tipos incluyen enteros, flotantes, booleanos y cadenas, cada uno con características específicas que determinan su uso y comportamiento en el lenguaje.

Los enteros en Go se dividen en varias categorías según su tamaño y signo. Los tipos básicos son int y uint, que representan enteros con signo y sin signo, respectivamente. Además, existen variantes específicas como int8, int16, int32, int64, y sus equivalentes sin signo uint8, uint16, uint32, uint64. El tipo int es generalmente equivalente a int32 o int64, dependiendo de la arquitectura del sistema. Por ejemplo:

var a int = 42
var b uint = 100
var c int64 = 900000000000

Los números flotantes se utilizan para representar valores con punto decimal. Go proporciona los tipos float32 y float64, siendo este último el más común debido a su mayor precisión. Estos tipos permiten cálculos más precisos y son esenciales para aplicaciones científicas y financieras. Por ejemplo:

var x float32 = 3.14
var y float64 = 2.718281828459045

El tipo booleano en Go se representa con bool, que puede contener solo dos valores: true o false. Los booleanos son cruciales para el control de flujo y las operaciones lógicas dentro de un programa. Por ejemplo:

var isValid bool = true
var hasAccess bool = false

Las cadenas de caracteres en Go se manejan mediante el tipo string, que es una secuencia inmutable de bytes, representando texto codificado en UTF-8. Las cadenas pueden contener texto Unicode y se delimitan por comillas dobles. Es importante destacar que las cadenas son inmutables, lo que significa que no pueden ser modificadas una vez creadas. Por ejemplo:

var saludo string = "Hola, mundo"
var mensaje string = "Go es eficiente"

Una característica destacada de Go es su capacidad para convertir tipos de manera explícita. Esto es importante cuando se necesita operar con diferentes tipos de datos primitivos. Por ejemplo, para convertir un int a float64, se utiliza una conversión explícita:

var entero int = 10
var flotante float64 = float64(entero)

Además, las operaciones entre tipos diferentes requieren una conversión explícita para evitar errores de compilación, asegurando que el programador sea consciente de la manipulación de datos.

Uso de constantes con la palabra clave const

En Go, las constantes se definen utilizando la palabra clave const. A diferencia de las variables, las constantes son valores que no pueden cambiar durante la ejecución del programa. Esto las hace ideales para representar valores que deben permanecer inmutables, como los números matemáticos constantes o configuraciones que no varían. La sintaxis para declarar una constante es similar a la de una variable, pero con const en lugar de var:

const pi = 3.14159
const saludo = "Hola, mundo"

En estos ejemplos, pi es una constante de tipo float64 y saludo es una constante de tipo string. Es importante notar que Go infiere el tipo de la constante basado en el valor asignado. Además, las constantes en Go pueden ser de tipo numérico, de cadena o booleano.

Una característica clave de las constantes en Go es que no tienen un tipo fijo hasta que son utilizadas en una expresión que requiere un tipo específico. Esto permite que las constantes numéricas se utilicen de manera flexible en cálculos sin necesidad de conversiones explícitas, siempre que el tipo final sea compatible. Por ejemplo:

const ancho = 8
const alto = 6
var area = ancho * alto // Go infiere que el resultado es de tipo int

Las constantes también pueden ser definidas en bloques para agruparlas, lo que mejora la organización del código y facilita el mantenimiento. Este enfoque es útil cuando se declaran múltiples constantes relacionadas entre sí:

const (
    velocidadLuz     = 299792458 // en metros por segundo
    gravedadTierra   = 9.80665   // en m/s^2
    constantePlanck  = 6.62607015e-34 // en J·s
)

Go permite el uso de iota dentro de un bloque de constantes para crear secuencias incrementales. iota es una constante predefinida que se incrementa automáticamente dentro de un bloque de constantes, comenzando desde cero. Esto es especialmente útil para definir enumeraciones:

const (
    domingo = iota // iota es 0
    lunes          // iota es 1
    martes         // iota es 2
    miércoles      // iota es 3
    jueves         // iota es 4
    viernes        // iota es 5
    sábado         // iota es 6
)

En este ejemplo, domingo se asigna a 0, lunes a 1, y así sucesivamente. Esto es útil para representar días de la semana o cualquier conjunto de valores que requiera una secuencia numérica.

Finalmente, es fundamental entender que las constantes en Go no pueden ser modificadas una vez definidas. Intentar cambiar el valor de una constante generará un error de compilación. Esta inmutabilidad garantiza que las constantes sean seguras y confiables para su uso en cualquier parte del programa, proporcionando una base sólida para valores que no deben cambiar.