Cheatsheet de Golang

Instalación de Go

Puedes descargar e instalar Go desde su sitio web oficial golang.org.

Configurar la variable de entorno:

• Windows: Añade C:\Go\bin a la variable de entorno PATH.
• macOS/Linux: Añade export PATH=$PATH:/usr/local/go/bin en tu archivo .bash_profile o .bashrc.

Verificar la instalación de Go

Para comprobar que Go está correctamente instalado y ver la versión:

go version

Crear un nuevo proyecto

Crea un nuevo módulo Go y configura el archivo go.mod que gestionará las dependencias.

go mod init nombre_modulo

Programa básico

Ejemplo de un programa

package main

import "fmt"

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

Ejecutar un programa Go

Compila y ejecuta el archivo .go:

go run archivo.go

Compilar un programa Go

Crea un ejecutable desde el archivo fuente.

go build archivo.go

Instalar un programa Go

Compila e instala el programa en tu GOPATH/bin.

go install

Declarar una variable

Go admite la declaración de variables explícitamente con var o con inferencia de tipos utilizando :=.

var x int = 10
y := 20 // Inferencia de tipos

Declarar múltiples variables

Puedes declarar múltiples variables en una sola línea.

var a, b int = 1, 2
c, d := 3, "hello"

Tipos básicos en Go

• int, float64: Números enteros y decimales.
• bool: Booleano (true/false).
• string: Cadena de texto.
• array: Arreglo de longitud fija.
• slice: Arreglo dinámico.
• struct: Estructura de datos personalizada.

Conversión de tipos

Go no realiza conversiones automáticas de tipo, por lo que es necesario convertir manualmente.

x := 42
y := float64(x)

Función básica

Go permite definir funciones con tipos explícitos de entrada y salida.

func suma(a int, b int) int {
return a + b
}

Funciones con múltiples valores de retorno

Las funciones en Go pueden devolver más de un valor.

func dividir(a, b int) (int, int) {
return a / b, a % b
}

Funciones anónimas (closures)

Go soporta funciones anónimas o closures, que pueden ser asignadas a variables.

suma := func(a, b int) int {
return a + b
}
fmt.Println(suma(3, 4))

Funciones con parámetros variables

Go permite funciones que aceptan un número variable de argumentos.

func sumarTodos(nums ...int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}

Métodos

func (p Persona) Saludar() string {
return "Hola, mi nombre es " + p.Nombre
}

Estructura if-else

El condicional if puede incluir inicialización de variables dentro de su declaración.

if x := 10; x > 5 {
fmt.Println("Mayor que 5")
} else {
fmt.Println("Menor o igual a 5")
}

Switch

El switch en Go no necesita break, ya que automáticamente finaliza la ejecución de cada caso.

switch dia {
case 1:
fmt.Println("Lunes")
case 2:
fmt.Println("Martes")
default:
fmt.Println("Otro día")
}

Bucle for

El bucle for es el único bucle disponible en Go, y puede funcionar como while.

for i := 0; i < 5; i++ {
fmt.Println(i)
}

Bucle infinito

Puedes crear bucles infinitos utilizando for sin condiciones.

for {
fmt.Println("Bucle infinito")
}

Arrays

Los arrays tienen un tamaño fijo definido en el momento de su creación.

var arr [5]int
arr[0] = 1
fmt.Println(arr)

Slices

Los slices son arrays dinámicos y son más comunes en Go.

slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice)

Utiliza append para agregar nuevos elementos a un slice.

slice = append(slice, 6)

Mapas

Los mapas son colecciones clave-valor.

m := make(map[string]int)
m["uno"] = 1
m["dos"] = 2
fmt.Println(m)

Crear un struct

Los structs son tipos de datos definidos por el usuario que pueden agrupar datos relacionados.

type Persona struct {
Nombre string
Edad   int
}

Inicializar y acceder a un struct

persona := Persona{Nombre: "Juan", Edad: 30}
fmt.Println(persona.Nombre)

Interfaces

Las interfaces en Go definen comportamientos que un tipo puede implementar.

type Animal interface {
sonido() string
}

Manejo básico de errores

func Dividir(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("no se puede dividir por cero")
}
return a / b, nil
}

Uso de errores

resultado, err := Dividir(4, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Resultado:", resultado)
}

Lectura de entrada estándar

var nombre string
fmt.Print("Introduce tu nombre: ")
fmt.Scanln(&nombre)

Escritura en archivo

file, err := os.Create("archivo.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
file.WriteString("Hola, mundo!")

Goroutine

Las goroutines permiten la ejecución concurrente de funciones.

go func() {
fmt.Println("Hola desde la goroutine")
}()

Crear y usar canales

Los canales son utilizados para sincronizar la comunicación entre goroutines.

c := make(chan string)

// Enviar datos a un canal
go func() {
c <- "Mensaje"
}()

// Recibir datos del canal
fmt.Println(<-c)

Selección

select {
case msg1 := <-ch1:
fmt.Println(msg1)
case msg2 := <-ch2:
fmt.Println(msg2)
default:
fmt.Println("Ningún mensaje recibido")
}

Cerrar un canal

Un canal puede ser cerrado cuando ya no es necesario enviar más datos.

close(c)

Crear y usar módulos

go mod init nombre_modulo
go mod tidy // Para limpiar las dependencias

Importar paquetes estándar

Go incluye una biblioteca estándar robusta, que puede ser importada según sea necesario.

import (
"fmt"
"math"
)

Importar paquetes locales

Puedes organizar tu código en múltiples archivos y paquetes locales.

import "mi_proyecto/mipaquete"

Crear un paquete

// En archivo mi_paquete.go
package mi_paquete

func MiFuncion() {
// código
}

Agregar una dependencia al módulo

Para agregar un paquete externo al proyecto, se usa go get.

go get github.com/gin-gonic/gin

Actualizar dependencias

Actualiza todas las dependencias del proyecto.

go mod tidy

Escribir una prueba unitaria

Go incluye un paquete nativo para testing (testing).

package main

import "testing"

func TestSuma(t *testing.T) {
resultado := suma(2, 3)
if resultado != 5 {
t.Errorf("Error: se esperaba 5, se obtuvo %d", resultado)
}
}

Ejecutar pruebas unitarias

Ejecuta todas las pruebas definidas en tu proyecto.

go test

Ver cobertura de las pruebas

Muestra un informe de la cobertura de las pruebas unitarias.

go test -cover

Formatear código automáticamente

Go incluye una herramienta para formatear el código de acuerdo con las convenciones del lenguaje.

go fmt

Generar documentación

Genera documentación a partir de comentarios en el código.

go doc

Analizar código

go vet analiza el código en busca de posibles errores comunes.

go vet

Compilar para diferentes sistemas operativos

Go permite compilar ejecutables para otros sistemas operativos usando variables de entorno.

GOOS=linux GOARCH=amd64 go build

Gin

Framework para crear APIs web.

Gorilla Mux

Enrutador HTTP.

GORM

ORM para bases de datos.

Viper

Manejo de configuraciones.