The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Functions

Next ►
►

Functions are fundamental building blocks in Go programming. They allow you to encapsulate code into reusable blocks, making your programs more modular and easier to maintain. In this section, we will cover the basics of defining and using functions in Go, including function parameters, return values, and more advanced topics like variadic functions and anonymous functions.

Key Concepts

  1. Function Definition
  2. Function Parameters
  3. Return Values
  4. Named Return Values
  5. Variadic Functions
  6. Anonymous Functions
  7. Higher-Order Functions

Function Definition

A function in Go is defined using the func keyword, followed by the function name, parameters (if any), return type (if any), and the function body.

Syntax

func functionName(parameterList) returnType {
    // function body
}

Example

package main

import "fmt"

// Function definition
func greet(name string) string {
    return "Hello, " + name
}

func main() {
    // Function call
    message := greet("Alice")
    fmt.Println(message) // Output: Hello, Alice
}

Explanation

  • func greet(name string) string defines a function named greet that takes a single parameter name of type string and returns a string.
  • The function body contains the code that will be executed when the function is called.
  • greet("Alice") calls the function with the argument "Alice".

Function Parameters

Functions can take zero or more parameters. Parameters are specified in the parentheses following the function name.

Example

package main

import "fmt"

func add(a int, b int) int {
    return a + b
}

func main() {
    sum := add(3, 4)
    fmt.Println(sum) // Output: 7
}

Explanation

  • func add(a int, b int) int defines a function named add that takes two parameters a and b, both of type int, and returns an int.
  • add(3, 4) calls the function with the arguments 3 and 4.

Return Values

Functions can return zero or more values. The return type(s) are specified after the parameter list.

Example

package main

import "fmt"

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result) // Output: Result: 5
    }
}

Explanation

  • func divide(a, b float64) (float64, error) defines a function named divide that takes two float64 parameters and returns a float64 and an error.
  • The function checks if b is zero and returns an error if true. Otherwise, it returns the result of the division and nil for the error.

Named Return Values

Go allows you to name the return values, which can make the code more readable and self-documenting.

Example

package main

import "fmt"

func swap(x, y string) (first, second string) {
    first = y
    second = x
    return
}

func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b) // Output: world hello
}

Explanation

  • func swap(x, y string) (first, second string) defines a function with named return values first and second.
  • The named return values are assigned within the function body and returned implicitly.

Variadic Functions

Variadic functions can accept a variable number of arguments. The syntax uses ... before the type of the last parameter.

Example

package main

import "fmt"

func sum(numbers ...int) int {
    total := 0
    for _, number := range numbers {
        total += number
    }
    return total
}

func main() {
    result := sum(1, 2, 3, 4, 5)
    fmt.Println(result) // Output: 15
}

Explanation

  • func sum(numbers ...int) int defines a variadic function that takes a variable number of int arguments.
  • The function iterates over the numbers slice and calculates the total sum.

Anonymous Functions

Anonymous functions are functions without a name. They are often used as function literals or closures.

Example

package main

import "fmt"

func main() {
    add := func(a, b int) int {
        return a + b
    }

    result := add(3, 4)
    fmt.Println(result) // Output: 7
}

Explanation

  • add := func(a, b int) int { return a + b } defines an anonymous function and assigns it to the variable add.
  • The anonymous function is then called using add(3, 4).

Higher-Order Functions

Higher-order functions are functions that take other functions as parameters or return functions.

Example

package main

import "fmt"

func applyOperation(a, b int, operation func(int, int) int) int {
    return operation(a, b)
}

func main() {
    add := func(a, b int) int {
        return a + b
    }

    result := applyOperation(3, 4, add)
    fmt.Println(result) // Output: 7
}

Explanation

  • func applyOperation(a, b int, operation func(int, int) int) int defines a higher-order function that takes two int parameters and a function operation as parameters.
  • The applyOperation function calls the operation function with a and b.

Practical Exercises

Exercise 1: Simple Calculator

Write a function calculator that takes two integers and a string representing an operation ("add", "subtract", "multiply", "divide") and returns the result of the operation.

Solution

package main

import "fmt"

func calculator(a, b int, operation string) (int, error) {
    switch operation {
    case "add":
        return a + b, nil
    case "subtract":
        return a - b, nil
    case "multiply":
        return a * b, nil
    case "divide":
        if b == 0 {
            return 0, fmt.Errorf("division by zero")
        }
        return a / b, nil
    default:
        return 0, fmt.Errorf("unknown operation")
    }
}

func main() {
    result, err := calculator(10, 5, "add")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result) // Output: Result: 15
    }
}

Exercise 2: Variadic Average

Write a variadic function average that calculates the average of a variable number of float64 numbers.

Solution

package main

import "fmt"

func average(numbers ...float64) float64 {
    total := 0.0
    for _, number := range numbers {
        total += number
    }
    return total / float64(len(numbers))
}

func main() {
    result := average(1.0, 2.0, 3.0, 4.0, 5.0)
    fmt.Println(result) // Output: 3
}

Summary

In this section, we covered the basics of functions in Go, including:

  • Function definition and syntax
  • Function parameters and return values
  • Named return values
  • Variadic functions
  • Anonymous functions
  • Higher-order functions

Understanding these concepts will help you write more modular and reusable code. In the next module, we will delve into advanced data structures like arrays, slices, maps, and structs.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved