Introducción
La estructura (struct) es un tipo compuesto que se puede utilizar para almacenar diferentes tipos de datos. Se puede emplear para implementar estructuras de datos más complejas. Por ejemplo, los artículos de una tienda de conveniencia tienen atributos como el nombre del producto, la categoría y el precio. Podemos utilizar una estructura para representarlos.
En este laboratorio (LabEx), aprenderemos sobre la definición y el uso de estructuras.
Puntos de conocimiento:
- Definición de una estructura
- Métodos de una instancia de estructura
Definición de Estructura
Podemos utilizar las palabras clave type y struct para definir una estructura. La sintaxis es la siguiente:
type StructName struct {
FieldName Type
//...
}
Donde:
- Type representa el tipo específico del nombre del campo, que puede ser un entero, una cadena de caracteres, etc.
- StructName debe ser único dentro del mismo paquete.
- Los nombres de campo deben ser únicos dentro de la misma estructura.
Probemos. Definamos una tienda de conveniencia:
type Store struct {
ProductType string // product type
ProductName string // product name
Price int // product price
}
En el código anterior, definimos una estructura llamada Store para la tienda de conveniencia, que incluye el tipo, el nombre y el precio del producto.
Dado que los campos de tipo de producto y nombre de producto son del mismo tipo, podemos simplificar el código de la siguiente manera:
type Store struct {
ProductName, ProductType string
Price int
}
Instanciación usando var
En la sección anterior, definimos una estructura de tienda de conveniencia Store, que describe el espacio de memoria. Solo se le asignará memoria y se utilizarán los campos de la estructura después de la instanciación.
Podemos utilizar la palabra clave var para instanciar una estructura:
var InstanceName Structure
Veamos un ejemplo de instanciación. Crea un archivo llamado struct.go y escribe el siguiente código:
cd ~/project
touch struct.go
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
// Instantiate a structure using `var`
var store1 Store
// Assign values to the fields related to the instance store1
store1.productType = "Drinks"
store1.productName = "Coca-Cola"
store1.price = 3
fmt.Printf("store1:\n\t%s\n\t%s\n\t%d\n",
store1.productType, store1.productName, store1.price)
}
Ejecuta el programa:
go run struct.go
Después de ejecutarlo, se muestra el siguiente resultado:
store1:
Drinks
Coca-Cola
3
En este programa, instanciamos una tienda de conveniencia usando var y luego asignamos valores a sus campos usando el operador ..
Valor inicial de una estructura
¿Cuál será el valor de una estructura instanciada si solo la inicializamos sin asignar un valor? Veamos el siguiente código:
package main
import "fmt"
type Store struct {
ProductName string
ProductType string
Price int
}
func main() {
// Instantiate a structure using `var`
var lan1 Store
// Print the structure value using %#v
fmt.Printf("lan1: %#v\n", lan1)
}
Ejecuta el programa:
go run struct.go
El resultado es el siguiente:
lan1: main.Store{ProductName:"", ProductType:"", Price:0}
Podemos ver que cuando no se especifica un valor inicial, el valor de la estructura instanciada es el valor cero del tipo correspondiente. Por ejemplo, la cadena de caracteres está vacía y el entero es 0.
Instanciación usando new
Además de utilizar la palabra clave var para la instanciación, también podemos usar la palabra clave new:
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
store := new(Store)
// Use %T to output the type
fmt.Printf("Type of store: %T\n", store)
store.productType = "Daily Necessities"
store.productName = "Umbrella"
store.price = 20
fmt.Printf("store:\n\t%s\n\t%s\n\t%d\n",
store.productType, store.productName, store.price)
}
Ejecuta el programa:
go run struct.go
El resultado es el siguiente:
Type of store: *main.Store
store:
Daily Necessities
Umbrella
20
Cuando se utiliza la palabra clave new para la instanciación, la "instancia" que crea es en realidad un puntero a la instancia. La operación de asignar un valor al puntero de la estructura es la misma que asignar un valor a una estructura normal.
Instanciación usando :=
De manera similar, podemos utilizar := para instanciar una estructura:
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
lan3 := Store{}
lan3.productType = "Fresh Food"
lan3.productName = "Taiwanese Meatballs"
lan3.price = 20
fmt.Printf("lan3:\n\t%s\n\t%s\n\t%d\n",
lan3.productType, lan3.productName, lan3.price)
}
Ejecuta el programa:
go run struct.go
El resultado es el siguiente:
lan3:
Fresh Food
Taiwanese Meatballs
20
Podemos escribir la inicialización y la asignación juntas, así:
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
lan3 := Store{
productType: "Fresh Food",
productName: "Taiwanese Meatballs",
price: 4,
}
fmt.Printf("lan3:\n\t%s\n\t%s\n\t%d\n",
lan3.productType, lan3.productName, lan3.price)
}
Ejecuta el programa:
go run struct.go
El resultado es el siguiente:
lan3:
Fresh Food
Taiwanese Meatballs
4
Cuando necesitamos asignar valores a todos los campos de una estructura, podemos escribir los valores en el orden en que se definen en la estructura.
Por ejemplo, reescribimos la instancia lan3 de la siguiente manera:
lan3 := Store{
"Fresh Food",
"Taiwanese Meatballs",
4,
}
Nota: Esta sintaxis solo es adecuada para casos en los que se asignan valores a todos los campos.
Resumen
En este laboratorio (lab), presentamos las estructuras y resumimos los siguientes puntos de conocimiento:
- Las estructuras son tipos de datos compuestos que pueden contener múltiples tipos de datos diferentes.
- El valor de una estructura no inicializada es el valor cero del tipo correspondiente.
- Tres métodos para instanciar una estructura.
