Author Intro

i must admit to resisting learning Go for many years. the language is different enough from both Java and C++ that i didn’t feel comfortable in it. also, it’s on the wrong side of the tabs-vs-spaces war — tabs? really?!?

i have grown to appreciate the language as a nice middle ground between Java and C. it has built-in support for important data types like maps and strings. it has the garbage collection of Java. it also has the concepts of pointers from C without the complication of pointer arithmetic. its approach to objects is much simpler than C++ and even Java. Python programmers will enjoy the duck typing that Go uses. and it’s compiled!

this is a mediocre Go book to get a Java programmer to the level of a mediocre Go programmer quickly. i hope after reading this book, you will be motivated to learn Go thoroughly with other Go books and some nice war stories of your own.

i’ve learned a lot about Go writing it – Claude is fantastic at identifying concepts that need to be mentioned as well as checking text and code for errors. the first dozen chapters should give you a good start into using Go. many programmers may find up to the Essential Standard Library chapter to be all they need to continue with Go on their own.

i hope this book will help you get a new perspective of how to approach problems the go way and add another language to tackle problems with.

may the source be with you!

How to use this booklet

This is a short booklet to help a Java programmer learn Go.

Each chapter is meant to help you understand a topic, but you will still want to reference API descriptions for more specifics of the parameters and operating conditions. Hopefully, you’ll have the context you need to understand API documentation.

Code Review Rules

Go is an opinionated language — they don’t even let us indent with spaces!!! You will find the Code Review Rules for Go in the appendix. These rules help developers understand the best practices for writing Go code. When we refer to these rules we will use the bold italics version of the [short-rule-name].

Idioms

Idioms are found in every language — spoken and programmed. Go takes idioms next level. You are going to see idiom and idiomatic a lot, so it helps to get comfortable with the word. Wikipedia defines idiom as (Wikipedia contributors 2024)

a commonly-used way to code a relatively small construct in a particular programming context

You could also think of it as best practices. I like to think of it as “if you don’t do it the idiomatic way, you risk looking like an idiot”.

Callouts

Tips call out details that you need to pay special attention to. Traps warn you of common mistakes. Wut calls out a detail that is counter-intuitive, so make sure you pay attention.

Function Signatures

When this book introduces a new function, it shows the function’s signature. In Go, a function’s signature is its parameter and result types — unlike Java, the return type is part of the signature. We show the signature together with the function’s name so you know what it is called, what goes in, and what comes out. For example:

func Abs(n int) int

This tells you that Abs takes one int parameter and returns an int. You do not need to understand every detail the first time you see it, but it gives you three things at a glance: what the function is called, what goes in, and what comes out. As you work through API documentation on your own, signatures are the first thing you will look at, so getting comfortable reading them early pays off.

Try It

As the intro to the most amazing programming language book ever written (Kernighan and Ritchie 1988) starts out:

The only way to learn a new programming language is by writing programs in it.

You need to write some code. Make sure you try writing some programs from scratch. At the end of each chapter is a starter program that you can type in and modify to play with. Don’t use it as an excuse to avoid writing some of your own starter programs. It’s the only way to master a language.

Exercises

Don’t skip the exercises at the end of the chapters. You can get the answer key, but don’t look at the answer key before you work out the answer yourself. If you look at the answer key first, the concepts will not sink in.

Hello, Go

Go drops a lot of Java ceremony — no class wrappers, no checked exceptions, no semicolons — and in exchange asks you to follow a small set of strict conventions. This chapter maps what you already know from Java to the equivalent Go concepts, gets your first program compiling, and introduces the fmt package you will reach for constantly.

Program Structure

In Java, every program lives inside a class. In Go, a program lives inside a package, and main is just a function.

package main

import "fmt"

func main() {
    fmt.Println("Buenas noches, Go!")
}

package main tells the compiler this file is an executable entry point, not a library. func main() is the entry point — no class, no static, no throws. Every .go file in a directory belongs to the same package; the directory is the package.

Import Blocks

import in Go resembles Java, but with two important differences: imports are always full paths, and every imported package must be used.

import (
    "fmt"
    "math"
    "os"
)

The grouped parenthesis form is the idiomatic style. Single imports work too (import "fmt"), but you will see the grouped form everywhere. [group-imports]

Go treats an unused import as a compile error. If you import "math" and never call anything from it, the build fails. This keeps dependency lists honest.

Sometimes you import a package purely for its side effects — a database driver that registers itself, for example. Use the blank import for this:

import _ "github.com/lib/pq"  // registers the PostgreSQL driver

The _ tells the compiler “I know I am not calling anything from this; run its init function anyway.” If you do this, remember that all blank imports should happen in the main package. [blank-import-main-only]

You can also give an imported package an alias by placing a name between import and the path:

import (
    f "fmt"       // use f.Println instead of fmt.Println
    mrand "math/rand"  // avoids collision with crypto/rand
)

This is useful when two packages share the same last path segment and would otherwise collide.

. is a special alias which dumps all exported names directly into the current file’s namespace — no qualifier needed, like import com.example.pq.*; in Java. [no-dot-import] Avoid it in non-test code: it makes it impossible to tell at a glance which package a name comes from. Tests sometimes use it to avoid circular dependencies.

Modules

In Java, you can compile a single file with javac Hello.java and run it with java Hello before Maven or Gradle ever enters the picture. Go does not work that way. Every Go project — even a single-file hello world — lives inside a module. A module is a directory tree with a go.mod file at its root that tells the toolchain what your project is named and which external packages it needs. Without a go.mod, go build refuses to run, and even go run behaves inconsistently when you start splitting code across files.

Your First Project

The complete setup for a hello-world program looks like this:

$ mkdir hello
$ cd hello
$ go mod init github.com/yourname/hello

Then create main.go with the program from the previous section. Your directory now contains two files:

hello/
├── go.mod
└── main.go

That is the entire project structure. No src/, no com/yourname/hello/, no build descriptor beyond go.mod.

Choosing a module path

The module path is the string you pass to go mod init. It serves two purposes: it uniquely identifies your module, and it becomes the import prefix for every package inside it. If your module path is github.com/yourname/hello and you later add a songs/ subdirectory, other files import it as "github.com/yourname/hello/songs".

The rules:

• Published modules use the repository URL as the path, such as github.com/you/hello or gitlab.com/org/toolkit. This is what go get fetches when someone installs your module.
• Private or internal modules can use any domain your organization controls, like corp.example.com/auth. Nothing enforces the domain, but using one you own prevents collisions with public modules.
• Local experiments can use any short, unique string. example.com/hello is the conventional placeholder Go documentation uses. You can also use hello on its own — the toolchain does not require a domain.

For this book’s examples, example.com/hello (or a shortened name like hello) is used for standalone programs that are not meant to be published.

Why Modules Exist

Before modules existed, Go used a single workspace called GOPATH where all code from all projects — yours and every third-party library — lived in one directory tree. Pinning one project to version 1.2 of a library while another needed version 2.0 was painful, and reproducible builds were hard. Modules fixed this: each project declares its own dependencies and the exact versions it needs, so two projects on the same machine can use different versions of the same library without conflict.

go mod init creates go.mod containing:

module github.com/yourname/hello

go 1.26

Managing Dependencies

go.sum appears beside go.mod once you add external dependencies. It records the cryptographic checksums of every module version you depend on — never edit it by hand.

To add a dependency:

go get github.com/some/library@v1.2.3

For example, a project that uses the Gin HTTP framework, the Zap structured logger, and Testify for test assertions would run:

go get github.com/gin-gonic/gin@v1.10.0
go get go.uber.org/zap@v1.27.0
go get github.com/stretchr/testify@v1.10.0

After those commands, go.mod looks like this:

module github.com/yourname/hello

go 1.26

require (
    github.com/gin-gonic/gin v1.10.0
    github.com/stretchr/testify v1.10.0
    go.uber.org/zap v1.27.0
)

Each require entry pins the module path and exact version. Indirect dependencies (packages that your dependencies depend on) are added automatically and marked with // indirect.

To remove unused dependencies and pin the ones you do use:

go mod tidy

go mod tidy is the Go equivalent of cleaning up your pom.xml. Run it before every commit.

Building and Running

With go.mod in place, you have three commands to choose from:

go run is your read-eval-print loop (REPL) replacement for quick experiments. Use go build or go install for anything you want to distribute or benchmark. go install drops the binary in $GOPATH/bin, which defaults to ~/go/bin — add that directory to your $PATH so the installed tools are runnable from anywhere.

Unlike Java, which compiles to .class files that need a JVM and a classpath to run, go build produces a single statically-linked native binary you can copy to another machine and run directly — no runtime VM required.

Running the hello program from the hello/ directory:

$ go run main.go
Buenas noches, Go!

Exported vs Unexported Identifiers

Go uses capitalization to control visibility. There is no public, private, or protected.

An exported identifier starts with an uppercase letter. Anything else is unexported. There is no protected in Go: unexported means the package boundary, full stop. Subpackages (e.g. mypkg/internal) are separate packages and cannot access each other’s unexported names.

The fmt Package

fmt is Go’s formatted I/O package. You will use it constantly.

fmt.Println

func Println(a ...any) (n int, err error)

Writes its arguments to standard output separated by spaces, followed by a newline. Same idea as System.out.println, minus the class hierarchy.

fmt.Println("Sandstorm Remix")          // Sandstorm Remix
fmt.Println("hits:", 42, "platinum")    // hits: 42 platinum

fmt.Printf

func Printf(format string, a ...any) (n int, err error)

Formatted output, same concept as C’s printf. Java also has printf — System.out.printf("Hello %s\n", name) — with similar format verbs.

fmt.Printf("%s has %d platinum single\n", "Darude", 1)

There are variants of fmt.Printf that format strings and write to files.

fmt.Sprintf

func Sprintf(format string, a ...any) string

Same as Printf but returns the formatted string instead of printing it. This is your String.format() equivalent.

msg := fmt.Sprintf("Track %d: %s", 1, "Sandstorm")
fmt.Println(msg)  // Track 1: Sandstorm

fmt.Fprintf

func Fprintf(w io.Writer, format string, a ...any) (n int, err error)

Writes to any io.Writer — a file, a network connection, a buffer, anything. fmt.Printf is just fmt.Fprintf(os.Stdout, ...).

fmt.Fprintf(os.Stderr, "error: %v\n", err)

Print, Fprint, Fprintln, and Sprint round out the family:

func Print(a ...any) (n int, err error)                  // no \n; spaces between non-strings
func Fprintln(w io.Writer, a ...any) (n int, err error)  // Println to any io.Writer

Reading Input

Printing is only half the story. In Java you reach for Scanner sc = new Scanner(System.in) when you need interactive input. Go’s fmt package has a family of scan functions that mirror the print family.

func Scan(a ...any) (n int, err error)                     // whitespace-delimited
func Scanf(format string, a ...any) (n int, err error)     // format-directed
func Scanln(a ...any) (n int, err error)                   // stops at newline

n is the number of items successfully scanned; err is non-nil if scanning stopped early. All three write into their arguments, so every argument must be a pointer:

var artist string
var plays int
fmt.Print("enter artist and play count: ")
fmt.Scanf("%s %d", &artist, &plays)
fmt.Printf("%s has %d plays\n", artist, plays)

Running the program and typing Miley 1400000000 produces:

enter artist and play count: Miley 1400000000
Miley has 1400000000 plays

fmt.Scan (no format) is the simpler choice when the values are separated by any whitespace and you do not care about the exact layout:

fmt.Scan(&artist, &plays)  // reads two whitespace-separated tokens

Format Verbs

x := 42
fmt.Printf("%v %T\n", x, x)  // 42 int
fmt.Printf("%q\n", "The Sound of Silence") // "The Sound of Silence"
fmt.Printf("%.2f\n", 3.14159) // 3.14

Command-Line Arguments

You may have noticed that main doesn’t have the usual main(String[] args) signature from Java, so how do we get the command-line arguments? The os package exposes the program’s command-line arguments as a slice of strings:

var Args []string // Args[0] is the program name; Args[1:] are the arguments

A complete program that greets whoever is named on the command line:

package main

import (
    "fmt"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("usage: greet <name>")
        return
    }
    fmt.Printf("hola, %s!\n", os.Args[1])
}

Run it:

$ go run main.go mundo
hola, mundo!

os.Args[0] is always the name of the compiled binary (or a temporary path when using go run). Arguments start at index 1.

Try It

Type this one in and run it a few ways — first with no arguments, then with a name after go run main.go. It exercises the chapter’s greatest hits: package main, the fmt print family, format verbs, and os.Args.

package main

import (
    "fmt"
    "os"
)

func main() {
    artist := "Hozier"
    track := "Too Sweet"
    plays := 850_000_000

    // Sprintf builds a string; Println prints it.
    line := fmt.Sprintf("%q by %s", track, artist)
    fmt.Println(line)

    // Printf with verbs: %s string, %d integer, %T type.
    fmt.Printf("plays: %d (type %T)\n", plays, plays)

    // os.Args carries the command line; index 0 is the binary.
    if len(os.Args) > 1 {
        fmt.Printf("hola, %s!\n", os.Args[1])
    } else {
        fmt.Println("hola, mundo!")
    }
}

Run with no arguments and it prints hola, mundo!; run go run main.go oyente and the last line becomes hola, oyente!.

Try these tweaks:

• Swap %q for %v in the Sprintf call and notice the quotes disappear.
• Add a third command-line argument and print os.Args[2] — then run it with too few arguments and watch it panic.
• Replace fmt.Println(line) with fmt.Fprintln(os.Stderr, line) and observe that the line still appears on the terminal but now goes to standard error.

Key Points

• A Go program needs package main and func main() — no class wrapper required.
• Every import must be used; unused imports are compile errors.
• Use _ as the import name to import a package for side effects only.
• go run compiles and runs; go build produces a binary; go install installs it.
• go mod init creates go.mod; go mod tidy keeps it clean.
• Visibility is controlled entirely by capitalization: uppercase = exported, lowercase = unexported.
• There is no protected in Go; the visibility boundary is the package.
• fmt.Println, fmt.Printf, fmt.Sprintf, and fmt.Fprintf cover nearly all formatted output needs.
• %v is the universal format verb; %T prints the type; %q quotes a string.
• os.Args is a []string where index 0 is the binary name and index 1 onward are the arguments; always check len(os.Args) before indexing.
• Use the flag package (Chapter 14) for programs with named flags.

Exercises

1. Think about it: Java has four visibility levels: public, protected, package-private (no keyword), and private. Go has two: exported (uppercase) and unexported (lowercase), with the package as the only boundary. What do you gain from Go’s simpler model? What do you lose? Can you think of a Java visibility pattern that has no direct equivalent in Go?

2. What does this print?

   package main
   
   import "fmt"
   
   func main() {
       name := "Ozzy Osbourne"
       plays := 2_100_000_000
       fmt.Printf("%s has %d plays\n", name, plays)
       fmt.Printf("type of plays: %T\n", plays)
       fmt.Printf("quoted: %q\n", name)
   }

3. Calculation: You run the following program as:

   go run main.go Sandstorm Remix Darude

   package main
   
   import (
       "fmt"
       "os"
   )
   
   func main() {
       fmt.Println(len(os.Args))
       fmt.Println(os.Args[2])
   }

   What does it print?

4. Where is the bug?

   package main
   
   import (
       "fmt"
       "math"
   )
   
   func main() {
       fmt.Println("Hello, Go!")
   }

5. Write a program: Write a Go program that accepts a song title as the first command-line argument and a play count as the second, then prints them formatted as "<title>" has <count> plays. If fewer than two arguments are provided (not counting the program name), print a usage message and exit. Run it with go run.

Types and Variables

Go’s type system will feel familiar to a Java programmer but has several sharp edges: every variable has a meaningful zero value from birth, numeric types never coerce implicitly, and the capitalization of one letter can change a type from private to public. This chapter covers the basic types, how to declare variables, constants, the handful of built-in functions that round out the type system, and structs — Go’s primary mechanism for grouping data, attaching behavior, and composing types.

Basic Types

Go’s primitive types map roughly to Java’s, with a few differences worth noting.

Integer Types

int is the idiomatic integer type for general use. Its width matches the platform’s native word size — 64 bits on every modern system you will care about.

Floating-Point Types

float32 and float64 correspond to Java’s float and double. The same as Java: prefer float64 for most uses.

Boolean and String

bool and string are the same concept as Java. In Go, strings are immutable byte sequences (not character sequences — that distinction matters a lot and gets its own chapter). true and false are the only bool literals, same as Java.

byte and rune

byte is an alias for uint8. rune is an alias for int32 and represents a Unicode code point. These two types come up constantly when working with text.

var b byte = 'A'   // b == 65
var r rune = '🎵'  // r == 127925

A full treatment of strings, bytes, and runes is in Chapter 3.

var Declarations and :=

Go has two ways to declare a variable.

var

var name string
var count int = 0
var ratio float64 = 1.5

var works anywhere — inside or outside a function. When you provide an initializer, the type is optional:

var title = "Flaming June"  // type inferred as string

:= Short Declaration

Inside a function body you can use the short declaration operator:

artist := "BT"
streams := 4_200_000

The compiler infers the type from the right-hand side. := is the idiomatic choice inside functions; var is preferred for package-level variables and when you want to declare a variable without an initial value.

Multiple variables can appear on the left side, which is how Go handles functions that return more than one value:

title, artist := "Flaming June", "BT"  // two new string variables
n, err := fmt.Println("hello")         // int and error from one call

Each variable on the left gets the corresponding value from the right. You will see this form constantly when calling functions that return a result alongside an error.

When to Use Each

Use := when you have an initializer and you are inside a function — it is shorter and more readable. Use var when you want to declare a variable at its zero value, when you need a package-level variable, or when the explicit type improves clarity.

Redeclaration with :=

:= can appear on the left side with variables that already exist in the current scope, as long as at least one variable on the left is new. The following example shows how you can reuse err across a chain of calls:

n, err := fmt.Println("first")
m, err := fmt.Println("second")  // err already declared; m is new --- OK
n, err := fmt.Println("third")   // error because n and err are already declared

If every variable on the left already exists in scope, := is a compile error.

Zero Values

In Java, reading a local variable before you initialize it is a compile error. In Go, every type has a zero value that variables are initialized to automatically.

var count int       // 0
var name string     // ""
var active bool     // false

Zero values make it safe to use a variable before assigning to it. Structs are zero-valued field by field.

nil

nil is the zero value for the six reference-like type categories listed above. It is Go’s counterpart to Java’s null, but with one important difference: nil is often safe and useful rather than a source of panic. A nil slice has length zero and works correctly with len, range, and append. [nil-slice-preferred] A nil map can be read from (the result is always the zero value for the value type). These behaviors are covered in detail when slices and maps (both Chapter 7) are introduced.

Dereferencing a nil pointer, though, always panics — the Go counterpart to Java’s NullPointerException (writing to a nil map panics too — see Chapter 7):

var p *int
fmt.Println(p)  // <nil>
fmt.Println(*p) // panic: runtime error: invalid memory address or nil pointer dereference

Integer Literal Prefixes and the Digit Separator

Go supports nearly the same literal prefix syntax you may know from modern Java — plus the 0o octal prefix, which Java lacks:

bin  := 0b1010_1100   // binary, underscores allowed
oct  := 0o755         // octal; 0o prefix is clearer, but leading-zero (0755) still works
hex  := 0xDEAD_BEEF   // hexadecimal
big  := 1_000_000     // one million, easier to read

The underscore _ is a digit separator — it is ignored by the compiler and exists only for readability. You can place it anywhere inside a numeric literal, but not at the start or end.

Constants

Constants in Go are declared with const. Unlike Java, Go constants are limited to booleans, numbers (integers, floats, complex, and runes), and strings — no arrays, slices, structs, or any other composite type. They can be typed or untyped:

const Pi float64 = 3.14159   // typed constant
const E  = 2.71828           // untyped floating-point constant

Untyped constants are precise and flexible — the compiler treats them as arbitrary-precision numbers and assigns a concrete type at the point of use.

const Streams = 1_200_000_000  // untyped integer constant

var plays32 int32   = Streams  // concrete type: int32
var plays64 int64   = Streams  // same constant, now int64
var ratio   float64 = Streams  // same constant, now float64

A typed constant like Pi float64 can only be used where float64 is expected. Streams works as any numeric type that can represent its value.

iota and const blocks

Constants can also be declared in a block. For example:

const (
    Rock = 1
    Pop = 2
    HipHop = 3
    Reggaeton = 4
)

but what about this code?

const (
    Rock = 1
    Pop
    HipHop
    Reggaeton
)

You would think this would be a syntax error or the constants would be set to the same values as the previous example. It turns out that there is a third option. The Go Language spec states that if the initialization expression is missing for a constant in a const block, the expression used will be “equivalent textually to the substitution of the first preceding non-empty expression list and its type if any” (The Go Authors 2025, sec. “Constant declarations”). That means the following code will print all ones.

fmt.Printf("%v %v %v %v", Rock, Pop, HipHop, Reggaeton)

So, why the textual substitution? Why give one iota about that rule? Read on!

iota is an untyped integer constant whose value is the position of a constant specification within a const block, starting at zero.

It is Go’s idiomatic way to define enumerations.

const (
    Free     = iota  // 0
    Standard = iota  // 1
    Premium  = iota  // 2
    Lossless = iota  // 3
)

We can take advantage of the textual substitution rule to simplify the preceding example:

const (
    Free     = iota  // 0
    Standard         // 1
    Premium          // 2
    Lossless         // 3
)

The iota will be implicitly copied to Standard, Premium, and Lossless.

You can use iota in expressions to offset the starting value:

const (
    Debut     = iota + 1  // 1
    Sophomore             // 2
    Certified             // 3
)

iota resets to zero at each new const block.

Type Casts

Go has no implicit numeric widening. In Java, assigning an int to a long variable just works; in Go, every conversion between different types must use a cast. Java casts look like int i = (int) myLong, but Go uses a functional form of the cast using the T(value) syntax.

var i int     = 42
var f float64 = float64(i)   // required: int → float64
var u uint    = uint(f)      // required: float64 → uint

This applies to all numeric types — int32 to int64, float32 to float64, int to byte, and so on. The compiler rejects any assignment that silently changes the representation.

These conversions are fully type-checked at compile time, with no runtime type test involved: unlike Java’s cast, T(value) can never fail at run time (though converting a non-constant value still executes an instruction). Java overloads the word cast for two very different operations — the compile-time (int) myLong and the runtime (String) obj, where the JVM checks the actual type and may throw ClassCastException. Go splits these apart. Compile-time conversions use T(value) and are called casts or conversions; the runtime operation of checking whether an interface value holds a particular concrete type or interface is a separate construct called a type assertion (covered in the interfaces chapter), written v.(T).

When you need a cast:

• Any numeric type to any other numeric type: float64(n), int32(x), byte(r)
• string to []byte or []rune, and back: []byte(s), string(b)
• Between a named type and its underlying type (covered in Type Definitions below): float64(c)

When you do not need a cast:

• Assigning an untyped constant to any compatible type — var x float64 = 42 works because 42 is an untyped constant that fits float64
• Passing a value to an interface parameter — any type that satisfies the interface is accepted automatically, no cast required
• Between a type and its alias (covered in Type Aliases below)

Type Definitions

type Celsius float64
type Fahrenheit float64

type Celsius float64 creates a new, distinct type. Even though both Celsius and float64 have the same underlying representation, they are different types. Assignment between them requires an explicit conversion:

var c Celsius    = 100.0
var f float64    = float64(c)   // explicit conversion required
var g float64    = c            // compile error: cannot use c (Celsius) as float64

This is intentional. You cannot accidentally pass a temperature in Fahrenheit where the function expects Celsius.

Type Aliases

type Seconds = float64  // alias, not a new type

An alias introduces a new name for the same type. Seconds and float64 are interchangeable — there is no conversion needed. Aliases are most useful in large-scale refactoring or when bridging packages.

new and make

Go has two allocation built-ins. They serve different purposes.

new

new(T) allocates memory for a value of type T, initializes it to the zero value, and returns a *T. Conceptually, the memory is allocated on the heap — a region of memory that lives on even after the local scope (block of code) finishes. In reality, Go does escape analysis to see if there is a chance the allocation will be used outside of the local scope. If not, the memory will be allocated on the stack and will be deallocated once the scope — usually the function or block of code — finishes. If the reference will be used outside of the local scope — it was passed to another function or added to a collection object — the compiler will allocate the memory on the heap where it will live until there are no more references to it.

p := new(int)    // *int pointing to 0
*p = 42
fmt.Println(*p)  // 42

You will see new occasionally, but struct literals with & are more common in practice:

type Point struct{ X, Y int }
pt := &Point{X: 3, Y: 4}  // same idea; more idiomatic for structs

If you’ve worked in other languages like C or C++, you will see that as a potential for a dangling pointer.

func GenPoint() *Point {
    p := Point{X: 3, Y: 4}
    return &p
}

However, with escape analysis, Go is able to see that p needs to survive past the return of the function and allocates p on the heap.

You cannot use new to create a ready-to-use map or channel — new(map[string]int) gives you a pointer to a nil map.

make initializes slices, maps, and channels — the three built-in reference types that need internal setup before use. The details are covered alongside each type: maps and slices in Chapter 7, channels in Chapter 10.

Built-in min, max, and clear (Go 1.21)

Go 1.21 added three built-ins that Java programmers typically import from utility libraries.

min and max

min and max are type-safe and variadic — they work on any ordered type and accept any number of arguments:

smallest := min(3, 1, 4, 1, 5)   // 1
largest  := max(3, 1, 4, 1, 5)   // 5
lo       := min(a, b)            // works for float64, string, etc.

No Math.min(a, b) gymnastics.

clear

clear zeroes the elements of a slice or deletes all entries from a map:

nums := []int{1, 2, 3}
clear(nums)        // nums is now [0, 0, 0], len unchanged

scores := map[string]int{"DJ Analyzer": 99}
clear(scores)      // scores is now an empty map

For slices, clear zeroes elements but does not change the length. For maps, it removes all keys.

The Blank Identifier

The blank identifier _ discards any value you do not need.

n, _ := fmt.Println("Hola")  // keep the byte count, discard the error

Go requires you to use every declared variable, so _ is your escape hatch when a function returns multiple values and you only need some of them. You can also use it in a for range loop to discard the index or value.

Structs

A struct is a composite type that groups named fields together. In Java, you use a class; in Go, you use a struct. The critical difference is that structs are value types in Go — assigning a struct copies all its fields — whereas in Java every object variable is a reference.

Struct Definition

Define a struct type with type T struct { ... }:

type Track struct {
    Title    string
    Artist   string
    BPM      int
    Duration float64 // seconds
}

The zero value of a Track has Title = "", Artist = "", BPM = 0, and Duration = 0.0. You can use a zero-value struct immediately; there is no constructor required.

Fields can have the same type listed once, separated by commas:

type Point struct {
    X, Y float64 // two fields, both float64
}

Struct Literals

There are two forms of struct literal.

Named form (preferred):

t := Track{
    Title:    "Gouryella",
    Artist:   "Gouryella",
    BPM:      138,
    Duration: 208.0,
}

Positional form (fragile):

t := Track{"Gouryella", "Gouryella", 138, 208.0}

Anonymous structs are useful for one-off data shapes, especially in tests and temporary groupings:

entry := struct {
    Title  string
    Plays  int
}{"Out Of The Blue", 1_800_000_000}

fmt.Println(entry.Title, entry.Plays)

Struct as a Value Type

Assigning a struct creates an independent copy:

a := Track{Title: "Gamemaster", Artist: "Matt Darey & Lost Tribe", BPM: 126}
b := a           // b is a copy; a and b are independent
b.BPM = 130
fmt.Println(a.BPM) // 126 --- a is unchanged
fmt.Println(b.BPM) // 130

In Java, b = a for an object would make both variables point to the same object. In Go, you get two distinct structs.

When you want shared mutation — so that changes through one variable are visible through another — use a pointer:

pa := &Track{Title: "Gamemaster", Artist: "Matt Darey & Lost Tribe", BPM: 126}
pb := pa           // both point to the same Track
pb.BPM = 130
fmt.Println(pa.BPM) // 130 --- shared!

Pointers

Java hides pointers — every object variable is secretly a reference to heap memory, but the language never lets you see or manipulate the raw address. Go makes pointers explicit: & takes an address and * follows it. Understanding Go pointers helps you predict when a function can modify its caller’s data, and why some methods need a *T receiver rather than a plain T receiver.

& and * — Address-Of and Dereference

Two operators are all you need to work with Go pointers.

&expr   // address-of: produces a pointer to expr
*pExpr  // dereference: follows the pointer to reach the value

A pointer type names what the pointer points to, with a * prefix:

var p *int      // p is a pointer to int; its zero value is nil
var s *string   // s is a pointer to string; also nil

Here is the whole idea in one small program:

package main

import "fmt"

func main() {
    x := 42
    p := &x          // p holds the address of x
    fmt.Println(p)   // something like 0xc0000b4008
    fmt.Println(*p)  // 42 --- dereference to get the value
    *p = 99          // write through the pointer
    fmt.Println(x)   // 99 --- x changed because *p and x are the same memory
}

The zero value of any pointer type is nil. Dereferencing a nil pointer causes a runtime panic — the same kind of NullPointerException you know from Java, just with a different name.

var p *int
fmt.Println(p)  // <nil>
fmt.Println(*p) // panic: runtime error: invalid memory address or nil pointer dereference

Pointers to Basic Types

Java programmers sometimes wonder why you would ever have a pointer to an int. In Java, primitive int is always a value, and you box it into Integer when you need reference semantics. In Go you use *int directly — no boxing, no wrapper class.

func newInt(n int) *int {
    v := n
    return &v // safe: compiler moves v to the heap if needed (escape analysis, see new)
}

p := newInt(7)
fmt.Println(*p) // 7

No Pointer Arithmetic

In C and C++, you can write ptr + 1 to advance a pointer to the next element in an array. Go forbids this entirely.

x := 42
p := &x
p++      // compile error: invalid operation: p++ (non-numeric type *int)
p + 1    // compile error: invalid operation: p + 1 (mismatched types *int and untyped int)

When you genuinely need unsafe pointer arithmetic (for C interop or performance-critical operations), the unsafe package exists, but it earns its name. That is an advanced topic far outside normal day-to-day Go.

Try It

Type this in and run it. It exercises most of the chapter at once: a typed iota enum, the digit separator, a numeric conversion, a struct copied by value, a pointer that mutates through *, and the built-in max. Watch how the boosted copy diverges from the original while the original stays put.

package main

import "fmt"

type Genre int

const (
    House Genre = iota + 1 // 1
    Trance                 // 2
    Techno                 // 3
)

type Track struct {
    Title  string
    Artist string
    BPM    int
    Genre  Genre
}

func boost(t *Track, by int) {
    t.BPM += by // mutate through the pointer
}

func main() {
    var plays int // zero value: 0
    t := Track{   // named struct literal
        Title:  "Eternity",
        Artist: "Anyma & Chris Avantgarde",
        BPM:    124,
        Genre:  Trance,
    }

    copyOfT := t // structs are value types --- this copies
    boost(&copyOfT, 4)

    plays = 2_500_000 // digit separator for readability
    rate := float64(plays) / 60.0
    fmt.Printf("%s by %s [genre %d]\n", t.Title, t.Artist, t.Genre)
    fmt.Println("original BPM:", t.BPM, "boosted copy BPM:", copyOfT.BPM)
    fmt.Printf("plays/min: %.1f, faster of (124,128): %d\n", rate, max(124, 128))
}

Try these modifications:

• Pass t to boost by value instead of by pointer (boost(t Track, by int)) and watch the change vanish.
• Add a Lossless quality enum as a second iota block and print where it resets to zero.
• Drop the float64(plays) conversion and see the compiler reject the implicit int-to-float64 mix.

Key Points

• Go has sized integer types (int8 through int64, unsigned variants); int is the idiomatic general-purpose integer and is platform-native width.
• byte is an alias for uint8; rune is an alias for int32.
• Declare variables with var (anywhere) or := (inside functions only).
• Every type has a zero value; Go never leaves a variable uninitialized.
• Integer literals support 0b (binary), 0o (octal), 0x (hex), and _ as a digit separator.
• const and iota are Go’s enumeration mechanism; iota counts from zero per const block.
• type Celsius float64 creates a new distinct type; type Celsius = float64 is a synonym.
• new(T) returns a zeroed *T; make initializes slices, maps, and channels.
• min, max, and clear are built-in since Go 1.21.
• _ discards values you do not need; every declared variable must otherwise be used.
• Structs are value types; assigning a struct copies it; use pointers for shared mutation.
• The cmp and maps packages (Go 1.21) provide comparison and map utilities; cmp is introduced in Chapter 7, and maps in Chapter 14.

Exercises

1. Think about it: Go’s zero values mean a declared-but-unassigned variable is always valid. Java requires local variables to be assigned before use. What are the practical benefits of Go’s approach? Can you think of a case where Go’s zero values might mask a bug instead of preventing one?

2. What does this print?

   package main
   
   import "fmt"
   
   type StreamingTier int
   
   const (
       Free     StreamingTier = iota
       Standard
       Premium
       Lossless
   )
   
   func main() {
       fmt.Println(Free, Standard, Premium, Lossless)
       tier := Premium
       fmt.Printf("tier type: %T, value: %d\n", tier, tier)
   }

3. Calculation: Given the following declarations, which assignments compile and which produce errors? Identify each line.

   type Bpm float64
   
   var tempo Bpm    = 120.0
   var raw  float64 = tempo          // line A
   var cvt  float64 = float64(tempo) // line B
   var same Bpm     = cvt            // line C

4. Where is the bug?

   package main
   
   import "fmt"
   
   func main() {
       x := 10
       y := 20
       x, y := x + y, x  // reassign both
       fmt.Println(x, y)
   }

5. Write a program: Declare a const block using iota that represents five chart positions for your favorite genre: Debut, Rising, Peak, Declining, and Legacy, numbered 1 through 5 (use iota + 1). Print each constant’s name and value using fmt.Printf with %d. Then declare a variable of that type, assign it the Peak value, and print its Go type using %T.

6. What does this print?

   package main
   
   import "fmt"
   
   func double(n *int) {
       *n *= 2
   }
   
   func main() {
       a := 5
       b := &a
       double(b)
       fmt.Println(a)
       fmt.Println(*b)
   }

7. Where is the bug? The following code tries to append a suffix to a string through a pointer.

   package main
   
   import "fmt"
   
   func addExcitement(s *string) {
       s += "!"
   }
   
   func main() {
       msg := "Out Of The Blue"
       addExcitement(&msg)
       fmt.Println(msg)
   }

   (This code does not compile — what is the type error?)

Strings, Bytes, and Runes

Go strings look familiar — you create them with double quotes, concatenate with +, and pass them to fmt.Println. But the model underneath is different enough from Java’s that it causes real bugs, especially with non-ASCII text. This chapter covers what Go strings actually are, why len(s) might surprise you, and how to work with text correctly.

What a String Really Is

In Java, a String is a sequence of char values, where each char is a UTF-16 code unit. In Go, a string is an immutable sequence of bytes. That is the entire definition. Go makes no promises about encoding; by convention almost all Go source code and string data is UTF-8, but the type itself is just bytes.

Under the hood, a string value is a small struct: a pointer to read-only memory and a length. It is essentially a read-only []byte without the capacity field. Because a string is just a pointer and a length, passing a string to a function copies only those two words — the underlying bytes are never duplicated. You can pass a ten-megabyte string to a function and the call is as cheap as passing an int.

len(s) returns the number of bytes in the string, not the number of characters.

s := "café"
fmt.Println(len(s)) // 5, not 4 --- é is two bytes (0xC3 0xA9)

byte and rune

Go has no char type. Instead it has two types for working with individual pieces of text:

• byte is an alias for uint8. It holds a single ASCII character or one byte of a multibyte sequence.
• rune is an alias for int32. It holds a full Unicode code point.

Java’s char is a UTF-16 code unit, which means characters outside the Basic Multilingual Plane (anything above U+FFFF) require two Java char values. Go’s rune is a full code point, so one rune always represents one character, no matter how far up the Unicode table it lives.

Rune literals use single quotes, just like character literals in Java:

var b byte = 'A'    // 65
var r rune = '⌘'    // 8984 (U+2318 PLACE OF INTEREST SIGN)
var r2 rune = 'é'   // 233 (U+00E9)

A rune literal has default type rune (an alias for int32), so r := 'é' gives r the type rune. Until it acquires a type, though, it is an untyped rune constant and participates in constant arithmetic like any other untyped integer — so 'A' + 1 is the perfectly legal constant 66.

r := 'é'
fmt.Println(r)          // 233
fmt.Printf("%v\n", r)   // 233
fmt.Printf("%c\n", r)   // é

Indexing and Iteration

Indexing with s[i]

Indexing a string with s[i] gives you a byte, not a character.

s := "café"
fmt.Println(s[3]) // 195 (0xC3 --- the first byte of é)

Java programmers often expect s[3] to yield 'é'. In Go it yields 195, the numeric value of the first byte of the two-byte UTF-8 encoding of é. Formatting it with %c would print Ã, which is the Latin character whose code point is 195 — not what you wanted.

Iterating Bytes with a Plain for Loop

A plain index loop iterates bytes:

s := "café"
for i := 0; i < len(s); i++ {
    fmt.Printf("s[%d] = %d\n", i, s[i])
}
// s[0] = 99   (c)
// s[1] = 97   (a)
// s[2] = 102  (f)
// s[3] = 195  (first byte of é)
// s[4] = 169  (second byte of é, 0xA9)

Iterating Runes with for range

for range over a string decodes UTF-8 automatically. The loop variable receives a rune (the Unicode code point), and the index is the byte position of the start of that rune.

s := "café!"
for i, r := range s {
    fmt.Printf("s[%d] = %c (%d)\n", i, r, r)
}
// s[0] = c (99)
// s[1] = a (97)
// s[2] = f (102)
// s[3] = é (233)
// s[5] = ! (33)

Notice that the index jumps from 3 directly to 5 for the ! — index 4 never appears because é occupies bytes 3 and 4, and byte 4 is not the start of a rune.

String Literals

Go has two forms of string literal.

Interpreted string literals use double quotes and process backslash escapes — \n, \t, \uXXXX, \UXXXXXXXX, etc. This is the same as Java.

Raw string literals use backticks and suppress all escape processing. Everything between the backticks is literal, including newlines and backslashes.

// interpreted --- \n is a newline
msg := "Bad Apple!!\nfor you\n"

// raw --- \n is two characters: backslash and n
re := `\d+\.\d+`

// raw --- multi-line JSON template
tmpl := `{
  "artist": "BT",
  "album":  "ESCM"
}`

Raw string literals are especially useful for regular expressions (where backslashes are abundant) and for embedding multi-line text without escaping.

Converting Between Strings, Bytes, and Runes

You can convert freely among string, []byte, and []rune:

s := "hola"

b := []byte(s)  // copy to a mutable byte slice
s2 := string(b) // copy back to a string

r := []rune(s)  // copy to a rune slice
s3 := string(r) // copy back to a string

fmt.Println(s2) // hola
fmt.Println(s3) // hola

Converting a single integer to string gives you the UTF-8 encoding of that code point, not the decimal representation:

fmt.Println(string(rune(65)))  // A
fmt.Println(string(rune(233))) // é

To convert a number to its decimal string representation, use strconv.Itoa (covered below).

The strings Package

The strings package provides the functions you reach for every day. Import it with import "strings".

Searching and Testing

func Contains(s, substr string) bool   // true if substr appears anywhere in s
func HasPrefix(s, prefix string) bool  // true if s starts with prefix
func HasSuffix(s, suffix string) bool  // true if s ends with suffix
func Count(s, substr string) int       // number of non-overlapping occurrences of substr
func Index(s, substr string) int       // byte index of first occurrence, or -1
func EqualFold(s, t string) bool       // true if s and t are equal under Unicode case-folding

s := "Bad Apple!!"
fmt.Println(strings.Contains(s, "Apple"))  // true
fmt.Println(strings.HasPrefix(s, "Bad"))   // true
fmt.Println(strings.HasSuffix(s, "!!"))    // true
fmt.Println(strings.Count(s, "p"))         // 2
fmt.Println(strings.Index(s, "Apple"))     // 4

strings.EqualFold is the case-insensitive equality test, Go’s answer to Java’s equalsIgnoreCase:

fmt.Println(strings.EqualFold("Darude", "DARUDE")) // true

Splitting and Joining

func Split(s, sep string) []string         // slice of substrings separated by sep
func Join(elems []string, sep string) string // concatenate elems with sep between each
func Fields(s string) []string             // split around runs of whitespace, dropping empties

parts := strings.Split("un,dos,tres", ",")
fmt.Println(parts)                       // [un dos tres]
fmt.Println(strings.Join(parts, " - ")) // un - dos - tres

strings.Fields splits on runs of whitespace (any amount), which is handy for tokenising messy input where Split(s, " ") would leave empty strings:

fmt.Println(strings.Fields("  un   dos  tres ")) // [un dos tres]

Trimming and Case

func TrimSpace(s string) string               // strip leading and trailing whitespace
func Trim(s, cutset string) string            // strip any chars in cutset from both ends
func ToUpper(s string) string                 // return s in upper case
func ToLower(s string) string                 // return s in lower case
func ReplaceAll(s, old, new string) string    // replace every occurrence of old with new

TrimSpace strips leading and trailing whitespace. Trim strips any characters in the cutset from both ends:

fmt.Println(strings.TrimSpace("  flores  "))                  // flores
fmt.Println(strings.Trim("***Sandstorm***", "*"))              // Sandstorm
fmt.Println(strings.Trim("...Better Off Alone...", "/."))      // Better Off Alone
fmt.Println(strings.ToUpper("flowers"))                        // FLOWERS
fmt.Println(strings.ReplaceAll("la la la", "la", "na"))        // na na na

Building Strings: strings.Builder

strings.Builder is the idiomatic way to build up a string incrementally. It is Go’s answer to Java’s StringBuilder. Unlike concatenating with + in a loop (which allocates a new string on every iteration), Builder maintains a growing buffer and materialises the final string only when you call String().

var b strings.Builder
b.WriteString("Sandstorm --- ")
b.WriteString("Darude")
b.WriteByte('\n')
b.WriteRune('🎵')
fmt.Println(b.String())
// Sandstorm --- Darude
// 🎵

The relevant methods are:

func (b *Builder) WriteString(s string) (int, error)  // append a string
func (b *Builder) WriteByte(c byte) error             // append a single byte
func (b *Builder) WriteRune(r rune) (int, error)      // append a Unicode code point
func (b *Builder) String() string                     // return the accumulated string
func (b *Builder) Reset()                             // clear the buffer for reuse
func (b *Builder) Len() int                           // current length in bytes

The strconv Package

strconv handles conversions between strings and numeric types.

func Itoa(i int) string                                           // int → decimal string
func Atoi(s string) (int, error)                                  // decimal string → int
func FormatInt(i int64, base int) string                          // int64 → string in base
func ParseInt(s string, base int, bitSize int) (int64, error)     // base 0 auto-detects prefix
func FormatUint(i uint64, base int) string                        // uint64 → string in base
func ParseUint(s string, base int, bitSize int) (uint64, error)   // string → uint64
func FormatFloat(f float64, fmt byte, prec, bitSize int) string   // float64 → string
func ParseFloat(s string, bitSize int) (float64, error)           // string → float64
func FormatBool(b bool) string                                    // bool → "true"/"false"
func ParseBool(str string) (bool, error)                          // "true"/"false" → bool

Itoa and Atoi are convenient wrappers for base-10 int. When you need a specific base or size, reach for ParseInt/ParseUint and FormatInt/FormatUint directly:

strconv.FormatInt(255, 16)          // "ff"  --- hex
strconv.FormatInt(255, 2)           // "11111111" --- binary
strconv.ParseInt("ff", 16, 64)      // 255, nil
strconv.ParseInt("0xFF", 0, 64)     // 255, nil --- base 0 detects "0x" prefix
strconv.ParseUint("4294967295", 10, 32) // 4294967295, nil --- fits in uint32

The bitSize parameter (8, 16, 32, or 64) constrains the result range without changing the return type — ParseInt always returns int64, but passing bitSize=32 guarantees the value fits in int32.

s := strconv.Itoa(42)    // "42"
n, err := strconv.Atoi("99") // 99, nil
bad, err := strconv.Atoi("nope") // 0, *strconv.NumError

strconv.Atoi returns two values: the converted integer and an error. If the string is not a valid integer, err is non-nil. You should always check the error. [no-discard-error] Error handling is covered fully in Chapter 9; for now, the pattern is:

n, err := strconv.Atoi(s)
if err != nil {
    // handle the error
}

The unicode/utf8 Package

When you need to work at the rune level without converting the whole string to []rune, the unicode/utf8 package gives you the tools.

func RuneCountInString(s string) int                  // number of runes in s (not bytes)
func DecodeRuneInString(s string) (r rune, size int)  // first rune and its byte width
func ValidString(s string) bool                       // true if s is valid UTF-8

s := "café"
fmt.Println(len(s))                        // 5 (bytes)
fmt.Println(utf8.RuneCountInString(s))     // 4 (runes)

r, size := utf8.DecodeRuneInString(s)
fmt.Printf("first rune: %c, size: %d\n", r, size) // first rune: c, size: 1

fmt.Println(utf8.ValidString(s))           // true
fmt.Println(utf8.ValidString("\xff\xfe"))  // false

DecodeRuneInString is useful when you want to peel off one rune at a time from the front of a string without a full for range loop.

The bytes Package

The bytes package mirrors the strings package but operates on []byte instead of string. Every function in strings that takes a string has a counterpart in bytes that takes []byte. For example, bytes.Contains, bytes.Split, bytes.Join, bytes.TrimSpace.

When you are working with data that is already in a []byte (reading from a file or network, for instance), using bytes functions avoids the copy that string(b) would require.

bytes.Buffer is the older alternative to strings.Builder and supports both reading and writing — it implements io.Reader and io.Writer, making it useful for testing code that writes to an io.Writer.

func Contains(b, subslice []byte) bool // true if subslice is within b
func ToUpper(s []byte) []byte          // a copy of s with all Unicode letters uppercased

data := []byte("good days")
fmt.Println(bytes.Contains(data, []byte("days"))) // true
fmt.Printf("%s\n", bytes.ToUpper(data))           // GOOD DAYS

var buf bytes.Buffer
fmt.Fprintf(&buf, "%d good days", 365) // buf implements io.Writer
fmt.Println(buf.String())              // 365 good days

Try It

Type this in and run it. It exercises the byte/rune distinction, for range, strings.Builder, strconv, and a couple of strings helpers all at once. Watch how the byte index from range lines up with the bytes the builder records.

package main

import (
    "fmt"
    "strconv"
    "strings"
    "unicode/utf8"
)

func main() {
    line := "Ojitos Lindos --- Bad Bunny"

    fmt.Println("bytes:", len(line))                    // byte count
    fmt.Println("runes:", utf8.RuneCountInString(line)) // rune count

    var b strings.Builder
    for i, r := range line {
        if r == 'o' || r == 'O' {
            b.WriteString("[" + strconv.Itoa(i) + "]") // tag each o with its byte index
        } else {
            b.WriteRune(r)
        }
    }
    fmt.Println(b.String())

    fmt.Println(strings.ToUpper(line))
    fmt.Println("contains Bunny:", strings.Contains(line, "Bunny"))
}

Try these modifications:

• Replace the ASCII title with one containing accented characters (say a Spanish phrase with ñ or é) and watch len and RuneCountInString diverge.
• Switch the for range loop to a plain for i := 0; i < len(line); i++ loop and observe how it now visits bytes instead of runes.
• Use strconv.Atoi to parse a track number out of a string like "track 7" (after trimming) and handle the error.

Key Points

• Go strings are immutable byte sequences; len(s) counts bytes, not characters.
• byte is uint8; rune is int32 (a full Unicode code point).
• s[i] yields a byte; use for range to iterate runes.
• Java char is a UTF-16 code unit; Go rune is a full code point — they are different concepts.
• Raw string literals (backticks) pass through all characters literally, including backslashes and newlines.
• Converting between string, []byte, and []rune always copies data.
• strings.Builder is the idiomatic way to build strings in a loop; avoid += in loops.
• strconv.Atoi returns an error; always check it.
• utf8.RuneCountInString gives the true character count; len gives the byte count.
• The bytes package mirrors strings for []byte data.

Exercises

1. Think about it: Go strings are described as “immutable sequences of bytes.” Java strings are also immutable. Given that both languages have immutable strings, why does Go’s for range behave differently from Java’s enhanced for loop over s.toCharArray()? What would have to be true about the loop for both languages to give the same result?

2. What does this print?

   package main
   
   import "fmt"
   
   func main() {
       s := "Alizée"
       fmt.Println(s[4])
   }

3. Calculation: len("Alizée") returns how many bytes? And utf8.RuneCountInString("Alizée") returns how many runes? (Hint: Alizée is spelled A, l, i, z, é, e — the accented é (U+00E9) comes before the final plain e. The five plain ASCII letters are one byte each, and é is two bytes in UTF-8.)

4. Where is the bug? The following function tries to reverse each byte’s case by operating on raw bytes:

   func swapCase(s string) string {
       b := []byte(s)
       for i := range b {
           switch {
           case b[i] >= 'A' && b[i] <= 'Z':
               b[i] += 32
           case b[i] >= 'a' && b[i] <= 'z':
               b[i] -= 32
           }
       }
       return string(b)
   }
   
   func main() {
       fmt.Println(swapCase("Héroe"))
   }

   é is encoded as bytes 0xC3 (195) and 0xA9 (169). H is 72 and e is 101. Trace through the loop byte by byte. What does the function actually print, and what is fundamentally wrong with this approach for non-ASCII strings?

5. Write a program: Write a function reverseString(s string) string that returns the string with its runes in reverse order. For example, reverseString("café") should return "éfac". Test it with at least one string that contains a multibyte character to confirm it handles Unicode correctly. (Hint: convert to []rune first.)

Control Flow

Java programmers are immediately comfortable with if, for, and switch in Go — the syntax is close enough that you can write working code on day one. But Go has a few surprises: there is only one loop keyword, switch does not fall through by default, and defer is a concept with no Java equivalent. This chapter covers all of it.

if / else

if and else work the same as in Java. The main syntactic difference is that the condition does not require parentheses (though they are allowed).

score := 95
if score >= 90 {
    fmt.Println("A")
} else if score >= 80 {
    fmt.Println("B")
} else {
    fmt.Println("C")
}
// A

The Init Statement

Go’s if statement supports an optional init statement separated from the condition by a semicolon. Variables declared in the init statement are scoped to the entire if/else if/else chain — they disappear after the closing brace.

if n := len("Sandstorm"); n > 6 {
    fmt.Println("long:", n)
} else {
    fmt.Println("short:", n)
}
// long: 9
// n is not accessible here

The most common use is capturing the result of a function call and checking the error in one line:

if err := doSomething(); err != nil {
    fmt.Println("error:", err)
    return
}

This pattern is ubiquitous in Go. You will see it constantly when you read idiomatic Go code. Chapter 9 covers error handling in full, but start recognizing this shape now.

for — the Only Loop

Go has exactly one loop keyword: for. There is no while, no do...while, and no foreach (that role is played by for range). Three forms cover every use case.

C-Style Loop

The familiar three-clause form works exactly as in Java:

for i := 0; i < 5; i++ {
    fmt.Println(i)
}
// 0 1 2 3 4 (each on its own line)

While-Style Loop

Omit the init and post clauses and you get a while loop:

n := 1
for n < 100 {
    n *= 2
}
fmt.Println(n) // 128

Infinite Loop

Omit the condition entirely for an infinite loop. Use break to exit.

for {
    line := readLine()
    if line == "" {
        break
    }
    process(line)
}

range

for range is Go’s replacement for Java’s for-each loop, extended to work on slices, arrays, maps, strings, channels, integers, and iterator functions. It yields up to two values, depending on what you range over: slices, arrays, maps, and strings yield an index (or key) and a value, while integer ranges (for i := range n), channels, and iter.Seq[V] iterators yield a single value. You can always bind just the first value and let Go implicitly drop the second — for i := range fruits gives you the index alone, no blank identifier needed.

The table below summarizes what the first and second values are for each rangeable type:

Slices and arrays yield the index and the element, replacing Java’s for (int i = 0; i < list.size(); i++) and for (T v : list) in one construct:

fruits := []string{"manzana", "naranja", "uva"}
for i, v := range fruits {
    fmt.Println(i, v)
}
// 0 manzana
// 1 naranja
// 2 uva

Maps yield each key–value pair in unspecified order:

m := map[string]int{"one": 1, "two": 2, "three": 3}
for k, v := range m {
    fmt.Println(k, v)
}
// output order is random --- never rely on it

Strings decode Unicode code points rather than bytes, which is important for non-ASCII text. As covered in Chapter 3, the index is the byte position of the rune, not its character index:

for i, r := range "café" {
    fmt.Printf("%d: %c\n", i, r)
}
// 0: c
// 1: a
// 2: f
// 3: é

Channels receive values one at a time, blocking until the next value arrives or the channel is closed — a clean way to drain a producer without a separate ok check on each receive. Channels are covered in Chapter 10.

Integers (Go 1.22+) give you a concise way to loop n times without a separate counter variable — a common pattern when you need a fixed number of iterations but do not need the index for anything else:

for i := range 5 {
    fmt.Print(i, " ")
}
// 0 1 2 3 4

Iterator functions (Go 1.23+) let library authors expose lazy, on-demand sequences without materializing the whole collection into a slice first — useful for large or infinite sequences. Any function that matches the iter.Seq[V] or iter.Seq2[K,V] signature from the iter package can be ranged over directly:

for title := range playlist.Titles() { // playlist.Titles() returns iter.Seq[string]
    fmt.Println(title)
}

The signatures, yield mechanics, and how to write your own iterators are covered in Chapter 18 (Generics).

In any for range form, use the blank identifier _ to discard the index or the value when you do not need it:

for _, v := range fruits {
    fmt.Println(v) // index discarded
}

for i := range fruits {
    fmt.Println(i) // value implicitly discarded (single-variable range)
}

switch

Go’s switch looks familiar but has two important differences from Java:

1. Cases do not fall through by default.
2. The switch expression is optional.

Basic switch

day := "lunes"
switch day {
case "lunes", "martes", "miércoles", "jueves", "viernes":
    fmt.Println("weekday")
case "sábado", "domingo":
    fmt.Println("weekend")
default:
    fmt.Println("unknown")
}
// weekday

Notice that multiple values can appear in one case, separated by commas. No break is needed — each case exits automatically.

Unlike Java, Go’s switch is not limited to integers, strings, or enums. You can switch on any comparable type — structs, arrays, or any user-defined type that supports ==:

type Point struct{ X, Y int }

p := Point{1, 2}
switch p {
case Point{0, 0}:
    fmt.Println("origin")
case Point{1, 2}:
    fmt.Println("one, two") // matches
default:
    fmt.Println("somewhere else")
}

fallthrough

When you genuinely need Java-style fall-through, use the fallthrough keyword explicitly. It transfers control to the first statement of the next case body without re-evaluating the case condition.

n := 1
switch n {
case 1:
    fmt.Println("one")
    fallthrough
case 2:
    fmt.Println("one or two")
case 3:
    fmt.Println("three")
}
// one
// one or two

fallthrough is unconditional — it always falls through regardless of whether the next case condition would match. It is rarely needed in practice.

Expression-Less switch

Omit the switch expression and each case becomes an independent boolean condition. This is a cleaner alternative to a long if/else if chain:

temp := 38.5
switch {
case temp < 0:
    fmt.Println("freezing")
case temp < 20:
    fmt.Println("cold")
case temp < 37:
    fmt.Println("warm")
default:
    fmt.Println("fiebre!")
}
// fiebre!

Type Switch (Preview)

A type switch selects a case based on the dynamic type of an interface value:

switch v := i.(type) {
case int:
    fmt.Println("int:", v)
case string:
    fmt.Println("string:", v)
default:
    fmt.Printf("other: %T\n", v)
}

Type switches are covered fully in Chapter 8 alongside interfaces.

Labeled break and continue

Java supports labeled statements to break out of nested loops. Go supports the same with labeled break and continue.

outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i == 1 && j == 1 {
            break outer // exits both loops
        }
        fmt.Println(i, j)
    }
}
// 0 0
// 0 1
// 0 2
// 1 0

continue outer would skip the rest of the inner loop body and continue with the next iteration of the outer loop.

goto

Go has goto, which jumps to a labeled statement within the same function. It cannot jump over variable declarations. It is legal but almost never the right tool — goto is mentioned here so you know it exists, not as an invitation to use it.

defer

defer is one of Go’s most distinctive features. A defer statement pushes a function call onto a per-function stack. All deferred calls run when the enclosing function returns, in last-in, first-out (LIFO) order.

func greet() {
    defer fmt.Println("goodbye")
    defer fmt.Println("see you later")
    fmt.Println("hello")
}

// greet() prints:
// hello
// see you later
// goodbye

You might be thinking “that’s nifty” — and then “why would I ever use that?!?” Go does not have Java’s try-finally, but defer is used in a similar way. Careful though: the mechanism is quite different — the finally clause runs at the end of a block in Java, but defer runs when a function returns.

Arguments Are Evaluated Immediately

The arguments to a deferred function call are evaluated at the defer statement, not when the deferred call actually runs.

func demo() {
    x := 10
    defer fmt.Println(x) // x is captured as 10 right now
    x = 99
}
// prints: 10

This catches many Go beginners off guard. The value of x at defer time (10) is baked in; the change to x = 99 does not affect it.

Closures Capture Variables by Reference

If the deferred function is a closure (a function that references a variable from an enclosing scope rather than receiving it as a parameter), it captures the variable itself as closures normally do, so it reads whatever value that variable holds at the time the deferred call actually runs.

func demo() {
    x := 10
    defer fmt.Print(" direct ", x)              // x is captured as 10 right now
    defer func() { fmt.Print("closure ", x) }() // closure, not a direct call
    x = 99
}
// prints: closure 99 direct 10

This distinction is important: a deferred call with arguments evaluates the arguments immediately, but a deferred closure evaluates its captured variables lazily at return time.

Common Uses

Closing resources is the most common use of defer:

f, err := os.Open("cancion.txt")
if err != nil {
    return err
}
defer f.Close() // guaranteed to run even if the rest of the function panics

This pattern ensures cleanup happens no matter how the function exits — return, error return, or panic.

Releasing locks:

mu.Lock()
defer mu.Unlock()

Printing structured exit messages (useful during debugging):

func process() {
    fmt.Println("process: start")
    defer fmt.Println("process: done")
    // ... work ...
}

defer Runs Even During a Panic

If a function panics, all of its deferred calls still run before the panic propagates up the call stack. This is why defer f.Close() is safe even when something unexpected happens.

func riskyOp() {
    defer fmt.Println("cleanup always runs")
    panic("something went wrong")
}

func main() {
    riskyOp()
}
// prints: cleanup always runs
// then panics

Try It

Type this in and run it. It pulls together the four control-flow tools you will reach for most often: an if init statement, a for range over a map, an expression-less switch, and a defer.

package main

import (
    "fmt"
    "slices"
)

func main() {
    defer fmt.Println("done analyzing the playlist")

    plays := map[string]int{
        "Monaco":           120,
        "Where She Goes":   95,
        "Tití Me Preguntó": 200,
    }

    if total := len(plays); total > 0 {
        fmt.Println("tracks loaded:", total)
    }

    titles := make([]string, 0, len(plays))
    for title := range plays {
        titles = append(titles, title)
    }
    slices.Sort(titles) // map order is randomized, so sort for stable output

    for i, title := range titles {
        count := plays[title]
        switch {
        case count >= 150:
            fmt.Printf("%d. %s --- hit (%d plays)\n", i+1, title, count)
        case count >= 100:
            fmt.Printf("%d. %s --- popular (%d plays)\n", i+1, title, count)
        default:
            fmt.Printf("%d. %s --- deep cut (%d plays)\n", i+1, title, count)
        }
    }
}

Because the titles are sorted, the output is deterministic: the deferd line always prints last, after the three ranked tracks.

Try these modifications:

• Add a fallthrough to one of the cases and observe how the output changes.
• Replace the expression-less switch with an equivalent if/else if chain.
• Remove the slices.Sort call, run it a few times, and watch the map iteration order shuffle.

Key Points

• if supports an init statement: if err := f(); err != nil — scopes the variable to the block.
• for is the only loop keyword in Go; it covers C-style, while-style, and infinite loops.
• for range iterates slices (index+value), maps (key+value), strings (byte-index+rune), channels, integers (Go 1.22+), and iterator functions (Go 1.23+).
• Map iteration order is deliberately randomized.
• switch does not fall through by default; use fallthrough explicitly when needed.
• An expression-less switch acts as a cleaner if/else chain.
• Labeled break and continue break out of nested loops.
• defer pushes a call onto a LIFO stack; all deferred calls run when the function returns.
• Defer arguments are evaluated immediately; closures in defer capture variables by reference.
• defer runs even when the function panics.

Exercises

1. Think about it: Go’s switch does not fall through by default, while Java’s does. Imagine you are reviewing a Go codebase written by a Java programmer. What kind of bug would you look for in their switch statements? Describe a concrete example where the Java habit causes a silent logic error in Go.

2. What does this print?

   package main
   
   import "fmt"
   
   func main() {
       for i := 0; i < 3; i++ {
           defer fmt.Println(i)
       }
       fmt.Println("done")
   }

3. What does this print? Trace the output of the following expression-less switch, one line at a time:

   package main
   
   import "fmt"
   
   func classify(n int) {
       switch {
       case n < 0:
           fmt.Println("negative")
       case n == 0:
           fmt.Println("zero")
       case n%2 == 0:
           fmt.Println("positive even")
       default:
           fmt.Println("positive odd")
       }
   }
   
   func main() {
       classify(-3)
       classify(0)
       classify(4)
       classify(7)
   }

4. Where is the bug? The following code tries to build three multiplier functions that multiply their input by 10, 20, and 30 respectively. What does it actually print when each function is called with 5, and why?

   package main
   
   import "fmt"
   
   func makeMultipliers() []func(int) int {
       fns := make([]func(int) int, 3)
       factor := 1
       for i := 0; i < 3; i++ {
           factor = (i + 1) * 10
           fns[i] = func(x int) int { return x * factor }
       }
       return fns
   }
   
   func main() {
       fns := makeMultipliers()
       for _, f := range fns {
           fmt.Println(f(5))
       }
   }

5. Write a program: Write a function processFile(path string) that opens a file, defers closing it, reads the first 64 bytes, and prints them as a string. Use defer to guarantee the file is closed even if an error occurs mid-function. Call the function with a valid path and with a path that does not exist, and print the error in the second case.

6. Calculation: Consider this loop:

   count := 0
   for i := 2; i < 100; i *= 2 {
       count++
   }

   How many times does the loop body execute, and what is the value of i when the loop condition is evaluated for the last time (and fails)?

Functions

Go functions look familiar on the surface — func, a name, parameters, a body — but underneath they have capabilities that Java methods do not: multiple return values, first-class status as values, and closures that capture variables from the surrounding scope. This chapter covers all of those features, plus variadic functions, the special init function, and the pattern of passing functions as parameters to build flexible, composable code. It also covers the topics that depend on understanding both functions and pointers together: value vs pointer semantics, when mutation requires a pointer, and escape analysis.

Function Syntax

A function declaration uses func, a name, a parameter list, an optional return type, and a body:

func greet(name string) string {
    return "Hola, " + name + "!"
}

When consecutive parameters share the same type, Go lets you write the type once at the end of the group:

func add(a, b int) int { return a + b }                       // a and b are both int
func volume(l, w, h float64) float64 { return l * w * h }     // all three are float64

This shorthand works for any number of consecutive same-typed parameters and is idiomatic in Go.

Multiple Return Values

In Java, a method returns exactly one value. When you need to signal failure you throw an exception. Go takes a different approach: a function can return multiple values, and the convention is to return the result alongside an error value. [errors-not-panic]

func divide(a, b float64) (float64, error) { // returns result and an error
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero") // zero value + error
    }
    return a / b, nil                                  // result + nil means success
}

The caller receives both values and must handle them:

result, err := divide(10, 3)
if err != nil {
    fmt.Println("error:", err)
    return
}
fmt.Printf("%.4f\n", result) // 3.3333

Use _ when you genuinely do not need one of the returned values:

result, _ := divide(10, 2) // discard the error (only do this when you are certain)

strconv Revisited

You saw strconv.Atoi in Chapter 3; now the two-value return makes more sense:

n, err := strconv.Atoi("42")  // 42, nil
n, err  = strconv.Atoi("🔥")  // 0,  *strconv.NumError

The function returns the converted value and an error. If parsing fails, the first return value is the zero value for the type (0 for int), and err is non-nil.

Named Return Values

Go lets you name the return values in the function signature. Named returns serve two purposes: they document what each value means [name-results-for-clarity], and they give defer a way to modify the return value before it leaves the function.

func minMax(nums []int) (lo, hi int) { // named returns document intent
    lo, hi = nums[0], nums[0]          // they are zero-initialized variables
    for _, n := range nums {
        if n < lo {
            lo = n
        }
        if n > hi {
            hi = n
        }
    }
    return // naked return --- returns current values of lo and hi
}

The return at the end with no arguments is a naked return. It returns whatever values the named return variables currently hold.

defer Modifying Named Returns

Because named returns are real variables, a deferred closure can read or modify them:

// safeOpen reads path and returns its contents; close errors are propagated via named return.
func safeOpen(path string) (data string, err error) {
    f, err := os.Open(path)
    if err != nil {
        return // err is already set
    }
    defer func() {
        if cerr := f.Close(); cerr != nil {
            err = cerr // overwrite any existing err with the close error
        }
    }()
    // ... read file into data ...
    return
}

The deferred closure can assign to err because err is a named return variable in the enclosing function. This pattern is useful for ensuring that a close error is not silently swallowed. [name-for-deferred-modify]

Variadic Functions

A variadic function accepts a variable number of arguments of a given type. The last parameter uses the ...T syntax:

func sum(nums ...int) int { // nums is []int inside the function
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

You can call it with any number of arguments, including zero:

fmt.Println(sum())           // 0
fmt.Println(sum(1, 2, 3))    // 6
fmt.Println(sum(10, 20, 30)) // 60

If you already have a slice and want to pass it to a variadic function, append ... to the slice in the call:

scores := []int{88, 92, 77, 95}
fmt.Println(sum(scores...)) // 352

Without ... the compiler would complain that you are passing a []int where int arguments are expected.

fmt.Println is itself variadic:

func Println(a ...any) (n int, err error) // prints each argument separated by spaces

That is why you can pass it any number of values of any type.

First-Class Functions

In Go, functions are first-class values. You can assign a function to a variable, store functions in a map, pass them as arguments, and return them from other functions. Java achieves this using java.util.function interfaces and lambdas, but in Go it is much simpler — a function is just a value, no wrapper interface required.

Function Types and Variables

A function type describes the parameter and return types of a function:

type transformer func(string) string // a function that takes and returns a string

You can assign any function with a matching signature to a variable of that type:

func shout(s string) string { return strings.ToUpper(s) }      // named function
whisper := func(s string) string { return strings.ToLower(s) } // anonymous function

var t transformer = shout
fmt.Println(t("better off alone")) // BETTER OFF ALONE
t = whisper
fmt.Println(t("BETTER OFF ALONE")) // better off alone

Dispatch Tables

Storing functions in a map creates a compact dispatch table — a clean alternative to a long switch statement.

ops := map[string]func(int, int) int{
    "add": func(a, b int) int { return a + b }, // addition handler
    "sub": func(a, b int) int { return a - b }, // subtraction handler
    "mul": func(a, b int) int { return a * b }, // multiplication handler
}

op := "add"
if fn, ok := ops[op]; ok {
    fmt.Println(fn(3, 4)) // 7
}

This pattern is common in command routing, codec registries, and plugin systems.

Closures

A closure is a function value that captures variables from the scope in which it was defined. The function “closes over” those variables — it can read and modify them even after the enclosing scope has returned.

A Counter Example

func makeCounter() func() int {  // returns a function
    count := 0                   // count lives as long as the returned function does
    return func() int {
        count++    // captures count by reference
        return count
    }
}

next := makeCounter()
fmt.Println(next()) // 1
fmt.Println(next()) // 2
fmt.Println(next()) // 3

Each call to makeCounter creates a new, independent count variable. Two counters created by separate calls do not share state.

Loop Variable Capture

A classic Go pitfall — now fixed — was accidentally sharing a loop variable across all closures created in a loop.

// Go 1.21 and earlier: all three closures capture the same i
fns := make([]func(), 3)
for i := 0; i < 3; i++ {
    fns[i] = func() { fmt.Println(i) }
}
// calling fns[0](), fns[1](), fns[2]() would print 3, 3, 3 in Go 1.21

In Go 1.22 the loop variable semantics changed. Both for range and C-style for loops now create a new variable per iteration, so each closure captures its own copy:

// Go 1.22+: each closure captures its own i
for i := 0; i < 3; i++ {
    fns[i] = func() { fmt.Println(i) }
}
fns[0]() // 0
fns[1]() // 1
fns[2]() // 2

init()

Every Go source file can declare one or more init functions:

func init() {
    // runs before main
}

init functions are called automatically by the Go runtime after all package-level variables have been initialized, and before main runs. You cannot call init explicitly — the runtime owns it. This is the rough equivalent of a Java static { ... } initializer block: code that runs once when the type (in Go, the package) is first loaded. The difference is scope: Go’s init runs per-package, while a Java static block runs per-class. Both allow several blocks, executed in source order.

Rules

• A single file may contain multiple init functions; they run in source order.
• Multiple files in a package: init functions run in the order the compiler processes the files (alphabetical by filename).
• If package A imports package B, B’s init functions complete before A’s.
• init cannot be called directly by user code.

// config.go
var configLoaded bool

func init() {
    loadConfig()
    configLoaded = true
}

When to Use init()

Use init for:

• One-time setup that cannot be expressed as a simple variable initializer.
• Registering database drivers, codec implementations, or similar plugin-style registrations.
• Validating configuration at startup before anything else runs.

Function Types as Parameters

Passing a function as a parameter is the Go equivalent of a Java functional interface. The pattern shows up constantly for callbacks, option functions, and middleware.

Callbacks

func applyToAll(nums []int, fn func(int) int) []int { // fn is called for each element
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = fn(n)
    }
    return result
}

doubled := applyToAll([]int{1, 2, 3, 4}, func(n int) int { return n * 2 })
fmt.Println(doubled) // [2 4 6 8]

Middleware Pattern

The middleware pattern wraps a function with pre- and post-logic without changing the wrapped function’s signature.

func withLogging(name string, fn func()) func() { // returns a wrapped version of fn
    return func() {
        fmt.Printf("[log] %s: starting\n", name) // pre-logic
        fn()                                      // call the original function
        fmt.Printf("[log] %s: done\n", name)     // post-logic
    }
}

greet := func() {
    fmt.Println("hola, mundo!")
}

loggedGreet := withLogging("greet", greet)
loggedGreet()
// [log] greet: starting
// hola, mundo!
// [log] greet: done

The wrapper returns a new func() that has the same signature as the original. The caller does not need to know that logging is happening. This is an instance of the decorator pattern — extra behavior is layered onto a function without changing its interface. This is the same idea behind Java’s java.lang.reflect.Proxy and AOP frameworks, but expressed with plain function values instead of bytecode weaving.

You can chain wrappers: withLogging("greet", withTiming("greet", greet)) would produce a function that logs and times the greeting. Building a withTiming wrapper follows the same shape as withLogging; the time package that makes it useful is covered in Chapter 14.

Pointer vs Value Semantics

Go structs are value types: assigning one struct to another copies all the fields. Java objects are always reference types: variables hold pointers to the object. Assigning a variable to another copies the pointer, not the object, thus both variables end up referring to the same object.

Consider a Point struct (covered fully in Chapter 2):

type Point struct {
    X, Y int
}

Value copy behavior:

a := Point{X: 3, Y: 4}
b := a              // b is a full copy
b.X = 99
fmt.Println(a.X)    // 3 --- a is unchanged
fmt.Println(b.X)    // 99

The same assignment in Java would have b and a pointing at the same object, so setting b.x = 99 would also change a.x.

The Swap That Doesn’t Work

The classic demonstration of why value semantics matters is a swap function.

// This does NOT work.
func swapBad(a, b int) {
    a, b = b, a // swaps the local copies only
}

func main() {
    x, y := 10, 20
    swapBad(x, y)
    fmt.Println(x, y) // 10 20 --- unchanged
}

swapBad receives copies of x and y. Swapping a and b inside the function has no effect on the caller’s variables.

The Swap That Works

Pass pointers and write through them:

// This works.
func swap(a, b *int) {    // a and b are pointers to the caller's ints
    *a, *b = *b, *a       // dereference both and swap the values in-place
}

func main() {
    x, y := 10, 20
    swap(&x, &y)           // pass the addresses of x and y
    fmt.Println(x, y)      // 20 10 --- swapped
}