Declaring Structs

A struct is one value made of several named parts. A book has a title, a page count and a stock level. Keeping those three in three separate variables means passing three things everywhere and keeping them in step by hand. A struct keeps them together as one value with one type name.

Declaring a struct type

You declare the type once, then make as many values of it as you like. Each named part is a field. A field has a name and a type. A field name that starts with a capital letter can be used from other packages; a lowercase one can only be used inside the package that declared it.

Three ways to build a value

A composite literal builds a value by listing its contents in braces. With field names, as in Book{Title: "Dune", Pages: 412}, the order does not matter and you may leave fields out. Anything left out gets its zero value. Without field names, as in Book{"Dune", 412, 2}, you must give every field, in declaration order. Declaring a variable with no literal at all, var b Book, gives a struct whose every field holds its zero value: 0 for numbers, "" for strings, false for booleans.

Reading and writing fields

A dot reaches a field. b.Title reads it and b.Title = "Go" writes it.

What trips people up

The form without field names is tied to field order. Add a field, or swap two of the same type, and old literals either stop compiling or quietly put values in the wrong fields. Use field names everywhere except very small types such as a two-number point.

package main

import "fmt"

// Book is a struct type: one name for a group of related values.
type Book struct {
	Title string
	Pages int
	Stock int
}

func main() {
	// Field names given, so the order does not matter.
	a := Book{Title: "Go in Practice", Pages: 320, Stock: 4}

	// No field names: every field must be listed, in declaration order.
	b := Book{"Dune", 412, 2}

	// No literal at all: each field holds its type's zero value.
	var c Book

	fmt.Println(a.Title, a.Pages, a.Stock)
	fmt.Println(b.Title, b.Pages, b.Stock)

	// %q puts quotes round a string, so an empty one is visible.
	fmt.Printf("%q %d %d\n", c.Title, c.Pages, c.Stock)
}

// Output:
// Go in Practice 320 4
// Dune 412 2
// "" 0 0

package main

import "fmt"

type Address struct {
	City string
	Code string
}

type Customer struct {
	Name string
	Home Address
}

func main() {
	c := Customer{
		Name: "Ada",
		Home: Address{City: "Leeds", Code: "LS1"},
	}

	// One dot per level: c, then Home, then City.
	fmt.Println(c.Name, c.Home.City)

	c.Home.Code = "LS2"
	fmt.Println(c.Home.Code)
}

// Output:
// Ada Leeds
// LS2

package main

import "fmt"

type Item struct {
	Name string
	Cost int
}

func main() {
	// Longhand: each element names its type.
	long := []Item{Item{Name: "pen", Cost: 2}, Item{Name: "pad", Cost: 5}}

	// Shorthand: inside a []Item literal the element type is already known,
	// so Item can be dropped. These two slices are identical.
	short := []Item{
		{Name: "pen", Cost: 2},
		{Name: "pad", Cost: 5},
	}

	total := 0
	for _, it := range short {
		total += it.Cost
	}
	fmt.Println(len(long), len(short), total)
}

// Output:
// 2 2 7

package main

import "fmt"

func main() {
	// A struct type written in place, with no name of its own.
	page := struct {
		Title string
		Views int
	}{Title: "Home", Views: 12}

	fmt.Println(page.Title, page.Views)
}

// Output:
// Home 12