Structs & Methods

Go’s answer to classes

TypeScript has class, interface, and plain objects. Go has structs — plain data types — and methods — functions attached to a type. There are no classes, no inheritance, no this keyword (Go uses a named receiver instead).

Defining structs

// TypeScript interface + object
interface User {
    name: string;
    age:  number;
}

const u: User = { name: "Alice", age: 30 };
console.log(u.name);

// Go struct
type User struct {
    Name string
    Age  int
}

u := User{Name: "Alice", Age: 30}
fmt.Println(u.Name)

Methods on structs

In TypeScript, methods live inside a class. In Go, you attach a method to any type by specifying a receiver before the function name.

class User {
    constructor(
        public name: string,
        public age: number,
    ) {}

    greet(): string {
        return `Hi, I'm ${this.name}`;
    }
}

type User struct {
    Name string
    Age  int
}

// Method with value receiver
func (u User) Greet() string {
    return "Hi, I'm " + u.Name
}

Try it

Open in Playground

package main

import "fmt"

type Rectangle struct {
  Width  float64
  Height float64
}

func (r Rectangle) Area() float64 {
  return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
  return 2 * (r.Width + r.Height)
}

// Pointer receiver — can mutate the struct
func (r *Rectangle) Scale(factor float64) {
  r.Width *= factor
  r.Height *= factor
}

func main() {
  rect := Rectangle{Width: 4, Height: 3}
  fmt.Printf("Area: %.1f\n", rect.Area())
  fmt.Printf("Perimeter: %.1f\n", rect.Perimeter())

  rect.Scale(2)
  fmt.Printf("After scaling: %.1f x %.1f\n", rect.Width, rect.Height)
}

🟦 Value Receivers vs Pointer Receivers

A value receiver (func (u User) Greet()) receives a copy of the struct. The method cannot mutate the original.

A pointer receiver (func (u *User) SetName(name string)) receives a pointer to the struct and CAN mutate it.

// Value receiver — reads, does not mutate
func (u User) Greet() string {
    return "Hi, " + u.Name
}

// Pointer receiver — mutates the original
func (u *User) Birthday() {
    u.Age++
}

Rule of thumb: if any method on a type needs to mutate, use pointer receivers for ALL methods on that type for consistency.

TypeScript’s this is always a reference — Go makes the copy-vs-pointer distinction explicit in the signature.

🟦 No Inheritance — Embed Instead

Go has no class inheritance. Instead, you embed one struct inside another to compose behaviour:

type Animal struct { Name string }
func (a Animal) Speak() string { return a.Name + " speaks" }

type Dog struct {
    Animal        // embedded — Dog "inherits" Speak
    Breed string
}

d := Dog{Animal: Animal{Name: "Rex"}, Breed: "Lab"}
fmt.Println(d.Speak()) // "Rex speaks" — promoted from Animal