Functions in Go

# CHAPTER 9

Functions in Go #

1. Introduction #

2. Learning Objectives #

• Declare and call basic functions.

• Pass parameters into functions.

• Return values from functions.

• Utilize Go's unique feature: Multiple Return Values.

• Understand Variadic functions.

3. Declaring and Calling a Function #

package main
import "fmt"

// 1. Function Declaration
func sayHello() {
    fmt.Println("Hello from a custom function!")
}

func main() {
    // 2. Calling the Function
    sayHello()
    sayHello() // Reusability!
}

4. Parameters and Arguments #

// Takes a string parameter named 'user'
func greetUser(user string) {
    fmt.Printf("Welcome, %s!\n", user)
}

func main() {
    greetUser("Alice") // "Alice" is the argument
    greetUser("Bob")
}

Syntax Shortcut: If multiple parameters share the same type, you only need to write the type once at the end!

// Instead of (a int, b int)
func add(a, b int) {
    fmt.Println("Sum:", a + b)
}

5. Return Values #

// Returns an integer
func multiply(x, y int) int {
    return x * y
}

func main() {
    result := multiply(5, 4)
    fmt.Println("Result is:", result) // Prints 20
}

6. Multiple Return Values (Go's Superpower) #

Go allows functions to return multiple values natively! This is heavily used in Go for Error Handling (returning the result AND an error status).

// Returns two integers
func getMinMax(a, b int) (int, int) {
    if a > b {
        return b, a
    }
    return a, b
}

func main() {
    min, max := getMinMax(100, 5)
    fmt.Printf("Min: %d, Max: %d\n", min, max)
}

7. The Blank Identifier _ #

min, _ := getMinMax(100, 5) // Ignores the max value entirely!
fmt.Println("Only care about min:", min)

8. Named Return Values #

func calculateRectangle(length, width int) (area int, perimeter int) {
    area = length * width
    perimeter = 2 * (length + width)
    return // "Naked return" - automatically returns area and perimeter
}

*Note: Use naked returns sparingly, as they can hurt readability in long functions.*

9. Variadic Functions #

// Accepts any number of integers
func sumAll(numbers ...int) int {
    total := 0
    // numbers is treated as a Slice (Array)
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    fmt.Println(sumAll(1, 2, 3))       // 6
    fmt.Println(sumAll(10, 20, 30, 40)) // 100
}

*(Fun Fact: fmt.Println is a variadic function, which is why you can pass it infinite arguments separated by commas!)*

10. Common Mistakes #

• Forgetting to return: If your function signature promises an int (func getAge() int), you MUST have a return statement that yields an integer.

• Scope Issues: A variable declared inside func A() cannot be seen or used by func B(). This is called Local Scope.

11. Best Practices #

• Single Responsibility Principle: A function should do exactly ONE thing. If it validates a user, saves to the database, and sends an email, break it down into three separate functions.

• Keep functions small: If a function is over 50 lines long, consider refactoring it.

12. Exercises #

1. 1. Write a function called divide that takes two float64 numbers.

1. 2. Have it return the division result. If the second number is 0, return 0 (we will handle proper errors later). Test it in main.

13. MCQs with Answers & Explanations #

14. Interview Preparation #

1. 1. Why does Go support multiple return values, and what is its most common use case? (Answer: Returning the actual result AND an error status simultaneously).

1. 2. Explain what the blank identifier _ is used for in function returns.

15. Summary #

16. Next Chapter Recommendation #