Basics

Keywords

The 25 reserved words that make up Go's grammar — declarations, control flow, types, and concurrency primitives. Unchanged since Go 1.0 and still the full set through Go 1.26.

break

Terminates the innermost for, switch, or select statement.

case

Introduces a clause in a switch or select statement.

chan

Declares a channel type used for goroutine communication.

const

Declares a constant value, fixed at compile time.

continue

Skips to the next iteration of the innermost for loop.

default

Specifies the default clause in a switch or select statement.

defer

Schedules a function call to run after the surrounding function returns.

else

Introduces the alternative branch of an if statement.

fallthrough

Transfers control to the next case clause in a switch statement.

for

Introduces a loop; Go's only looping construct.

func

Declares a function, method, or function literal.

Starts a new goroutine running a function call.

goto

Transfers control to a labeled statement in the same function.

Introduces a conditional statement.

import

Declares packages whose exported identifiers may be used in the file.

interface

Declares an interface type, a set of method signatures.

map

Declares a map type, an unordered collection of key-value pairs.

package

Declares the package to which the current source file belongs.

range

Iterates over elements of an array, slice, string, map, channel, or integer.

return

Terminates a function and optionally returns values to the caller.

select

Waits on multiple channel communication operations.

struct

Declares a struct type, a sequence of named fields.

switch

Introduces a multi-way conditional statement.

type

Declares a new named type or type alias.

var

Declares one or more variables.

Examples

var, const, type, func, import, and package are the vocabulary of top-level and local declarations. Only package and import are file-scoped; the rest can appear almost anywhere.

package main

import "fmt"

const MaxRetries = 3

type Job struct {
    ID    int
    Tries int
}

func retry(j Job) bool {
    var ok bool = j.Tries < MaxRetries
    return ok
}

fmt.Println(retry(Job{ID: 1, Tries: 2}))

Output

true

switch in Go doesn't fall through by default — each case breaks automatically. fallthrough opts back in to the C-style behavior.

grade := 82

if grade >= 90 {
    fmt.Println("A")
} else if grade >= 80 {
    fmt.Println("B")
} else {
    fmt.Println("C or lower")
}

switch {
case grade >= 90:
    fmt.Println("excellent")
case grade >= 70:
    fmt.Println("passing")
    fallthrough
default:
    fmt.Println("recorded")
}

Output

B
passing
recorded

for is Go's only loop keyword — it covers counted loops, while-style loops, and range iteration. break and continue target the innermost loop unless given a label.

sum := 0
for i := 0; i < 10; i++ {
    if i%2 != 0 {
        continue
    }
    if i > 6 {
        break
    }
    sum += i
}
fmt.Println(sum)

fruits := []string{"fig", "kiwi", "plum"}
for i, f := range fruits {
    fmt.Println(i, f)
}

Output

12
0 fig
1 kiwi
2 plum

goto jumps to a labeled statement in the same function. It can't jump into a block or over a variable declaration — the compiler rejects both.

i := 0
loop:
if i < 3 {
    fmt.Println("i =", i)
    i++
    goto loop
}
fmt.Println("done")

Output

i = 0
i = 1
i = 2
done

These four keywords declare Go's composite and reference-like types: fixed-shape records, method-set contracts, key-value collections, and typed communication pipes.

type Shape interface {
    Area() float64
}

type Rect struct {
    W, H float64
}

func (r Rect) Area() float64 { return r.W * r.H }

shapes := map[string]Shape{
    "a": Rect{W: 3, H: 4},
}
fmt.Println(shapes["a"].Area())

results := make(chan float64, 1)
results <- shapes["a"].Area()
fmt.Println(<-results)

Output

12
12

go launches a goroutine; select waits on whichever of several channel operations is ready first, the concurrency counterpart to switch.

ch1 := make(chan string)
ch2 := make(chan string)

go func() { ch1 <- "from ch1" }()
go func() { ch2 <- "from ch2" }()

for i := 0; i < 2; i++ {
    select {
    case msg := <-ch1:
        fmt.Println(msg)
    case msg := <-ch2:
        fmt.Println(msg)
    }
}

Output

from ch1
from ch2

defer runs LIFO, after return has set the result but before the function actually hands control back — which is why a deferred func can still modify a named return value.

func process() (n int) {
    defer func() { n *= 10 }()
    defer fmt.Println("cleanup")
    n = 4
    return n
}

fmt.Println(process())

Output

cleanup
40

In practice

range combined with continue skips completed tasks without an extra if/else branch. The named zero Task return relies on var producing the type's zero value when nothing is found.

type Task struct {
    Name string
    Done bool
}

func nextPending(tasks []Task) (Task, bool) {
    for _, t := range tasks {
        if t.Done {
            continue
        }
        return t, true
    }
    var zero Task
    return zero, false
}

A switch with an init statement scopes t and ok to the switch itself, the same pattern used for if with an init clause.

tasks := []Task{
    {Name: "design", Done: true},
    {Name: "build", Done: false},
    {Name: "ship", Done: false},
}

switch t, ok := nextPending(tasks); {
case !ok:
    fmt.Println("nothing pending")
default:
    fmt.Println("next up:", t.Name)
}

Terminal

$ go run main.go
next up: build

Previous Built-in Functions Next Topic Set up Environment