Cómo aprobar una entrevista de Go: principales preguntas y respuestas

Cómo aprobar una entrevista de Go: preguntas principales

Go (Golang) es uno de los lenguajes más demandados para crear aplicaciones de servidor de alta carga y microservicios. La entrevista para un puesto de desarrollador Go a menudo evalúa no solo el conocimiento de la sintaxis, sino también la comprensión del funcionamiento interno: gorutinas, canales, interfaces y gestión de memoria. En este artículo, analizaremos las 10 preguntas principales que se hacen con más frecuencia en las entrevistas, con ejemplos de código y explicaciones.

1. ¿Cuál es la diferencia entre un array y un slice (array vs slice)?

Esta es una pregunta clásica para entender los fundamentos de Go.

• Array — es una secuencia fija de elementos del mismo tipo. El tamaño del array es parte de su tipo.
• Slice — es una estructura dinámica que hace referencia a un array subyacente. El slice puede crecer y cambiar de tamaño.

// Array — tamaño fijovar arr [3]int = [3]int{1, 2, 3}// Slice — dinámicovar slc []int = []int{1, 2, 3}

// Importante: arr y [4]int son tipos diferentes// Los slices se pasan por referencia (puntero al array subyacente)

Consejo: Si necesitas cambiar la longitud, usa slice. Si necesitas garantía de tamaño fijo, usa array.

2. ¿Qué son las gorutinas y cómo funcionan?

Una gorutina es un hilo de ejecución ligero gestionado por el runtime de Go. A diferencia de los hilos del sistema (OS threads), las gorutinas tienen una pila más pequeña (a partir de 2 KB) y cambian rápidamente.

• Inicio de una gorutina: go func()
• Las gorutinas trabajan en el mismo espacio de direcciones, por lo que el acceso a datos compartidos debe sincronizarse (a través de canales o mutex).

package main

import (    "fmt"    "time")

func printNumbers() {    for i := 1; i <= 5; i++ {        time.Sleep(100 * time.Millisecond)        fmt.Println(i)    }}

func main() {    go printNumbers() // inicio de gorutina    time.Sleep(1 * time.Second) // esperamos a que termine    fmt.Println("Main done")}

Importante: La función principal no espera a que las gorutinas terminen. Para sincronizar, usa sync.WaitGroup o canales.

3. ¿Cómo funcionan los canales (channels)?

Los canales son "tuberías" tipadas a través de las cuales las gorutinas intercambian datos. Proporcionan una transferencia segura de datos sin bloqueos explícitos.

• Canal no buferizado: el emisor se bloquea hasta que el receptor lee los datos.
• Canal buferizado: el emisor se bloquea solo cuando el búfer está lleno.

ch := make(chan int)    // no buferizadochBuf := make(chan int, 3) // buferizado (capacidad 3)

// Envíogo func() {    ch <- 42}()

// Recepciónvalue := <-chfmt.Println(value)

// Cierre del canalclose(ch)// Leer de un canal cerrado devuelve el valor cero

Pregunta frecuente: ¿Qué sucede si se lee de un canal nil? — Respuesta: la gorutina se bloqueará para siempre (deadlock).

4. ¿Qué son las interfaces en Go y en qué se diferencian de otros lenguajes?

Una interfaz en Go es un conjunto de métodos. A diferencia de Java o C#, la implementación de una interfaz en Go es implícita (duck typing): un tipo satisface automáticamente la interfaz si implementa todos sus métodos.

type Speaker interface {    Speak() string}

type Dog struct{}func (d Dog) Speak() string { return "Woof!" }

type Cat struct{}func (c Cat) Speak() string { return "Meow!" }

func makeSound(s Speaker) {    fmt.Println(s.Speak())}

func main() {    makeSound(Dog{}) // Woof!    makeSound(Cat{}) // Meow!}

Por qué es importante: Permite escribir código flexible y débilmente acoplado. La interfaz vacía interface{} (o any en Go 1.18+) puede almacenar un valor de cualquier tipo.