Defining Functions in Go

List Topics
February 15, 2025
No Comments
7 min read

In Go, functions are essential building blocks that allow code reusability and modular programming.

1. Syntax of a Function in Go

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

Basic Syntax:

Go
func functionName(parameters) returnType {
    // Function body
}

Example of a Simple Function

Go
package main

import "fmt"

func greet() {
    fmt.Println("Hello, Welcome to Go!")
}

func main() {
    greet()  // Calling the function
}

🔹 Output:

Bash
Hello, Welcome to Go!

2. Function with Parameters

Functions can accept parameters to work with input values.

Example: Function with One Parameter

Go
package main

import "fmt"

func greet(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    greet("Alice") // Passing argument "Alice"
}

🔹 Output:

Bash
Hello, Alice

3. Function with Multiple Parameters

A function can take multiple parameters separated by commas.

Example: Function with Two Parameters

Go
package main

import "fmt"

func add(a int, b int) {
    sum := a + b
    fmt.Println("Sum:", sum)
}

func main() {
    add(5, 10)  // Passing values 5 and 10
}

🔹 Output:

Bash
Sum: 15

👉 Shortcut for Same Type Parameters:
If parameters have the same type, you can omit repeating the type:

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

4. Function with Return Value

Functions can return values using the return statement.

Example: Function Returning a Value

Go
package main

import "fmt"

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

func main() {
    result := add(10, 20)
    fmt.Println("Result:", result)
}

🔹 Output:

Bash
Result: 30

5. Multiple Return Values

Go allows functions to return multiple values.

Example: Returning Two Values

Go
package main

import "fmt"

func calculate(a, b int) (int, int) {
    sum := a + b
    product := a * b
    return sum, product
}

func main() {
    s, p := calculate(4, 5)
    fmt.Println("Sum:", s)
    fmt.Println("Product:", p)
}

🔹 Output:

Bash
Sum: 9
Product: 20

👉 Ignoring a Return Value:
If you don’t need one of the return values, use _ (blank identifier).

Go
s, _ := calculate(4, 5)  // Ignores product
fmt.Println("Sum:", s)

6. Named Return Values

You can name return values in the function signature, and Go will automatically return them.

Example: Named Return Values

Go
package main

import "fmt"

func calculate(a, b int) (sum int, product int) {
    sum = a + b
    product = a * b
    return  // No need to explicitly return variables
}

func main() {
    s, p := calculate(3, 7)
    fmt.Println("Sum:", s)
    fmt.Println("Product:", p)
}

🔹 Output:

Bash
Sum: 10
Product: 21

7. Variadic Functions (Multiple Arguments)

A variadic function can accept any number of arguments.

Example: Variadic Function

Go
package main

import "fmt"

func sum(numbers ...int) {
    total := 0
    for _, num := range numbers {
        total += num
    }
    fmt.Println("Total Sum:", total)
}

func main() {
    sum(1, 2, 3, 4, 5)  // Passing multiple arguments
}

🔹 Output:

Bash
Total Sum: 15

👉 ...int means the function can accept any number of integers.

8. Function as a Value

Functions in Go are first-class citizens, meaning they can be assigned to variables and passed as arguments.

Example: Assigning Function to a Variable

Go
package main

import "fmt"

func greet(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    var sayHello func(string) = greet  // Assign function to variable
    sayHello("Bob")  // Calling the function via variable
}

🔹 Output:

Bash
Hello, Bob

9. Function as an Argument

A function can be passed as a parameter to another function.

Example: Passing Function as an Argument

Go
package main

import "fmt"

func printMessage(msg string) {
    fmt.Println(msg)
}

func executeFunction(f func(string), message string) {
    f(message)
}

func main() {
    executeFunction(printMessage, "Go is Awesome!")
}

🔹 Output:

Bash
Go is Awesome!

10. Anonymous Functions (Lambda Functions)

Go allows defining functions without a name (Anonymous Functions).

Example: Anonymous Function

Go
package main

import "fmt"

func main() {
    greet := func(name string) {
        fmt.Println("Hello,", name)
    }

    greet("Charlie")
}

🔹 Output:

Bash
Hello, Charlie

11. Closures in Go

A closure is an anonymous function that captures variables from its surrounding scope.

Example: Closure

Go
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:

Bash
1
2

👉 The anonymous function remembers count even after counter() exits.

Conclusion: Key Takeaways

FeatureDescription
Basic FunctionUses func keyword, has parameters and return values
Multiple ParametersAllows passing multiple inputs
Return ValuesFunctions can return single or multiple values
Named Return ValuesPredefined return variable names
Variadic FunctionsAccepts multiple arguments using ...
Function as ValueAssign functions to variables
Function as ArgumentPass functions to other functions
Anonymous FunctionFunction without a name
ClosuresFunctions that capture outer scope variables

🚀 Go functions make code modular, reusable, and efficient!

āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĄāĻŋāĻĢāĻŋāĻ¨āĻŋāĻļāĻ¨ (Function Definition)

Go-āĻ¤ā§‡ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻšāĻ˛ āĻ•ā§‹āĻĄ āĻĒā§āĻ¨āĻƒāĻŦā§āĻ¯āĻŦāĻšāĻžāĻ°āĻ¯ā§‹āĻ—ā§āĻ¯ āĻ•āĻ°āĻžāĻ° āĻāĻ•āĻŸāĻŋ āĻ—ā§āĻ°ā§āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻ…āĻ‚āĻļāĨ¤ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°ā§‡ āĻ•ā§‹āĻĄāĻ•ā§‡ āĻ›ā§‹āĻŸ āĻ›ā§‹āĻŸ āĻ…āĻ‚āĻļā§‡ āĻ­āĻžāĻ— āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧ, āĻ¯āĻž āĻĒā§āĻ°ā§‹āĻ—ā§āĻ°āĻžāĻŽāĻŋāĻ‚āĻ•ā§‡ āĻ¸āĻšāĻœ āĻ“ āĻ•āĻžāĻ°ā§āĻ¯āĻ•āĻ° āĻ•āĻ°ā§‡ āĻ¤ā§‹āĻ˛ā§‡āĨ¤

1. āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻ¸āĻžāĻ§āĻžāĻ°āĻŖ āĻ—āĻ āĻ¨ (Syntax of a Function)

āĻāĻ•āĻŸāĻŋ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĄāĻŋāĻĢāĻžāĻ‡āĻ¨ āĻ•āĻ°āĻ¤ā§‡ func āĻ•ā§€āĻ“āĻ¯āĻŧāĻžāĻ°ā§āĻĄ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻšāĻ¯āĻŧāĨ¤

✅ āĻ¸āĻžāĻ§āĻžāĻ°āĻŖ āĻ—āĻ āĻ¨ (Syntax)

Go
func functionName(parameters) returnType {
    // āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻ•āĻžāĻœ āĻāĻ–āĻžāĻ¨ā§‡ āĻ˛ā§‡āĻ–āĻž āĻšāĻŦā§‡
}

✅ āĻ¸āĻšāĻœ āĻāĻ•āĻŸāĻŋ āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻ‰āĻĻāĻžāĻšāĻ°āĻŖ

Go
package main

import "fmt"

func greet() {
    fmt.Println("āĻšā§āĻ¯āĻžāĻ˛ā§‹, āĻ—ā§‹ āĻ­āĻžāĻˇāĻžāĻ¯āĻŧ āĻ¸ā§āĻŦāĻžāĻ—āĻ¤āĻŽ!")
}

func main() {
    greet()  // āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ•āĻ˛ āĻ•āĻ°āĻž āĻšāĻ˛ā§‹
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻšā§āĻ¯āĻžāĻ˛ā§‹, āĻ—ā§‹ āĻ­āĻžāĻˇāĻžāĻ¯āĻŧ āĻ¸ā§āĻŦāĻžāĻ—āĻ¤āĻŽ!

2. āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻ¸āĻš āĻĢāĻžāĻ‚āĻļāĻ¨ (Function with Parameters)

āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻ¨āĻŋāĻ¤ā§‡ āĻĒāĻžāĻ°ā§‡, āĻ¯āĻž āĻ‡āĻ¨āĻĒā§āĻŸ āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻšāĻ¯āĻŧāĨ¤

✅ āĻāĻ•āĻ• āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻ¸āĻš āĻĢāĻžāĻ‚āĻļāĻ¨

Go
package main

import "fmt"

func greet(name string) {
    fmt.Println("āĻšā§āĻ¯āĻžāĻ˛ā§‹,", name)
}

func main() {
    greet("āĻ†āĻ˛āĻŋāĻĢ") // "āĻ†āĻ˛āĻŋāĻĢ" āĻ‡āĻ¨āĻĒā§āĻŸ āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻĒāĻžāĻ āĻžāĻ¨ā§‹ āĻšāĻ˛ā§‹
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻšā§āĻ¯āĻžāĻ˛ā§‹, āĻ†āĻ˛āĻŋāĻĢ

3. āĻāĻ•āĻžāĻ§āĻŋāĻ• āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻ¸āĻš āĻĢāĻžāĻ‚āĻļāĻ¨ (Multiple Parameters)

āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡ āĻāĻ•āĻžāĻ§āĻŋāĻ• āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻĨāĻžāĻ•āĻ¤ā§‡ āĻĒāĻžāĻ°ā§‡āĨ¤

✅ āĻĻā§āĻ‡āĻŸāĻŋ āĻ¸āĻ‚āĻ–ā§āĻ¯āĻž āĻ¯ā§‹āĻ— āĻ•āĻ°āĻžāĻ° āĻĢāĻžāĻ‚āĻļāĻ¨

Go
package main

import "fmt"

func add(a int, b int) {
    sum := a + b
    fmt.Println("āĻ¯ā§‹āĻ—āĻĢāĻ˛:", sum)
}

func main() {
    add(10, 20)
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻ¯ā§‹āĻ—āĻĢāĻ˛: 30

👉 āĻ¸āĻ‚āĻ•ā§āĻˇāĻŋāĻĒā§āĻ¤āĻ­āĻžāĻŦā§‡ āĻŸāĻžāĻ‡āĻĒ āĻ‰āĻ˛ā§āĻ˛ā§‡āĻ– āĻ•āĻ°āĻž:

Go
func add(a, b int) {
    fmt.Println("āĻ¯ā§‹āĻ—āĻĢāĻ˛:", a+b)
}

4. āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ­ā§āĻ¯āĻžāĻ˛ā§ āĻ¸āĻš āĻĢāĻžāĻ‚āĻļāĻ¨ (Function with Return Value)

āĻāĻ•āĻŸāĻŋ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ­ā§āĻ¯āĻžāĻ˛ā§ āĻĻāĻŋāĻ¤ā§‡ āĻĒāĻžāĻ°ā§‡āĨ¤

✅ āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ­ā§āĻ¯āĻžāĻ˛ā§ āĻ¸āĻš āĻĢāĻžāĻ‚āĻļāĻ¨

Go
package main

import "fmt"

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

func main() {
    result := add(15, 25)
    fmt.Println("āĻĢāĻ˛āĻžāĻĢāĻ˛:", result)
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻĢāĻ˛āĻžāĻĢāĻ˛: 40

5. āĻāĻ•āĻžāĻ§āĻŋāĻ• āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ­ā§āĻ¯āĻžāĻ˛ā§ (Multiple Return Values)

āĻāĻ•āĻŸāĻŋ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻāĻ•āĻžāĻ§āĻŋāĻ• āĻŽāĻžāĻ¨ āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ•āĻ°āĻ¤ā§‡ āĻĒāĻžāĻ°ā§‡āĨ¤

✅ āĻ‰āĻĻāĻžāĻšāĻ°āĻŖ: āĻ¯ā§‹āĻ—āĻĢāĻ˛ āĻ“ āĻ—ā§āĻŖāĻĢāĻ˛ āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ•āĻ°āĻž

Go
package main

import "fmt"

func calculate(a, b int) (int, int) {
    sum := a + b
    product := a * b
    return sum, product
}

func main() {
    s, p := calculate(4, 5)
    fmt.Println("āĻ¯ā§‹āĻ—āĻĢāĻ˛:", s)
    fmt.Println("āĻ—ā§āĻŖāĻĢāĻ˛:", p)
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻ¯ā§‹āĻ—āĻĢāĻ˛: 9
āĻ—ā§āĻŖāĻĢāĻ˛: 20

👉 āĻ•ā§‹āĻ¨ā§‹ āĻāĻ•āĻŸāĻŋ āĻŽāĻžāĻ¨ āĻ‰āĻĒā§‡āĻ•ā§āĻˇāĻž āĻ•āĻ°āĻ¤ā§‡ āĻšāĻžāĻ‡āĻ˛ā§‡ _ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻšāĻ¯āĻŧ:

Go
s, _ := calculate(4, 5)  // āĻļā§āĻ§ā§ āĻ¯ā§‹āĻ—āĻĢāĻ˛ āĻ°āĻžāĻ–āĻŦā§‹
fmt.Println("āĻ¯ā§‹āĻ—āĻĢāĻ˛:", s)

6. āĻ¨ā§‡āĻŽāĻĄ āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ­ā§āĻ¯āĻžāĻ˛ā§ (Named Return Values)

āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ­ā§āĻ¯āĻžāĻ˛ā§āĻ—ā§āĻ˛ā§‹ āĻ¨āĻžāĻŽ āĻĻā§‡āĻ“āĻ¯āĻŧāĻž āĻ¯āĻžāĻ¯āĻŧ, āĻāĻ¤ā§‡ āĻ†āĻ˛āĻžāĻĻāĻž āĻ•āĻ°ā§‡ return āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻ¤ā§‡ āĻšāĻ¯āĻŧ āĻ¨āĻžāĨ¤

✅ āĻ‰āĻĻāĻžāĻšāĻ°āĻŖ: āĻ¨ā§‡āĻŽāĻĄ āĻ°āĻŋāĻŸāĻžāĻ°ā§āĻ¨ āĻ­ā§āĻ¯āĻžāĻ˛ā§

Go
package main

import "fmt"

func calculate(a, b int) (sum int, product int) {
    sum = a + b
    product = a * b
    return  // āĻ†āĻ˛āĻžāĻĻāĻž āĻ•āĻ°ā§‡ return sum, product āĻ˛ā§‡āĻ–āĻžāĻ° āĻĻāĻ°āĻ•āĻžāĻ° āĻ¨ā§‡āĻ‡
}

func main() {
    s, p := calculate(3, 7)
    fmt.Println("āĻ¯ā§‹āĻ—āĻĢāĻ˛:", s)
    fmt.Println("āĻ—ā§āĻŖāĻĢāĻ˛:", p)
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻ¯ā§‹āĻ—āĻĢāĻ˛: 10
āĻ—ā§āĻŖāĻĢāĻ˛: 21

7. āĻĒāĻ°āĻŋāĻŦāĻ°ā§āĻ¤āĻ¨āĻļā§€āĻ˛ āĻ¸āĻ‚āĻ–ā§āĻ¯āĻž āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° (Variadic Functions)

āĻ•ā§‹āĻ¨ā§‹ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ…āĻ¨āĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āĻŸ āĻ¸āĻ‚āĻ–ā§āĻ¯āĻ• āĻ‡āĻ¨āĻĒā§āĻŸ āĻ—ā§āĻ°āĻšāĻŖ āĻ•āĻ°āĻ¤ā§‡ āĻĒāĻžāĻ°ā§‡, āĻāĻ•ā§‡ variadic function āĻŦāĻ˛ā§‡āĨ¤

✅ āĻ‰āĻĻāĻžāĻšāĻ°āĻŖ: āĻ¯ā§‡ āĻ•ā§‹āĻ¨ā§‹ āĻ¸āĻ‚āĻ–ā§āĻ¯āĻ• āĻ‡āĻ¨āĻĒā§āĻŸ āĻ—ā§āĻ°āĻšāĻŖ āĻ•āĻ°āĻž āĻĢāĻžāĻ‚āĻļāĻ¨

Go
package main

import "fmt"

func sum(numbers ...int) {
    total := 0
    for _, num := range numbers {
        total += num
    }
    fmt.Println("āĻŽā§‹āĻŸ āĻ¯ā§‹āĻ—āĻĢāĻ˛:", total)
}

func main() {
    sum(1, 2, 3, 4, 5)  // āĻāĻ•āĻžāĻ§āĻŋāĻ• āĻŽāĻžāĻ¨ āĻĒāĻžāĻ āĻžāĻ¨ā§‹ āĻšāĻ˛ā§‹
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻŽā§‹āĻŸ āĻ¯ā§‹āĻ—āĻĢāĻ˛: 15

👉 ...int āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°ā§‡ āĻāĻ•āĻžāĻ§āĻŋāĻ• āĻ¸āĻ‚āĻ–ā§āĻ¯āĻž āĻĒāĻžāĻ āĻžāĻ¨ā§‹ āĻ¯āĻžāĻ¯āĻŧāĨ¤

8. āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ āĻšāĻŋāĻ¸āĻžāĻŦā§‡ (Function as a Value)

āĻĢāĻžāĻ‚āĻļāĻ¨āĻ•ā§‡ āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻ¸āĻ‚āĻ°āĻ•ā§āĻˇāĻŖ āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧ āĻāĻŦāĻ‚ āĻĒā§āĻ°āĻ¯āĻŧā§‹āĻœāĻ¨ā§‡ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧāĨ¤

✅ āĻ‰āĻĻāĻžāĻšāĻ°āĻŖ: āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ āĻšāĻŋāĻ¸āĻžāĻŦā§‡ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž

Go
package main

import "fmt"

func greet(name string) {
    fmt.Println("āĻšā§āĻ¯āĻžāĻ˛ā§‹,", name)
}

func main() {
    var sayHello func(string) = greet
    sayHello("āĻ°āĻĢāĻŋāĻ•")
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻšā§āĻ¯āĻžāĻ˛ā§‹, āĻ°āĻĢāĻŋāĻ•

9. āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ†āĻ°ā§āĻ—ā§āĻŽā§‡āĻ¨ā§āĻŸ āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ (Function as an Argument)

āĻĢāĻžāĻ‚āĻļāĻ¨āĻ•ā§‡ āĻ…āĻ¨ā§āĻ¯ āĻāĻ•āĻŸāĻŋ āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻĒāĻžāĻ āĻžāĻ¨ā§‹ āĻ¯āĻžāĻ¯āĻŧāĨ¤

✅ āĻ‰āĻĻāĻžāĻšāĻ°āĻŖ: āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻšāĻŋāĻ¸āĻžāĻŦā§‡ āĻĒāĻžāĻ āĻžāĻ¨ā§‹

Go
package main

import "fmt"

func printMessage(msg string) {
    fmt.Println(msg)
}

func executeFunction(f func(string), message string) {
    f(message)
}

func main() {
    executeFunction(printMessage, "āĻ—ā§‹ āĻ­āĻžāĻˇāĻž āĻ…āĻ¸āĻžāĻ§āĻžāĻ°āĻŖ!")
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻ—ā§‹ āĻ­āĻžāĻˇāĻž āĻ…āĻ¸āĻžāĻ§āĻžāĻ°āĻŖ!

10. āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ (Anonymous Function)

āĻ¯ā§‡ āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻ•ā§‹āĻ¨ā§‹ āĻ¨āĻžāĻŽ āĻ¨ā§‡āĻ‡, āĻ¤āĻžāĻ•ā§‡ anonymous function āĻŦāĻ˛ā§‡āĨ¤

✅ āĻ‰āĻĻāĻžāĻšāĻ°āĻŖ: āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨

Go
package main

import "fmt"

func main() {
    greet := func(name string) {
        fmt.Println("āĻšā§āĻ¯āĻžāĻ˛ā§‹,", name)
    }

    greet("āĻ¨āĻžāĻˆāĻŽ")
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻšā§āĻ¯āĻžāĻ˛ā§‹, āĻ¨āĻžāĻˆāĻŽ<br><br>

11. āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ (Anonymous Function) – āĻŦāĻŋāĻ¸ā§āĻ¤āĻžāĻ°āĻŋāĻ¤ āĻŦā§āĻ¯āĻžāĻ–ā§āĻ¯āĻž

āĻāĻ•āĻŸāĻŋ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ (Anonymous Function) āĻšāĻ˛ āĻāĻŽāĻ¨ āĻāĻ•āĻŸāĻŋ āĻĢāĻžāĻ‚āĻļāĻ¨, āĻ¯āĻžāĻ° āĻ•ā§‹āĻ¨ā§‹ āĻ¨āĻžāĻŽ āĻ¨ā§‡āĻ‡āĨ¤ āĻāĻŸāĻŋ āĻ¸āĻžāĻ§āĻžāĻ°āĻŖāĻ¤ āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ā§‡ āĻ¸āĻ‚āĻ°āĻ•ā§āĻˇāĻŖ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧ āĻŦāĻž āĻ…āĻ¨ā§āĻ¯ āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻ­ā§‡āĻ¤āĻ°ā§‡ āĻ‡āĻ¨āĻ˛āĻžāĻ‡āĻ¨āĻ­āĻžāĻŦā§‡ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻšāĻ¯āĻŧāĨ¤

✅ āĻ¸āĻžāĻ§āĻžāĻ°āĻŖ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨

Go
package main

import "fmt"

func main() {
    greet := func(name string) {
        fmt.Println("āĻšā§āĻ¯āĻžāĻ˛ā§‹,", name)
    }

    greet("āĻ¨āĻžāĻˆāĻŽ") // āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ•āĻ˛ āĻ•āĻ°āĻž āĻšāĻ˛ā§‹
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻšā§āĻ¯āĻžāĻ˛ā§‹, āĻ¨āĻžāĻˆāĻŽ

👉 āĻāĻ–āĻžāĻ¨ā§‡ greet āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ā§‡ āĻāĻ•āĻŸāĻŋ āĻ¨āĻžāĻŽāĻšā§€āĻ¨ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ¸āĻ‚āĻ°āĻ•ā§āĻˇāĻŖ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡ āĻāĻŦāĻ‚ āĻĒāĻ°ā§‡ āĻ¸ā§‡āĻŸāĻŋ āĻ•āĻ˛ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡āĨ¤

āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ā§‡āĻ° āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° (Uses of Anonymous Functions)

1ī¸âƒŖ āĻ¸āĻžāĻĨā§‡ āĻ¸āĻžāĻĨā§‡ āĻ•āĻ˛ āĻ•āĻ°āĻž (Immediately Invoked Function Expression - IIFE)

āĻāĻ•āĻŸāĻŋ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ¸āĻžāĻĨā§‡āĻ¸āĻžāĻĨā§‡ āĻ•āĻ˛ āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧāĨ¤

Go
package main

import "fmt"

func main() {
    func() {
        fmt.Println("āĻāĻ‡ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ¸āĻžāĻĨā§‡ āĻ¸āĻžāĻĨā§‡ āĻ•āĻ˛ āĻšāĻ¯āĻŧā§‡āĻ›ā§‡!")
    }()
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻāĻ‡ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ¸āĻžāĻĨā§‡ āĻ¸āĻžāĻĨā§‡ āĻ•āĻ˛ āĻšāĻ¯āĻŧā§‡āĻ›ā§‡!

👉 āĻāĻ–āĻžāĻ¨ā§‡ āĻĢāĻžāĻ‚āĻļāĻ¨ () āĻĻāĻŋāĻ¯āĻŧā§‡ āĻāĻ•ā§āĻ¸āĻŋāĻ•āĻŋāĻ‰āĻŸ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡, āĻ¤āĻžāĻ‡ āĻāĻŸāĻŋ āĻĄāĻŋāĻ•ā§āĻ˛āĻžāĻ°ā§‡āĻļāĻ¨ā§‡āĻ° āĻ¸āĻžāĻĨā§‡ āĻ¸āĻžāĻĨā§‡ āĻšāĻ˛ā§‡ āĻ¯āĻžāĻŦā§‡āĨ¤

2ī¸âƒŖ āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ°āĻ¸āĻš IIFE āĻĢāĻžāĻ‚āĻļāĻ¨

Go
package main

import "fmt"

func main() {
    func(name string) {
        fmt.Println("āĻšā§āĻ¯āĻžāĻ˛ā§‹,", name)
    }("āĻ†āĻ°āĻŋāĻĢ") // āĻ¸āĻžāĻĨā§‡ āĻ¸āĻžāĻĨā§‡ āĻ•āĻ˛ āĻšāĻšā§āĻ›ā§‡, "āĻ†āĻ°āĻŋāĻĢ" āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻĻā§‡āĻ“āĻ¯āĻŧāĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻšā§āĻ¯āĻžāĻ˛ā§‹, āĻ†āĻ°āĻŋāĻĢ

👉 āĻāĻ–āĻžāĻ¨ā§‡ āĻ¨āĻžāĻŽāĻšā§€āĻ¨ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĄāĻŋāĻĢāĻžāĻ‡āĻ¨ āĻ•āĻ°ā§‡āĻ‡ āĻ¸āĻžāĻĨā§‡ āĻ¸āĻžāĻĨā§‡ "āĻ†āĻ°āĻŋāĻĢ" āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻĻāĻŋāĻ¯āĻŧā§‡ āĻ•āĻ˛ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡āĨ¤

3ī¸âƒŖ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ā§‡ āĻ°āĻžāĻ–āĻž āĻāĻŦāĻ‚ āĻĒā§āĻ¨āĻ°āĻžāĻ¯āĻŧ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž

Go
package main

import "fmt"

func main() {
    multiply := func(a, b int) int {
        return a * b
    }

    result := multiply(5, 6)
    fmt.Println("āĻ—ā§āĻŖāĻĢāĻ˛:", result)
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻ—ā§āĻŖāĻĢāĻ˛: 30

👉 āĻāĻ–āĻžāĻ¨ā§‡ multiply āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ā§‡ āĻāĻ•āĻŸāĻŋ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ¸āĻ‚āĻ°āĻ•ā§āĻˇāĻŖ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡ āĻāĻŦāĻ‚ āĻĒāĻ°ā§‡ multiply(5, 6) āĻ•āĻ˛ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡āĨ¤

4ī¸âƒŖ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĒāĻžāĻ āĻžāĻ¨ā§‹

Go
package main

import "fmt"

func execute(f func(int, int) int, x int, y int) {
    fmt.Println("āĻĢāĻ˛āĻžāĻĢāĻ˛:", f(x, y))
}

func main() {
    execute(func(a, b int) int {
        return a + b
    }, 10, 20)
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻĢāĻ˛āĻžāĻĢāĻ˛: 30

👉 āĻāĻ–āĻžāĻ¨ā§‡ execute āĻĢāĻžāĻ‚āĻļāĻ¨ āĻāĻ•āĻŸāĻŋ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ‡āĻ¨āĻĒā§āĻŸ āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻ—ā§āĻ°āĻšāĻŖ āĻ•āĻ°ā§‡āĻ›ā§‡, āĻ¯ā§‡āĻ–āĻžāĻ¨ā§‡ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĒāĻžāĻ¸ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧā§‡āĻ›ā§‡āĨ¤

5ī¸âƒŖ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°ā§‡ Go āĻ°ā§āĻŸāĻŋāĻ¨ (Concurrency with Goroutines)

Go
package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        fmt.Println("āĻ—ā§‹ āĻ°ā§āĻŸāĻŋāĻ¨ āĻĻāĻŋāĻ¯āĻŧā§‡ āĻ†āĻ˛āĻžāĻĻāĻž āĻĨā§āĻ°ā§‡āĻĄā§‡ āĻšāĻžāĻ˛āĻžāĻ¨ā§‹ āĻšāĻšā§āĻ›ā§‡!")
    }()
    
    time.Sleep(time.Second) // āĻ…āĻĒā§‡āĻ•ā§āĻˇāĻž āĻ¨āĻž āĻ•āĻ°āĻ˛ā§‡ āĻĒā§āĻ°ā§‹āĻ—ā§āĻ°āĻžāĻŽ āĻļā§‡āĻˇ āĻšāĻ¯āĻŧā§‡ āĻ¯āĻžāĻŦā§‡
}

🔹 āĻ†āĻ‰āĻŸāĻĒā§āĻŸ:

Bash
āĻ—ā§‹ āĻ°ā§āĻŸāĻŋāĻ¨ āĻĻāĻŋāĻ¯āĻŧā§‡ āĻ†āĻ˛āĻžāĻĻāĻž āĻĨā§āĻ°ā§‡āĻĄā§‡ āĻšāĻžāĻ˛āĻžāĻ¨ā§‹ āĻšāĻšā§āĻ›ā§‡!

👉 āĻāĻ–āĻžāĻ¨ā§‡ go āĻ•ā§€āĻ“āĻ¯āĻŧāĻžāĻ°ā§āĻĄ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°ā§‡ āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨āĻ•ā§‡ āĻāĻ•āĻŸāĻŋ āĻ¨āĻ¤ā§āĻ¨ āĻ—ā§‹ āĻ°ā§āĻŸāĻŋāĻ¨ā§‡ āĻšāĻžāĻ˛āĻžāĻ¨ā§‹ āĻšāĻ¯āĻŧā§‡āĻ›ā§‡, āĻ¯āĻž āĻ¸āĻŽāĻžāĻ¨ā§āĻ¤āĻ°āĻžāĻ˛āĻ­āĻžāĻŦā§‡ (concurrently) āĻ•āĻžāĻœ āĻ•āĻ°āĻŦā§‡āĨ¤

āĻ‰āĻĒāĻ¸āĻ‚āĻšāĻžāĻ° (Conclusion)

āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°ā§‡ āĻ•ā§‹āĻĄāĻ•ā§‡ āĻ†āĻ°āĻ“ āĻ¸āĻ‚āĻ•ā§āĻˇāĻŋāĻĒā§āĻ¤ āĻāĻŦāĻ‚ āĻ•āĻžāĻ°ā§āĻ¯āĻ•āĻ°ā§€ āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧāĨ¤ āĻāĻŸāĻŋ āĻ¸āĻžāĻ§āĻžāĻ°āĻŖāĻ¤ āĻāĻ•āĻŦāĻžāĻ° āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ°ā§‡āĻ° āĻœāĻ¨ā§āĻ¯ āĻ‰āĻĒāĻ¯ā§‹āĻ—ā§€, āĻ¤āĻŦā§‡ āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ā§‡ āĻ¸āĻ‚āĻ°āĻ•ā§āĻˇāĻŖ āĻ•āĻ°ā§‡ āĻāĻ•āĻžāĻ§āĻŋāĻ•āĻŦāĻžāĻ° āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻžāĻ“ āĻ¸āĻŽā§āĻ­āĻŦāĨ¤

āĻŦā§ˆāĻļāĻŋāĻˇā§āĻŸā§āĻ¯āĻŦāĻ°ā§āĻŖāĻ¨āĻž
āĻ¨āĻžāĻŽāĻšā§€āĻ¨ āĻĢāĻžāĻ‚āĻļāĻ¨āĻĢāĻžāĻ‚āĻļāĻ¨āĻ•ā§‡ āĻ•ā§‹āĻ¨ā§‹ āĻ¨āĻžāĻŽ āĻ¨āĻž āĻĻāĻŋāĻ¯āĻŧā§‡ āĻ¸āĻ°āĻžāĻ¸āĻ°āĻŋ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧ
IIFE (Immediately Invoked Function Expression)āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ˜ā§‹āĻˇāĻŖāĻž āĻ•āĻ°ā§‡āĻ‡ āĻ¸āĻžāĻĨā§‡ āĻ¸āĻžāĻĨā§‡ āĻāĻ•ā§āĻ¸āĻŋāĻ•āĻŋāĻ‰āĻŸ āĻ•āĻ°āĻž āĻšāĻ¯āĻŧ
āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻ—ā§āĻ°āĻšāĻŖ āĻ•āĻ°āĻ¤ā§‡ āĻĒāĻžāĻ°ā§‡āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻ‡āĻ¨āĻĒā§āĻŸ āĻ¨āĻŋāĻ¤ā§‡ āĻĒāĻžāĻ°ā§‡
āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ā§‡ āĻ¸āĻ‚āĻ°āĻ•ā§āĻˇāĻŖ āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧāĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨āĻ•ā§‡ āĻ­ā§‡āĻ°āĻŋāĻ¯āĻŧā§‡āĻŦāĻ˛ā§‡ āĻ°ā§‡āĻ–ā§‡ āĻĒā§āĻ¨āĻƒāĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧ
āĻ—ā§‹ āĻ°ā§āĻŸāĻŋāĻ¨ā§‡ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧāĻŽāĻžāĻ˛ā§āĻŸāĻŋāĻĨā§āĻ°ā§‡āĻĄāĻŋāĻ‚āĻ¯āĻŧā§‡āĻ° āĻœāĻ¨ā§āĻ¯ āĻ—ā§‹ āĻ°ā§āĻŸāĻŋāĻ¨ā§‡ āĻšāĻžāĻ˛āĻžāĻ¨ā§‹ āĻ¯āĻžāĻ¯āĻŧ
āĻĢāĻžāĻ‚āĻļāĻ¨ āĻĒā§āĻ¯āĻžāĻ°āĻžāĻŽāĻŋāĻŸāĻžāĻ° āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻĒāĻžāĻ āĻžāĻ¨ā§‹ āĻ¯āĻžāĻ¯āĻŧāĻĢāĻžāĻ‚āĻļāĻ¨āĻ•ā§‡ āĻ‡āĻ¨āĻĒā§āĻŸ āĻšāĻŋāĻ¸ā§‡āĻŦā§‡ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧ

🚀 āĻ…ā§āĻ¯āĻžāĻ¨ā§‹āĻ¨āĻŋāĻŽāĻžāĻ¸ āĻĢāĻžāĻ‚āĻļāĻ¨ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ•āĻ°ā§‡ Go āĻĒā§āĻ°ā§‹āĻ—ā§āĻ°āĻžāĻŽāĻŋāĻ‚āĻ•ā§‡ āĻ†āĻ°āĻ“ āĻĢā§āĻ˛ā§‡āĻ•ā§āĻ¸āĻŋāĻŦāĻ˛ āĻ“ āĻļāĻ•ā§āĻ¤āĻŋāĻļāĻžāĻ˛ā§€ āĻ•āĻ°āĻž āĻ¯āĻžāĻ¯āĻŧ! 🚀

Š2025 Linux Bangla | Developed & Maintaind by Linux Bangla.