Functions and methods are the building blocks of Go programs. Here’s an overview of how they work in Go:
1. Functions: A function is a block of code that performs a specific task. Functions in Go are declared using the `func` keyword, followed by the function name, parameter list, return type (if any), and function body. For example:
``
func add(a, b int) int {
return a + b
}
This function takes two integer parameters and returns their sum.
2. Methods: A method is a function that is associated with a specific type. Methods in Go are declared in a similar way to functions, but with an extra parameter for the receiver type. For example:
`
type Rectangle struct {
width, height float64
}
func (r Rectangle) area() float64 {
return r.width * r.height
}
`
This method is associated with the `Rectangle` type and calculates the area of a rectangle.
3. Variadic functions: A variadic function is a function that can take a variable number of arguments. Variadic functions in Go are declared using the `…` operator before the parameter type. For example:
`
func sum(nums ...int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}
`
This function takesa variable number of integer arguments and returns their sum.
4. Anonymous functions: An anonymous function is a function without a name that can be defined inline. Anonymous functions in Go are created using the `func` keyword, followed by the parameter list and function body. For example:
`
func() {
fmt.Println("Hello, world!")
}()
`
This anonymous function prints “Hello, world!” to the console.
5. Function values: In Go, functions are first-class citizens, which means that they can be assigned to variables and passed as arguments to other functions. For example:
`
add := func(a, b int) int {
return a + b
}
result := add(3, 5) // result is 8
`
This code assigns a function that adds two integers to the variable `add`, and then calls it with the arguments `3` and `5`.
6. Method receivers: In Go, method receivers can be either a value or a pointer. Method receivers that are values are passed by copy, while method receivers that are pointers are passed by reference. For example:
`
type Rectangle struct {
width, height float64
}
func (r *Rectangle) scale(factor float64) {
r.width *= factor
r.height *= factor
}
`
This method scales a rectangle by multiplying its width and height by afactor. The method receiver is a pointer to the `Rectangle` type, so changes made to the receiver inside the method will be reflected outside the method.
Understanding functions and methods is essential for writing effective and efficient Go code. Functions and methods allow you to break down complex tasks into smaller, more manageable pieces, and to reuse code across your program.