Structs and methods, against objects and classes

A JavaScript object is a bag of keys you can add to at any time. A Go struct is a fixed set of named fields with fixed types, decided when you declare the type and never changing. Everything else in this chapter follows from that one difference.

Declaring and creating

type User struct {
    ID    int
    Name  string
    Email string
    Admin bool
}

There are four ways to make one, and you will see all four in real code.

// 1. Field names. Use this one. It survives a field being added.
u := User{ID: 1, Name: "Ada", Email: "ada@example.com"}

// 2. Positional. Fragile: adding a field breaks every call site.
u := User{1, "Ada", "ada@example.com", false}

// 3. Zero value, then assign.
var u User
u.Name = "Ada"

// 4. new(), giving a pointer to a zero value.
u := new(User)   // *User

Notice what is missing from the first example: Admin was not set, so it isfalse. There is no undefined. Every field always has a value, and a struct you create is immediately complete.

Methods: functions with a receiver

Go has no classes. You attach behaviour to a type by declaring a function with a receiver, the parameter in parentheses before the name.

func (u User) DisplayName() string {
    if u.Name == "" {
        return u.Email
    }
    return u.Name
}

fmt.Println(u.DisplayName())

u User is the receiver. It behaves like a parameter, because that is exactly what it is: u.DisplayName() is sugar for passing u as the first argument.

Value receivers and pointer receivers

This is the first thing in Go that genuinely trips people up, and it is worth getting right now rather than debugging later.

A value receiver gets a copy. Changes to it do not affect the original.

func (u User) Rename(name string) {
    u.Name = name       // modifies the copy, then throws it away
}

u := User{Name: "Ada"}
u.Rename("Grace")
fmt.Println(u.Name)     // still "Ada"

A pointer receiver gets the address, so changes stick.

func (u *User) Rename(name string) {
    u.Name = name       // modifies the original
}

u := User{Name: "Ada"}
u.Rename("Grace")
fmt.Println(u.Name)     // "Grace"

You do not write (&u).Rename(...). Go inserts the address-of automatically when the method needs a pointer and you have an addressable value.

A practical reason to prefer pointer receivers even when not mutating: a value receiver copies the whole struct on every call. For a struct with twenty fields called in a loop, that is real work for no benefit.

Composition instead of inheritance

Go has no extends. It has embedding, which looks similar and behaves differently in one important way.

type Timestamps struct {
    CreatedAt time.Time
    UpdatedAt time.Time
}

type Post struct {
    Timestamps          // embedded: no field name
    Title string
    Body  string
}

p := Post{Title: "Hello"}
p.CreatedAt = time.Now()        // promoted, as if declared on Post
fmt.Println(p.Timestamps.CreatedAt)  // the long way, same field

The embedded type's fields and methods are promoted to the outer type. IfTimestamps had a method Age(), then p.Age() would work.

Struct tags: metadata for encoders

A field can carry a string of metadata, used by libraries through reflection. You will meet this constantly, because it is how Go does JSON.

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
    Admin bool   `json:"-"`                  // never encoded
    Bio   string `json:"bio,omitempty"`      // dropped when empty
}

Without tags, json.Marshal uses the Go field names, so you get {"ID":1, "Name":"Ada"}. With them you get the lowercase JSON your frontend expects.

Constructors are just functions

Go has no constructor keyword. The convention is a package-level function named New or NewThing that returns the type.

func NewUser(name, email string) (*User, error) {
    if email == "" {
        return nil, errors.New("email is required")
    }
    return &User{
        Name:  name,
        Email: email,
    }, nil
}

Returning *User rather than User is the usual choice, because the caller almost always wants to pass it around without copying, and because it lets you return nil on failure.

Comparing structs

Structs are comparable with == when all their fields are, and the comparison is by value, field by field.

a := User{ID: 1, Name: "Ada"}
b := User{ID: 1, Name: "Ada"}
fmt.Println(a == b)     // true

That is deep equality for free, and it is a genuine surprise if you are used toa === b on objects being an identity check.

package main

import (
    "errors"
    "fmt"
    "strings"
)

type Contact struct {
    Name  string
    Email string
    Tags  []string
}

// Value receiver: reads only, so a copy is fine.
func (c Contact) Display() string {
    if len(c.Tags) == 0 {
        return c.Name
    }
    return fmt.Sprintf("%s [%s]", c.Name, strings.Join(c.Tags, ", "))
}

// Pointer receiver: it modifies, so it must be a pointer.
func (c *Contact) Tag(tag string) {
    for _, t := range c.Tags {
        if t == tag {
            return // already there, do nothing
        }
    }
    c.Tags = append(c.Tags, tag)
}

type Book struct {
    contacts []Contact
}

func (b *Book) Add(c Contact) error {
    if c.Email == "" {
        return errors.New("contact needs an email")
    }
    b.contacts = append(b.contacts, c)
    return nil
}

func (b *Book) Find(email string) (*Contact, bool) {
    for i := range b.contacts {
        if b.contacts[i].Email == email {
            return &b.contacts[i], true   // address of the real one
        }
    }
    return nil, false
}

func main() {
    var book Book
    ada := Contact{Name: "Ada", Email: "ada@example.com"}
    if err := book.Add(ada); err != nil {
        fmt.Println(err)
        return
    }

    if c, ok := book.Find("ada@example.com"); ok {
        c.Tag("maths")
        c.Tag("maths") // ignored, already present
    }

    for _, c := range book.contacts {
        fmt.Println(c.Display())  // Ada [maths]
    }
}

Assignment

Commit your work with the message Structs - Assignment One, exactly as written, so the leaderboard can score it.