Resumen de puntos clave de Fundamentos de Go

Cada viñeta de puntos clave de las 9 páginas de esta sección, reunida en una sola página y agrupada por la página de la que proviene.

Cómo se estructuran los programas de Go: Paquetes, main y la Toolchain

• Solo el paquete main produce un ejecutable y debe definir el punto de entrada func main()
• go build recorre las importaciones desde main y compila cada paquete necesario en la caché de compilación
• Los nombres exportados comienzan con mayúscula; los identificadores en minúscula son privados del paquete
• El compilador rechaza las importaciones de internal/ desde fuera del módulo para encapsulación
• El enlazador realiza la eliminación de código muerto a nivel de función para minimizar el tamaño del binario
• Las funciones init se ejecutan antes de main en orden de dependencia para registro y configuración

Fundamentos básicos de Go

• El paquete main marca los ejecutables; go run . compila sin dejar un binario
• Use := solo dentro de funciones; var funciona a nivel de paquete
• Los tipos numéricos por defecto son 0; bool a false; punteros, slices y mapas a nil
• iota se reinicia por bloque const e incrementa una vez por línea
• range sobre cadenas produce el índice de bytes y la rune; len cuenta bytes, no runes
• append puede reasignar cuando la capacidad del array subyacente se excede

Variables, Constantes y Ámbito

• La declaración corta := es idiomática en funciones; var y const pertenecen al nivel del paquete
• Los valores de Const deben ser computables en tiempo de compilación: literales, aritmética o secuencias de iota
• El ámbito es léxico; los bloques internos sombrean los nombres externos pero los nombres a nivel de paquete cruzan archivos
• Las variables de bucle anteriores a la versión 1.22 en cierres de goroutine capturan una mutable; pásela como parámetro
• Las variables y las importaciones no utilizadas fallan la compilación; use el guion bajo _ para descartar intencionalmente
• Las declaraciones cortas := reutilizan nombres solo en el mismo bloque cuando al menos uno es nuevo

Valores Cero e Inicialización

• Los tipos de Go tienen valores cero: numéricos 0, bool false, cadena vacía, referencias nil
• Go idiomático aprovecha los valores cero para que las estructuras sean utilizables sin inicialización
• Los slices nil se añaden y devuelven de longitud cero, pero los mapas nil entran en pánico al escribir
• Los canales nil se bloquean para siempre al enviar, corrija con make o una guardia de verificación nil
• El valor cero de sync.Mutex está desbloqueado y listo para usar inmediatamente
• El valor de interfaz nil != nil si contiene un nil tipado, verifique explícitamente

Tipos Numéricos, Cadenas, Runas y Slices de Bytes

• Use []byte para datos binarios y []rune para operaciones indexadas por caracteres
• len(s) cuenta bytes UTF-8, no caracteres; use utf8.RuneCountInString en su lugar
• El tamaño de int y uint depende de la plataforma; use tipos con tamaño para la serialización
• range sobre cadenas produce el índice de bytes y el valor de rune
• Truncar con int32 envuelve silenciosamente valores grandes; verifique los límites antes de convertir
• Compare floats con épsilon, no con ==; 0.1+0.2 falla debido a pérdida de precisión

Arrays, Slices y Mapas de un Vistazo

• Los arrays son tipos de tamaño fijo; los slices son cabeceras de referencia con puntero, len, cap
• Los mapas se iteran en orden indefinido; ordene las claves si necesita un orden consistente
• Append crece duplicando la capacidad cuando len es igual a cap, potencialmente reasignando
• Las mutaciones de Slice son visibles para los llamadores ya que las cabeceras comparten el almacenamiento del array subyacente
• Los mapas nil entran en pánico al asignar; use make para inicializar antes de escribir en un mapa
• La sorpresa del alias de Append sobrescribe los elementos existentes; use un slice completo o copie para arreglar

Estructuras, Incrustación y Promoción de Campos

• La incrustación promueve campos y métodos exportados al tipo exterior sin herencia
• La colisión de nombres en la estructura exterior sombrea los campos del tipo incrustado, use Type.Field para acceder
• El receptor de puntero incrustado nil entra en pánico en las llamadas a métodos promovidos sin inicialización
• Los campos promovidos se aplanan en la codificación JSON por defecto, nombre los campos o ajuste las etiquetas
• Múltiples tipos incrustados con el mismo campo crean un acceso ambiguo que requiere un calificador
• Incrustar estructuras auxiliares no exportadas evita la exposición superficial no deseada de la composición

Punteros y el Operador de Dirección

• Use punteros para compartir mutaciones entre funciones sin duplicar datos
• La dirección de & y la desreferencia * permiten el uso de punteros; sin aritmética de punteros
• La desreferencia de puntero nil entra en pánico; proteja con p != nil antes de usar *p
• Use receptores de puntero en métodos cuando necesite modificar el receptor
• El análisis de escape decide la asignación en la pila o en el montón, no el uso del operador &
• Evite el uso excesivo de punteros; las copias de estructuras pequeñas son más rápidas que la indirección

Mejores Prácticas de Fundamentos de Go

• Preasigne slices con make([]T, 0, n) para reducir las asignaciones en bucles activos
• Inicialice mapas con make o literales; nunca asigne a mapas nil
• len(string) cuenta bytes, no caracteres; use utf8.RuneCountInString para texto visible por el usuario
• Siempre asigne el resultado de append ya que puede devolver una nueva cabecera de slice
• Use receptores de puntero para mutación, receptores de valor para tipos inmutables
• Los identificadores en mayúscula son una promesa de compatibilidad; exporte solo lo que los llamadores necesitan