Guía completa de Go para principiantes: sintaxis básica, variables y tipos de datos

Resumen rápido

Go es un lenguaje de programación excelente para aplicaciones de servidor. Con él puedes crear APIs, microservicios, aplicaciones de scripting, desarrollo web, DevOps y mucho más.

Es un lenguaje de alto nivel, pero con “superpoderes” gracias a su modelo de concurrencia nativo y eficiente. Las goroutines y los canales lo hacen ideal para tareas concurrentes y paralelas.

A diferencia de otros lenguajes, Go no es orientado a objetos, ya que no tiene herencia de clases. En su lugar, promueve la composición a través de la incrustación de structs.

Inicio rápido

Para arrancar una aplicación en Go, solo necesitas ejecutar el siguiente comando en tu terminal:

go mod init app-name

Este comando crea un módulo de Go, un archivo clave para gestionar las dependencias y versiones de las librerías que uses en tu proyecto.

Estructura de archivos

Como cualquier lenguaje, Go tiene una estructura básica. El punto de partida de tu aplicación siempre será el archivo main.go, que se encarga de ejecutar el programa.

Aquí tienes un ejemplo del clásico Hello World:

package main

import "fmt"

func main() {
	fmt.Println("Hello world!")
}

Ahora, veamos la estructura de este código:

package main: Todos los archivos deben pertenecer a un paquete. Esta es la forma de organizar y modularizar el código en Go, permitiendo que los archivos sean accesibles entre sí e incluso importables desde otros lugares.
import ("fmt"): Cada archivo debe incluir las importaciones que usa. Por ejemplo, si necesitas mostrar algo en la consola, importas el paquete fmt. También puedes importar tus propios paquetes, como import "calculadora/operacion", donde calculadora es el nombre de la app y operacion el nombre del paquete.
Contenido: El resto del archivo es donde defines variables, constantes, funciones, structs e interfaces.

Public vs. Private

En Go, la visibilidad de funciones, variables o constantes no se basa en palabras clave, sino en la nomenclatura.

Públicos

Para que un método o propiedad sea público, su nombre debe empezar con una letra mayúscula.

Ejemplos:

package properties_public

const Pi = 3.1415

var Persons = []Person{ {...} }

func GetFirstPerson(person []Person) Person {...}

Como ves, todo lo que empieza con mayúscula se puede acceder desde cualquier otro paquete. Por ejemplo: properties_public.Pi o properties_public.Persons.

Privados

Para que un método o propiedad sea privado, su nombre debe empezar con una letra minúscula. Esto impide que se acceda a ellos desde fuera del paquete.

Ejemplos:

package properties_public

var language = "ES_MX"

func suma(...numbers float64) float64 {...}

Nota: Los elementos privados solo son accesibles dentro del mismo paquete. Los elementos públicos son accesibles desde cualquier otro paquete.

Tipos de datos

No entraré en demasiados detalles, ya que la mayoría de los programadores ya están familiarizados con los tipos de datos. Aquí tienes una tabla con algunos de los que Go maneja:

Tipo de dato	Descripción
`bool`	`true` o `false` para flags o condicionales
`int`, `int8`, etc.	Números enteros
`uint`, `uint8`, etc.	Números enteros sin signo (positivos)
`float32`, `float64`	Valores numéricos reales (con decimales)
`byte` (= `uint8`)	Para trabajar con datos binarios
`rune` (= `int32`)	Para representar un solo carácter (Unicode)
`complex64`, etc.	Para números complejos con parte real e imaginaria

Una de las cosas geniales de Go es su capacidad de inferir los tipos de datos, así que no siempre necesitas declararlos explícitamente.

Ejemplo:

var name string = "Gersom" // Declaración explícita
var age = 37 // Go infiere que es int
var isDeveloper = true // Go infiere que es bool

Declaración de variables

Hay diferentes maneras de declarar una variable en Go. La elección depende del contexto, sobre todo si la declaras dentro o fuera de una función.

Dentro de una función, puedes usar la forma corta: name := "Gersom". Aquí, el compilador infiere el tipo de dato y no es necesario usar var.

También puedes usar var cuando solo necesitas declarar la variable y la asignarás más tarde.

Mira este ejemplo para entender mejor:

func suma(a, b, c int) int {
	var total int // Solo declaras, asignas después.
	subtotal := a + b // Declaras y asignas al mismo tiempo.
	total = subtotal + c
	return total
}

En este caso, la variable subtotal se declara y se le asigna un valor de inmediato, así que no necesitas var ni el tipo de dato. En cambio, a total la declaras primero y le asignas su valor después.

Importante: Fuera de una función, no puedes usar :=. La declaración siempre debe empezar con var. Sin embargo, si le asignas un valor inmediatamente, Go inferirá el tipo: var name = "value".

Valores por defecto

Cuando declaras una variable pero no le asignas un valor, Go le da uno por defecto:

Tipo de dato	Valor por defecto
`string`	`""` (cadena vacía)
`bool`	`false`
`int`	`0`
`float`	`0.0`
`byte`	`0`
`rune`	`0`
`complex`	`0+0i`

Conclusión

Este es mi primer acercamiento a Go y, aunque faltan temas importantes como los arrays, maps, channels, interfaces y structs, por ahora nos quedamos aquí. Estaré escribiendo más notas a medida que avance en mi aprendizaje.

¡Nos vemos en un próximo post, devs!