Functions and multiple return values

Why functions?

A function lets you write a job once and use it many times by name. It also gives the job a clear name, so main reads like a list of steps: readOrder, calculateTotal, sendReceipt.

Writing a function

func withGST(price int) int {
	return price + price*18/100
}

func main() {
	fmt.Println(withGST(200)) // 236
}

• The type comes after the name: price int, not int price.
• Consecutive parameters of the same type can share it: func add(a, b int) int.
• A function with no result simply has no type after the brackets: func greet(name string).
• Go has no default values for parameters and no overloading (two functions with the same name). Give functions different names instead.

Multiple return values

A Go function can return more than one value. The most common pattern is a result and an error. The caller checks the error first. This replaces exceptions, which Go does not have.

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return a / b, nil
}

func main() {
	q, err := divide(10, 2)
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(q) // 5
}

q, _ := divide(9, 3)        // ignore the error (only when you are sure)
lo, hi := minMax([]int{4, 9, 1})

Named result values

func split(total int) (half, rest int) {
	half = total / 2
	rest = total - half
	return // a "naked" return sends back half and rest
}

func main() {
	fmt.Println(split(15)) // 7 8
}

Arguments are copied

Go passes arguments by value: the function gets its own copy. Changing a parameter inside does not change the caller's variable. To let a function change the caller's value, pass a pointer (module 4). Slices and maps behave differently because the copy still points to the same underlying data; you will see why in module 3.

func addBonus(marks int) {
	marks += 5
}

func main() {
	m := 80
	addBonus(m)
	fmt.Println(m) // still 80
}

Exported or not: the first letter

A function whose name starts with a capital letter (CalculateTotal) can be used from other packages. A lowercase name (calculateTotal) is private to its package. That is the whole visibility system in Go; there are no public/private keywords.