Go by Example: Structs

Las estructuras (structs) de Go son colecciones tipadas de campos. Son útiles para agrupar datos juntos y formar registros.
	`package main`
	`import "fmt"`
Este tipo de estructura `person` tiene campos `name` y `age`.	`type person struct { name string age int }`
`newPerson` construye una nueva estructura person con el nombre dado.	`func newPerson(name string) *person {`
Puedes devolver de forma segura un puntero a una variable local ya que una variable local sobrevivirá al ámbito de la función.	`p := person{name: name} p.age = 42 return &p }`
	`func main() {`
Esta sintaxis crea una nueva estructura.	`fmt.Println(person{"Bob", 20})`
Puedes nombrar los campos al inicializar una estructura.	`fmt.Println(person{name: "Alice", age: 30})`
Los campos omitidos tendrán un valor cero.	`fmt.Println(person{name: "Fred"})`
Un prefijo `&` produce un puntero a la estructura.	`fmt.Println(&person{name: "Ann", age: 40})`
Es idiomático encapsular la creación de nuevas estructuras en funciones constructoras	`fmt.Println(newPerson("Jon"))`
Accede a los campos de la estructura con un punto.	`s := person{name: "Sean", age: 50} fmt.Println(s.name)`
También puedes usar puntos con punteros de estructuras - los punteros se desreferencian automáticamente.	`sp := &s fmt.Println(sp.age)`
Las estructuras son mutables.	`sp.age = 51 fmt.Println(sp.age)`
Si un tipo de estructura solo se usa para un valor único, no tenemos que darle un nombre. El valor puede tener un tipo de estructura anónima. Esta técnica se utiliza comúnmente para pruebas basadas en tablas.	`dog := struct { name string isGood bool }{ "Rex", true, } fmt.Println(dog) }`

$ go run structs.go
{Bob 20}
{Alice 30}
{Fred 0}
&{Ann 40}
&{Jon 42}
Sean
50
51
{Rex true}

Siguiente ejemplo: Methods.