Estructura anidada en Golang

Una estructura o struct en Golang es un tipo definido por el usuario que nos permite crear un grupo de elementos de diferentes tipos en una sola unidad. Cualquier entidad del mundo real que tenga un conjunto de propiedades o campos puede representarse como una estructura.

Cómo usar estructuras anidadas en Golang

El lenguaje Go permite estructuras anidadas. Una estructura que es un campo de otra estructura se denomina estructura anidada. En otras palabras, una estructura dentro de otra estructura se llama Estructura Anidada. Sintaxis:

type struct_name_1 struct{
  // Các trường
} 
type struct_name_2 struct{
  variable_name  struct_name_1

}

Considere el siguiente ejemplo para comprender la estructura anidada en Golang:

Ejemplo 1:

// Chương trình Go minh hoạc
// cấu trúc lồng nhau
package main

import "fmt"

// Tạo cấu trúc
type Author struct {
	name string
	branch string
	year int
}

// Tạo cấu trúc lòng nhau
type HR struct {

	// cấu trúc là một trường
	details Author
}

func main() {

	// Khởi tạo các trường
	// của cấu trúc
	result := HR{
	
		details: Author{"Sona", "ECE", 2013},
	}

	// Hiện giá trị
	fmt.Println("\nDetails of Author")
	fmt.Println(result)
}

Resultado:

Details of Author
{{Sona ECE 2013}}

Ejemplo 2:

// Chương trình Golang minh họa
// cấu trúc lồng nhau
package main

import "fmt"

// Tạo cấu trúc
type Student struct {
	name string
	branch string
	year int
}

// Tạo cấu trúc lồng nhau
type Teacher struct {
	name string
	subject string
	exp	 int
	details Student
}

func main() {

	// Khởi tạo các trường
	// của cấu trúc
	result := Teacher{
		name: "Suman",
		subject: "Java",
		exp:	 5,
		details: Student{"Bongo", "CSE", 2},
	}

	// Hiện giá trị
	fmt.Println("Details of the Teacher")
	fmt.Println("Teacher's name: ", result.name)
	fmt.Println("Subject: ", result.subject)
	fmt.Println("Experience: ", result.exp)

	fmt.Println("\nDetails of Student")
	fmt.Println("Student's name: ", result.details.name)
	fmt.Println("Student's branch name: ", result.details.branch)
	fmt.Println("Year: ", result.details.year)
}

Resultado:

Details of the Teacher
Teacher's name:  Suman
Subject:  Java
Experience:  5

Details of Student
Student's name:  Bongo
Student's branch name:  CSE
Year:  2

Ejemplo 3:

En Go, una estructura puede tener campos que son en sí mismos estructuras, llamadas estructuras anidadas. A continuación se muestra un ejemplo de una estructura que tiene una estructura anidada:

package main

import (
	"fmt"
)

type Address struct {
	Street	 string
	City	 string
	State	 string
	PostalCode string
}

type Person struct {
	FirstName string
	LastName string
	Age	 int
	Address Address
}

func main() {
	p := Person{
		FirstName: "John",
		LastName: "Doe",
		Age:	 30,
		Address: Address{
			Street:	 "123 Main St",
			City:	 "Anytown",
			State:	 "CA",
			PostalCode: "12345",
		},
	}

	fmt.Println(p.FirstName, p.LastName)
	fmt.Println("Age:", p.Age)
	fmt.Println("Address:")
	fmt.Println("Street:", p.Address.Street)
	fmt.Println("City:", p.Address.City)
	fmt.Println("State:", p.Address.State)
	fmt.Println("Postal Code:", p.Address.PostalCode)
}

Resultado:

John Doe
Age: 30
Address:
Street: 123 Main St
City: Anytown
State: CA
Postal Code: 12345

Aquí definimos dos tipos de estructuras: Persona y Dirección. La persona tiene un campo de estructura anidado llamado Dirección. En la función principal, creamos una nueva instancia de Persona con un campo Dirección. Luego imprimimos los distintos valores de campo de las estructuras Persona y Dirección usando la notación de puntos para acceder a los campos anidados.