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 inclusión de estructuras es el mecanismo de Go para incluir un tipo de estructura dentro de otra. En lugar de usar un nombre de campo, simplemente especificas el tipo, y Go promociona los campos de la estructura incluida a la estructura externa.

Esta es la sintaxis básica:

type Address struct {
    City    string
    Country string
}

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

Cuando insertas Address en Person, puedes acceder directamente a los campos insertados desde 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 promueve 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 las estructuras anidadas habituales, en las que siempre debes usar el nombre del campo para acceder a los campos internos. La inclusión crea una API más plana y cómoda, al tiempo que mantiene la agrupación lógica de los datos relacionados.

Desafío

Fácil

Construyamos un sistema de registro de vehículos que use la inclusión de estructuras para crear un modelo de datos limpio y organizado. Separarás la información de contacto de los detalles del vehículo y, al mismo tiempo, permitirás el acceso directo a todos los campos mediante la inclusión.

Organizarás tu código en dos archivos:

vehicle.go: Crea dos estructuras que trabajen juntas mediante la inclusión:
- Una estructura ContactInfo con los campos OwnerName y Phone (ambos de tipo string)
- Una estructura Vehicle que incluya ContactInfo (sin nombre de campo) y agregue 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 de contacto.
main.go: Lee los detalles del vehículo y del propietario desde la entrada, crea una instancia de Vehicle con ContactInfo incluido y demuestra el acceso a los campos incluidos tanto directamente como mediante el nombre del tipo incluido. 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 con 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 Vehicle (por ejemplo, v.OwnerName)
El teléfono accedido mediante el tipo incluido (por ejemplo, v.ContactInfo.Phone)
El resumen completo de tu método Summary

Por ejemplo, dadas las entradas 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: el acceso directo mediante la promoción de campos y el acceso explícito mediante el nombre del tipo incluido, lo que te proporciona flexibilidad al trabajar con datos incluidos.

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
	// Usa los valores leídos de la entrada anterior

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

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

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

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