Syntax Basics

Go keeps its grammar deliberately small. There are only a couple of dozen keywords, and there is usually one obvious way to write something. That makes Go code from different teams look remarkably alike. This chapter covers packages and imports, variables and constants, functions, control flow, and the distinctly Go-flavored defer.

Packages and imports

Every Go file begins with a package clause. To use another package, import it and refer to its members through the package name. Visibility is decided by the first letter: identifiers starting with an uppercase letter (Println, Pi) are exported, and everything else stays private to its package.

package main

import (
	"fmt"
	"math"
	"strings"
)

func main() {
	fmt.Println(math.Pi)
	fmt.Println(strings.ToUpper("go"))
}

Importing a package and not using it is a compile error. It feels strict at first, but it means dead dependencies never pile up in your files.

Variables and constants

Declare variables with var, or inside functions use the short form :=, which infers the type from the right-hand side. A variable declared without a value starts at its zero value: 0 for numbers, "" for strings, false for booleans, and nil for pointers, slices, maps, channels, functions, and interfaces. There is no such thing as an uninitialized variable in Go.

var count int          // 0
var name = "gopher"    // inferred as string
x, y := 10, 3.5        // int and float64
x, z := 20, true       // allowed because z is new; x is just reassigned

const Limit = 100
const (
	Read = 1 << iota // 1
	Write            // 2
	Exec             // 4
)

iota counts up from zero within a const block, which makes it the idiomatic way to build enumerations and bit flags. Note that := only works inside functions; at package level you must use var. Declaring a local variable and never reading it is, again, a compile error.

Functions

Functions are declared with func, and types come after parameter names. The feature you will use constantly is multiple return values: Go functions conventionally return a result alongside an error rather than throwing.

func add(a, b int) int {
	return a + b
}

// Return a value and an error together
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, fmt.Errorf("cannot divide by zero")
	}
	return a / b, nil
}

// Named result plus a variadic parameter
func sum(nums ...int) (total int) {
	for _, n := range nums {
		total += n
	}
	return
}

func main() {
	q, err := divide(10, 4)
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(q, sum(1, 2, 3))

	double := func(n int) int { return n * 2 } // function literal (closure)
	fmt.Println(double(add(1, 2)))
}