Types and Data

ages := map[string]int{"alice": 31, "bob": 27}
ages["carol"] = 40

if age, ok := ages["dave"]; !ok {
	fmt.Println("no dave", age) // age is 0
}

delete(ages, "bob")
for name, age := range ages {
	fmt.Println(name, age)
}

counts := make(map[string]int)
counts["go"]++ // missing keys start at zero, so counting just works

A nil map can be read from but panics on write, so create maps with a literal or with make.

Structs and methods

A struct groups named fields. Go has no classes; instead you attach methods to types. A method is simply a function with a receiver. Use a pointer receiver (*T) when the method mutates the value or the struct is large, and a value receiver for small read-only types. Within a single type, try to stick to one kind of receiver.

type Point struct {
	X, Y float64
}

func (p Point) Dist() float64 { // value receiver: works on a copy
	return math.Hypot(p.X, p.Y)
}

func (p *Point) Scale(k float64) { // pointer receiver: mutates the original
	p.X *= k
	p.Y *= k
}

type Named struct {
	Point        // embedded: Point's fields and methods are promoted
	Name  string
}

func main() {
	p := Point{X: 3, Y: 4}
	p.Scale(2) // Go takes &p for you
	n := Named{Point: p, Name: "A"}
	fmt.Println(p.Dist(), n.X, n.Dist())
}

Instead of inheritance, Go offers embedding: placing one type inside another promotes its fields and methods.

Interfaces

An interface is a set of method signatures. There is no implements keyword: any type that has the right methods satisfies the interface automatically. As a result, interfaces tend to be small and defined by the code that uses them.

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func describe(v any) string {
	switch x := v.(type) { // type switch
	case Shape:
		return fmt.Sprintf("area %.2f", x.Area())
	case string:
		return "a string: " + x
	default:
		return "unknown"
	}
}

func main() {
	shapes := []Shape{Rect{2, 3}, Circle{1}}
	for _, s := range shapes {
		fmt.Println(describe(s))
	}
}

any is an alias for the empty interface interface{} and can hold a value of any type. To get the concrete value back out, use a type assertion v.(T) or a type switch. Go also supports generics through type parameters, so an algorithm that works over many types can be written once, for example func Max[T cmp.Ordered](a, b T) T.

Pointers

A pointer holds the address of a value: &x takes the address, and *p reads or writes through it. There is no pointer arithmetic, and memory is garbage collected, so returning the address of a local variable is perfectly safe.

func newCounter() *int {
	c := 0
	return &c // safe: c escapes to the heap
}

func main() {
	p := newCounter()
	*p++
	fmt.Println(*p) // 1

	pt := &Point{1, 2}
	pt.X = 10 // no need to write (*pt).X
}

Go always passes arguments by value. Reach for a pointer when a function must modify its argument or when copying a large struct would be wasteful. Slices and maps already contain references internally, so copying one still points at the same underlying data.

Summary

• Conversions are always explicit; strings are UTF-8 bytes and range yields runes.
• Slices are views onto arrays; always reassign the result of append.
• Check map membership with v, ok := m[k].
• Attach methods to structs and compose with embedding instead of inheriting.
• Interfaces are satisfied implicitly, and pointers let functions share and mutate data.