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

Cómo pasar una entrevista de Go: preguntas principales con ejemplos de código

La entrevista para un puesto de desarrollador Go no solo es una prueba de sintaxis, sino también una comprensión profunda del modelo de concurrencia, la gestión de memoria y el estilo idiomático del lenguaje. En este artículo, analizamos las 10 preguntas principales que se hacen con más frecuencia en las entrevistas de Golang, con respuestas detalladas y ejemplos de código. El material es adecuado tanto para nivel Junior como Middle.

1. Gorutinas vs hilos del SO: ¿cuál es la diferencia?

Esta es una pregunta básica que evalúa la comprensión del modelo de ejecución de Go. La respuesta debe ser clara:

• Tamaño de la pila: Una gorutina comienza con una pila de ~2 KB que crece dinámicamente. Un hilo del SO tiene una pila fija (1-8 MB).
• Cambio de contexto: Las gorutinas cambian en el espacio de usuario (Go scheduler). Los hilos cambian mediante una llamada al sistema (más costosa).
• Costo de creación: Una gorutina cuesta ~4 KB de memoria, un hilo ~1 MB. Se pueden ejecutar miles de gorutinas.

// Ejemplo: 10000 gorutinasfunc main() {    for i := 0; i < 10000; i++ {        go func(n int) {            fmt.Println("Gorutina", n)        }(i)    }    time.Sleep(time.Second)}

2. Canales: con búfer y sin búfer

Pregunta sobre la comprensión de la sincronización. Explica la diferencia con un ejemplo:

• Canal sin búfer: El envío se bloquea hasta que se recibe. Garantiza la sincronía.
• Canal con búfer: El envío no se bloquea hasta que el búfer está lleno. Permite la transmisión asíncrona.

// Canal sin búferch := make(chan int)go func() { ch <- 42 }()val := <-ch // Se bloquea hasta que llegue el valor

// Canal con búferbufCh := make(chan int, 2)bufCh <- 1 // No se bloqueabufCh <- 2 // No se bloquea// bufCh <- 3 // Se bloquea - el búfer está lleno

3. Select y manejo de múltiples canales

El operador select permite esperar múltiples operaciones con canales. A menudo preguntan sobre default y timeouts:

func main() {    ch1 := make(chan string)    ch2 := make(chan string)

    go func() { time.Sleep(2 * time.Second); ch1 <- "from ch1" }()    go func() { time.Sleep(1 * time.Second); ch2 <- "from ch2" }()

    select {    case msg := <-ch1:        fmt.Println(msg)    case msg := <-ch2:        fmt.Println(msg)    case <-time.After(3 * time.Second):        fmt.Println("Timeout")    }}

4. Interfaces: interfaz vacía y type assertion

Evaluación de la comprensión de interface{} (any) y la conversión segura de tipos:

func describe(i interface{}) {    switch v := i.(type) {    case int:        fmt.Printf("Entero: %d", v)    case string:        fmt.Printf("Cadena: %s", v)    default:        fmt.Printf("Tipo desconocido: %T", v)    }}

func main() {    describe(42)    describe("hello")    describe(3.14)}

5. Gestión de memoria: pila y montón, escape analysis

Pregunta sobre cómo Go decide dónde colocar las variables. El punto clave es el escape analysis:

• Si el compilador ve que una variable puede ser utilizada después de que la función retorne, "escapa" al montón.
• El uso de punteros, interfaces y closures a menudo provoca asignación en el montón.

// La variable x "escapa" al montónfunc createPointer() *int {    x := 42    return &x // x no puede estar en la pila}

6. Defer: orden de ejecución y particularidades

Defer se ejecuta según el principio LIFO (Last In, First Out). Los argumentos se evalúan en el momento de la declaración, no en el de la ejecución:

func main() {    x := 10    defer