Estructuras en Golang

Una estructura o estructura en Golang es un tipo definido por el usuario que permite agrupar/combinar elementos de tipos posiblemente diferentes en un solo tipo. Cualquier entidad del mundo real que tenga algún conjunto de propiedades/campos se puede representar como una estructura. Este concepto generalmente se compara con las clases en la programación orientada a objetos. Se puede denominar como una clase ligera que no admite la herencia pero sí la composición.

Por ejemplo, una dirección tiene un nombre, calle, ciudad, estado, código PIN. Tiene sentido agrupar estas tres propiedades en una sola dirección de estructura como se muestra a continuación.

Declarando una estructura:

 type Address struct {
      name string 
      street string
      city string
      state string
      Pincode int
}

En lo anterior, la palabra clave type introduce un nuevo tipo. Le sigue el nombre del tipo ( Dirección ) y la palabra clave struct para ilustrar que estamos definiendo una estructura. La estructura contiene una lista de varios campos dentro de las llaves. Cada campo tiene un nombre y un tipo.

Nota: También podemos hacerlos compactos combinando varios campos del mismo tipo como se muestra en el siguiente ejemplo:

type Address struct {
    name, street, city, state string
    Pincode int
}

Para definir una estructura: La sintaxis para declarar una estructura:

var a Address

El código anterior crea una variable de tipo Dirección que, de forma predeterminada, se establece en cero. Para una estructura, cero significa que todos los campos se establecen en su valor cero correspondiente. Entonces, los campos nombre, calle, ciudad, estado se establecen en «», y el código PIN se establece en 0.

También puede inicializar una variable de un tipo de estructura usando un literal de estructura como se muestra a continuación:

var a = Address{"Akshay", "PremNagar", "Dehradun", "Uttarakhand", 252636}

Nota:

• Pase siempre los valores de campo en el mismo orden en que se declaran en la estructura. Además, no puede inicializar solo un subconjunto de campos con la sintaxis anterior.
• Go también admite el nombre: sintaxis de valor para inicializar una estructura (el orden de los campos es irrelevante cuando se usa esta sintaxis). Y esto le permite inicializar solo un subconjunto de campos. Todos los campos no inicializados se establecen en su correspondiente valor cero.

  Ejemplo:

  var a = Dirección{Nombre:”Akshay”, calle:”PremNagar”, estado:”Uttarakhand”, Código PIN:252636} //ciudad:””

// Golang program to show how to
// declare and define the struct
  
package main
  
import "fmt"
  
// Defining a struct type
type Address struct {
    Name    string
    city    string
    Pincode int
}
  
func main() {
  
    // Declaring a variable of a `struct` type
    // All the struct fields are initialized 
    // with their zero value
    var a Address 
    fmt.Println(a)
  
    // Declaring and initializing a
    // struct using a struct literal
    a1 := Address{"Akshay", "Dehradun", 3623572}
  
    fmt.Println("Address1: ", a1)
  
    // Naming fields while 
    // initializing a struct
    a2 := Address{Name: "Anikaa", city: "Ballia",
                                 Pincode: 277001}
  
    fmt.Println("Address2: ", a2)
  
    // Uninitialized fields are set to
    // their corresponding zero-value
    a3 := Address{Name: "Delhi"}
    fmt.Println("Address3: ", a3)
}

Producción:

{  0}
Address1:  {Akshay Dehradun 3623572}
Address2:  {Anikaa Ballia 277001}
Address3:  {Delhi  0}

¿Cómo acceder a los campos de una estructura?

Para acceder a campos individuales de una estructura , debe usar el operador de punto (.) .

Ejemplo:

// Golang program to show how to
// access the fields of struct
package main
  
import "fmt"
  
// defining the struct
type Car struct {
    Name, Model, Color string
    WeightInKg         float64
}
  
// Main Function
func main() {
    c := Car{Name: "Ferrari", Model: "GTC4",
            Color: "Red", WeightInKg: 1920}
  
    // Accessing struct fields
    // using the dot operator
    fmt.Println("Car Name: ", c.Name)
    fmt.Println("Car Color: ", c.Color)
  
    // Assigning a new value
    // to a struct field
    c.Color = "Black"
      
    // Displaying the result
    fmt.Println("Car: ", c)
}

Producción:

Car Name:  Ferrari
Car Color:  Red
Car:  {Ferrari GTC4 Black 1920}

Punteros a una estructura

Los punteros en el lenguaje de programación Go o Golang es una variable que se utiliza para almacenar la dirección de memoria de otra variable. También puede crear un puntero a una estructura como se muestra en el siguiente ejemplo:

// Golang program to illustrate
// the pointer to struct
package main
  
import "fmt"
  
// defining a structure
type Employee struct {
    firstName, lastName string
    age, salary int
}
  
func main() {
  
    // passing the address of struct variable
    // emp8 is a pointer to the Employee struct
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}
  
    // (*emp8).firstName is the syntax to access
    // the firstName field of the emp8 struct
    fmt.Println("First Name:", (*emp8).firstName)
    fmt.Println("Age:", (*emp8).age)
}

Producción:

First Name: Sam
Age: 55

Golang nos da la opción de usar emp8.firstName en lugar de la desreferencia explícita (*emp8).firstName para acceder al campo firstName . Ejemplo para mostrar esto es el siguiente:

// Golang program to illustrate
// the pointer to struct
package main
  
import "fmt"
  
// Defining a structure
type Employee struct {
    firstName, lastName string
    age, salary         int
}
  
// Main Function
func main() {
  
    // taking pointer to struct
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}
  
    // emp8.firstName is used to access
    // the field firstName
    fmt.Println("First Name: ", emp8.firstName)
    fmt.Println("Age: ", emp8.age)
}

Producción:

First Name:  Sam
Age:  55