1. Fundamentos de Go (120 preguntas)

Por qué:

Comprender los valores cero evita problemas de ejecución causados por mapas no inicializados.

Qué:

• El valor cero de un mapa es nil.
• Un mapa nulo no puede contener pares clave-valor.

Cómo:

        	var m map[string]int // m == nil
        	m = make(map[string]int) // inicializar
        	m["age"] = 30 // ahora funciona
      	

Caso de uso en la vida real:

Un mapa nulo podría representar un objeto de configuración sin inicializar. Una inicialización correcta evita fallos al agregar configuraciones.

Por qué:

Go aplica una tipificación estricta para evitar la pérdida accidental de datos.

Qué:

• No hay conversión implícita entre tipos numéricos.
• Se requiere casting explícito.

Cómo:

          i := 42
          f := float64(i) // conversión explícita
          i = int(f) // volver a int (trunca el decimal)
        

Caso de uso en la vida real:

Conversión de lecturas de sensores (enteros) a valores de punto flotante para cálculos científicos.

Por qué:

iota simplifica las declaraciones de constantes secuenciales.

Qué:

• iota se incrementa automáticamente desde 0 en un bloque de constantes.

Cómo:

          const(
          Sunday = iota  // 0
          Monday         // 1
          Tuesday        // 2
          // ... hasta Saturday (6))
        

Caso de uso en la vida real:

Representar días en sistemas de programación (por ejemplo, aplicaciones de calendario).

Por qué:

Elegir el estilo de declaración correcto afecta la legibilidad y el alcance del código.

Qué:

• var x int = 10: Declaración de tipo explícita, funciona en cualquier ámbito.
• x := 10: Inferencia de tipos, solo dentro de funciones.

Cómo:

          varglobalVar int = 10 // nivel de paquete

          funcmain(){
            localVar := 20 // nivel de función
          }
        

Caso de uso en la vida real:

Usando var para constantes a nivel de paquete y := para variables de bucle local.

Por qué:

Go prioriza el código limpio y eficiente y la seguridad en tiempo de compilación.

Qué:

• Las variables/importaciones no utilizadas indican posibles errores o inflación.
• El compilador lanza errores para forzar la limpieza.

Cómo:

          // Error: unused import "fmt"
          // Error: unused variable x
          import"fmt"
          func main() {
            x := 10
          }
        

Caso de uso en la vida real:

Evitar que las variables de depuración sobrantes se envíen a producción.

Por qué:

Las cadenas sin formato mejoran la legibilidad de las plantillas o JSON.

Qué:

• Utilice comillas invertidas ` para literales de cadena sin formato.

Cómo:

          s :=`Line 1
          Line 2
          Line 3`
        

Caso de uso en la vida real:

Incrustar consultas SQL o plantillas HTML en el código.

Por qué:

Ignora los valores que no necesitas, evitando las advertencias del compilador.

Qué:

• Omite el índice o valor en bucles de rango.

Cómo:

          for _, value := range []int{1,2,3} {
            fmt.Println(value) // ignorar indice
          }
        

Caso de uso en la vida real:

Procesamiento de elementos de slices sin necesidad de conocer sus posiciones.

Por qué:

El manejo de desbordamientos afecta la integridad de los datos en sistemas de bajo nivel.

Qué:

• Se envuelve usando aritmética de complemento a dos.

Cómo:

          var a int8 = 127
          a++ // -128 (desbordamiento)
        

Caso de uso en la vida real:

Manejo de datos de sensores que exceden los límites del hardware.

Por qué:

Comprender el tipo de runa de Go es clave para el manejo de Unicode.

Qué:

• 'a' es una runa (alias para int32).

Cómo:

          fmt.Printf("%T",'a') // salida: int32
        

Caso de uso en la vida real:

Procesamiento de texto multilingüe (por ejemplo, emojis en la entrada del usuario).

Por qué:

Los alias de tipo mejoran la claridad del código y evitan el uso indebido.

Qué:

• Utilizar type NewName ExistingType.

Cómo:

          type UserID int
          var id UserID =1001
        

Caso de uso en la vida real:

Distinguir los identificadores de bases de datos de los números enteros regulares.