Introduction
Functions in Go are fundamental building blocks that allow you to encapsulate code into reusable and modular pieces. They help in organizing code, improving readability, and promoting code reuse. In this chapter, you will learn the syntax and usage of functions in Go, with examples to illustrate different types of functions.
Syntax
A function in Go is defined using the func keyword, followed by the function name, parameters (if any), return types (if any), and the function body.
Syntax:
func functionName(parameter1 type1, parameter2 type2) returnType {
// function body
return value
}
Examples
Basic Function
A basic function that takes no parameters and returns no value.
Example:
package main
import "fmt"
func sayHello() {
fmt.Println("Hello, World!")
}
func main() {
sayHello() // Output: Hello, World!
}
Function with Parameters
A function that takes parameters and performs an operation using those parameters.
Example:
package main
import "fmt"
func add(a int, b int) int {
return a + b
}
func main() {
sum := add(3, 4)
fmt.Println("Sum:", sum) // Output: Sum: 7
}
Function with Multiple Return Values
A function can return multiple values, which is a common feature in Go.
Example:
package main
import "fmt"
func swap(a, b int) (int, int) {
return b, a
}
func main() {
x, y := 1, 2
fmt.Println("Before swap:", x, y) // Output: Before swap: 1 2
x, y = swap(x, y)
fmt.Println("After swap:", x, y) // Output: After swap: 2 1
}
Named Return Values
Go allows you to name the return values, which can help in documentation and readability.
Example:
package main
import "fmt"
func divide(a, b int) (quotient int, remainder int) {
quotient = a / b
remainder = a % b
return
}
func main() {
q, r := divide(10, 3)
fmt.Println("Quotient:", q, "Remainder:", r) // Output: Quotient: 3 Remainder: 1
}
Variadic Functions
A variadic function can accept a variable number of arguments.
Example:
package main
import "fmt"
func sum(numbers ...int) int {
total := 0
for _, number := range numbers {
total += number
}
return total
}
func main() {
fmt.Println("Sum:", sum(1, 2, 3, 4)) // Output: Sum: 10
}
Anonymous Functions
Go supports anonymous functions, which are functions without a name. They can be defined inline and used as function literals.
Example:
package main
import "fmt"
func main() {
func() {
fmt.Println("Hello from an anonymous function!")
}() // Output: Hello from an anonymous function!
add := func(a, b int) int {
return a + b
}
fmt.Println("Sum:", add(3, 4)) // Output: Sum: 7
}
Higher-Order Functions
Functions can take other functions as parameters and return functions.
Example:
package main
import "fmt"
func apply(fn func(int, int) int, a, b int) int {
return fn(a, b)
}
func main() {
add := func(a, b int) int {
return a + b
}
fmt.Println("Result:", apply(add, 3, 4)) // Output: Result: 7
}
Conclusion
Functions in Go are powerful tools for organizing and reusing code. By understanding how to define and use functions with parameters, return values, multiple return values, named return values, variadic functions, anonymous functions, and higher-order functions, you can write more modular, readable, and maintainable code. Functions help break down complex problems into smaller, manageable pieces and promote code reuse across your programs.