Conceptos básicos de incrustación de structs

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 35 de 107.

La incrustación de structs (struct embedding) es el mecanismo de Go para incluir un tipo struct dentro de otro. En lugar de usar un nombre de campo, simplemente se especifica el tipo, y Go promueve los campos del struct incrustado al struct externo.

Aquí está la sintaxis básica:

type Address struct {
    City    string
    Country string
}

type Person struct {
    Name string
    Address  // embebido - sin nombre de campo
}

Cuando incrustas Address en Person, puedes acceder a los campos incrustados directamente en la estructura externa:

func main() {
    p := Person{
        Name: "Alice",
        Address: Address{
            City:    "London",
            Country: "UK",
        },
    }
    
    fmt.Println(p.City)     // London - acceso directo
    fmt.Println(p.Country)  // UK - acceso directo
    fmt.Println(p.Address.City)  // también funciona
}

Observa cómo p.City funciona sin escribir explícitamente p.Address.City. Go promociona automáticamente los campos de la estructura incrustada, haciéndolos accesibles como si pertenecieran a la estructura externa. Aún puedes acceder a ellos a través del nombre del tipo incrustado cuando sea necesario.

Esto difiere de los structs anidados regulares donde siempre debes usar el nombre del campo para acceder a los campos internos. La incrustación crea una API más plana y conveniente, manteniendo al mismo tiempo la agrupación lógica de los datos relacionados.

Desafío

Fácil

Vamos a construir un sistema de registro de vehículos que utiliza la incrustación de estructuras (struct embedding) para crear un modelo de datos limpio y organizado. Separarás la información de contacto de los detalles del vehículo, permitiendo al mismo tiempo el acceso directo a todos los campos a través de la incrustación.

Organizarás tu código en dos archivos:

vehicle.go: Crea dos estructuras que trabajen juntas mediante la incrustación:
- Una estructura ContactInfo con los campos OwnerName y Phone (ambos strings)
- Una estructura Vehicle que incrusta ContactInfo (sin un nombre de campo) y añade sus propios campos Make, Model y Year
También crea un método llamado Summary en Vehicle que devuelva una cadena formateada que contenga toda la información del vehículo y del contacto.
main.go: Lee los detalles del vehículo y del propietario desde la entrada, crea una instancia de Vehicle con ContactInfo incrustado, y demuestra el acceso a los campos incrustados tanto directamente como a través del nombre del tipo incrustado. Imprime el resumen del vehículo al final.

Se proporcionarán las siguientes entradas:

Línea 1: Nombre del propietario
Línea 2: Número de teléfono
Línea 3: Marca del vehículo
Línea 4: Modelo del vehículo
Línea 5: Año (entero)

Tu método Summary debe devolver una cadena en este formato:

[Year] [Make] [Model] - Owner: [OwnerName], Phone: [Phone]

En tu archivo principal, demuestra la promoción de campos imprimiendo:

El nombre del propietario accedido directamente en el Vehicle (por ejemplo, v.OwnerName)
El teléfono accedido a través del tipo incrustado (por ejemplo, v.ContactInfo.Phone)
El resumen completo de tu método Summary

Por ejemplo, dados Alice Smith, 555-1234, Toyota, Camry y 2023, tu salida debería ser:

Alice Smith
555-1234
2023 Toyota Camry - Owner: Alice Smith, Phone: 555-1234

Observa cómo funcionan ambos patrones de acceso —acceso directo a través de la promoción de campos y acceso explícito a través del nombre del tipo incrustado— lo que te brinda flexibilidad en la forma en que trabajas con datos incrustados.

Hoja de referencia

La incrustación de estructuras (struct embedding) permite incluir un tipo de estructura dentro de otra sin especificar un nombre de campo. Los campos de la estructura incrustada se promocionan a la estructura externa, lo que los hace directamente accesibles.

Sintaxis Básica

type Address struct {
    City    string
    Country string
}

type Person struct {
    Name string
    Address  // embedded - no field name
}

Acceso a Campos Incrustados

Puedes acceder a los campos incrustados de dos maneras:

p := Person{
    Name: "Alice",
    Address: Address{
        City:    "London",
        Country: "UK",
    },
}

// Direct access (field promotion)
fmt.Println(p.City)     // London

// Through embedded type name
fmt.Println(p.Address.City)  // London

Go promociona automáticamente los campos de la estructura incrustada, permitiendo el acceso directo como si pertenecieran a la estructura externa. Aún puedes acceder a ellos a través del nombre del tipo incrustado cuando sea necesario.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Leer el nombre del propietario
	ownerName, _ := reader.ReadString('\n')
	ownerName = strings.TrimSpace(ownerName)

	// Leer el número de teléfono
	phone, _ := reader.ReadString('\n')
	phone = strings.TrimSpace(phone)

	// Leer la marca del vehículo
	make, _ := reader.ReadString('\n')
	make = strings.TrimSpace(make)

	// Leer el modelo del vehículo
	model, _ := reader.ReadString('\n')
	model = strings.TrimSpace(model)

	// Leer el año
	yearStr, _ := reader.ReadString('\n')
	yearStr = strings.TrimSpace(yearStr)
	year, _ := strconv.Atoi(yearStr)

	// TODO: Crear una instancia de Vehicle con ContactInfo embebido
	// Usar los valores leídos de la entrada anterior

	// TODO: Imprimir el nombre del propietario accedido directamente en el Vehicle (promoción de campos)
	// Example: fmt.Println(v.OwnerName)

	// TODO: Imprimir el teléfono accedido a través del nombre del tipo embebido
	// Example: fmt.Println(v.ContactInfo.Phone)

	// TODO: Imprimir el resumen completo usando el método Summary
	// Example: fmt.Println(v.Summary())

	// Eliminar estas líneas una vez que implementes la solución
	_ = ownerName
	_ = phone
	_ = make
	_ = model
	_ = year
}