Go Functions
Go Functions
Functions in Go are self-contained blocks of code that perform specific tasks. They allow modular programming, code reusability, and better maintainability. In Go, functions can take arguments, return values, and even be used as first-class citizens.
1. Declaring a Function
A function in Go is defined using the func keyword, followed by the function name, parameters (if any), return type (if applicable), and a code block enclosed in curly braces {}.
Syntax:
func functionName(parameters) returnType {
// Function body
}2. Basic Function Example
package main
import "fmt"
// A function that neither accepts parameters nor returns a value.
func greet() {
fmt.Println("Hello, Go!")
}
func main() {
greet() // Calling the function
}OutPut:
Hello, Go!
3. Function with Parameters
A function can accept input parameters to perform operations dynamically.
Example:
package main
import "fmt"
// Function with two integer parameters
func add(a int, b int) {
sum := a + b
fmt.Println("Sum:", sum)
}
func main() {
add(5, 10) // Calling the function with arguments
}OutPut:
Sum: 15
4. Function with Return Value
A function can utilize the return statement to deliver a value.
Example:
package main
import "fmt"
// Function returning an integer value
func multiply(x int, y int) int {
return x * y
}
func main() {
result := multiply(4, 3) // Function call with return value
fmt.Println("Multiplication:", result)
}OutPut:
Multiplication: 12
5. Multiple Return Values
Go functions can return multiple values, which is useful in various scenarios such as error handling.
Example:
package main
import "fmt"
// Function returning two values
func divide_num(a int, b int) (int, int) {
quotient := a / b
remainder := a % b
return quotient, remainder
}
func main() {
q, r := divide_num(10, 3)
fmt.Println("Quotient:", q, "Remainder:", r)
}OutPut:
Quotient: 3 Remainder: 1
6. Named Return Values
Go allows defining return variables in the function signature itself.
Example:
package main
import "fmt"
// Function with named return values
func rectangle(dim1 int, dim2 int) (area int, perimeter int) {
area = dim1 * dim2
perimeter = 2 * (dim1 + dim2)
return // Implicit/Automatically return of named values
}
func main() {
a, p := rectangle(5, 3)
fmt.Println("Area:", a, "Perimeter:", p)
}OutPut:
Area: 15 Perimeter: 16
7. Variadic Functions
Go supports functions with a variable number of arguments using ... syntax.
package main
import "fmt"
// Function accepting variable number of integers
func sum(numbers ...int) int {
total := 0
for _, num := range numbers {
total += num
}
return total
}
func main() {
result_sum := sum_num(1, 2, 3, 4, 5)
fmt.Println("Total Sum:", result_sum)
}OutPut:
Total Sum: 15
8. Anonymous Functions
Functions can be defined without names, often used for short-lived operations.
Example:
package main
import "fmt"
func main() {
// Anonymous function
func() {
fmt.Println("This is an anonymous function")
}() // Immediate execution
}OutPut:
This is an anonymous function
9. Functions as Values
Go allows assigning functions to variables and passing them as arguments.
Example:
package main
import "fmt"
func message() {
fmt.Println("Hello from function variable!")
}
func main() {
greet := message // Assign function to variable
greet() // Invoke function via variable
}OutPut:
Hello from function variable!
10. Higher-Order Functions
Functions can take other functions as inputs or return them as outputs.
Example:
package main
import "fmt"
// A function that receives another function as an argument.
func operate(a int, b int, operation func(int, int) int) int {
return operation(a, b)
}
func main() {
add := func(x, y int) int {
return x + y
}
result := operate(7, 3, add)
fmt.Println("Result:", result)
}OutPut:
Result: 10
11. Closures
A function that references variables outside its scope is called a closure.
Example:
package main
import "fmt"
func counter() func() int {
count := 0
return func() int {
count++
return count
}
}
func main() {
increment := counter()
fmt.Println(increment()) // 1
fmt.Println(increment()) // 2
}OutPut:
1 2
12. Defer in Functions
The defer statement postpones function execution until surrounding function exits.
Example:
package main
import "fmt"
func main() {
defer fmt.Println("This is executed last")
fmt.Println("This executes first")
}OutPut:
This executes first This is executed last
Conclusion
Go functions are powerful, enabling clean and structured programming. By leveraging features like multiple return values, closures, and function variables, Go developers can write efficient and readable code.
Prefer Learning by Watching?
Watch these YouTube tutorials to understand GO Tutorial visually:
What You'll Learn:
- 📌 Functions in Go | Golang
- 📌 Go (Golang) Tutorial #9 - Using Functions