Defining and using a struct

A struct groups named fields into a single type. It is Go's way of building "objects" — more literal and immediate than classes, with no inheritance and no built-in constructors.

Declaration

type Person struct {
    Name string
    Age  int
}

type introduces a new named type. Fields are written one per line, name type. Consecutive fields of the same type can share the declaration: X, Y int.

Creation

// with named fields (recommended: robust to reordering)
p := Person{Name: "Ada", Age: 36}

// positional (fragile: depends on declaration order)
q := Person{"Ada", 36}

// zero value: every field at its zero value
var r Person          // r = {Name: "", Age: 0}

// pointer: allocate with & or new
ptr := &Person{Name: "Ada"}
ptr2 := new(Person)   // *Person to a zero-value struct

Field access

p := Person{Name: "Ada", Age: 36}
fmt.Println(p.Name, p.Age)

p.Age = 37            // mutation (if p is a variable)

On a pointer, ptr.Name works directly: Go performs the implicit dereference. No -> like in C.

Visibility: the uppercase rule

Fields with an uppercase initial are exported (visible from other packages); lowercase = private to the current package.

type User struct {
    Name   string  // exported
    salt   []byte  // private to the package
}

The same rule applies to every identifier in Go: types, functions, variables, fields.

Anonymous and nested structs

// anonymous (handy for ad-hoc data)
config := struct {
    Host string
    Port int
}{Host: "localhost", Port: 8080}

// nested
type Address struct {
    Street string
    City   string
}
type Customer struct {
    Name    string
    Address Address
}

Comparability

Two structs are comparable with == if ALL their fields are comparable (no slices/maps/funcs inside):

a := Person{Name: "Ada", Age: 36}
b := Person{Name: "Ada", Age: 36}
fmt.Println(a == b)   // true

This also lets you use them as map keys.

Try it

// in package other
type X struct {
    name string
}

Recap

• type Name struct { ... }: new named type with named fields.
• Construction: T{Field: value, ...} (recommended) or positional.
• Zero value: every field at its type's zero.
• &T{...} and new(T) for a pointer; implicit dereference (p.Field on *T).
• Uppercase = exported; lowercase = private to the package.
• Structs are comparable with == if all fields are; usable as map keys.