Functions in Golang

What are Functions in Go?

Functions Go में code के reusable blocks होते हैं, जिन्हें आप बार-बार use कर सकते हैं। Functions आपको complex operations को छोटे-छोटे logical chunks में divide करने की सुविधा देते हैं, जिससे code को manage करना और समझना आसान हो जाता है। Functions Go के essential building blocks हैं, और हर Go program में कम से कम एक function ज़रूर होता है: main function।

Basic Structure of a Function

Go में function की basic syntax कुछ इस प्रकार होती है:

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

• func: Go में function को define करने के लिए func keyword का उपयोग किया जाता है।
• functionName: Function का नाम, जिसे आप define कर रहे हैं।
• parameters: Function के लिए input values, जिन्हें आप parentheses के अंदर define करते हैं।
• returnType: Function से return होने वाले value का type। अगर function कुछ return नहीं करता, तो आप इसे omit कर सकते हैं।
• function body: Function का main code block, जो curly braces {} के अंदर होता है।

1. Simple Function Without Parameters and Return Type

Example: Basic Function

package main

import "fmt"

// Function definition
func greet() {
    fmt.Println("Hello, World!")
}

func main() {
    // Function call
    greet()
}

Explanation:

• func greet(): यह एक simple function है जो किसी parameter को accept नहीं करता और कुछ return भी नहीं करता।
• fmt.Println("Hello, World!"): Function body में हम एक simple message print कर रहे हैं।
• greet(): Main function के अंदर हमने greet() function को call किया है, जिससे message print होता है।

2. Function with Parameters

Functions में parameters pass करके आप उन्हें dynamic बना सकते हैं, यानी हर बार अलग-अलग inputs के साथ function को call कर सकते हैं।

Example: Function with Parameters

package main

import "fmt"

// Function definition with parameters
func add(a int, b int) {
    sum := a + b
    fmt.Println("Sum:", sum)
}

func main() {
    // Function call with arguments
    add(3, 4)
}

Explanation:

• func add(a int, b int): यहां add function दो integers a और b को parameters के रूप में लेता है।
• sum := a + b: Function body में हम a और b को add कर रहे हैं और result को sum variable में store कर रहे हैं।
• add(3, 4): Main function में हमने add() function को call किया है और 3 और 4 को arguments के रूप में pass किया है। यह Sum: 7 output देगा।

3. Function with Return Value

Functions से आप values को return भी कर सकते हैं। इससे आप function की output को capture करके आगे process कर सकते हैं।

Example: Function with Return Value

package main

import "fmt"

// Function definition with return value
func multiply(a int, b int) int {
    product := a * b
    return product
}

func main() {
    // Function call and capturing the return value
    result := multiply(3, 4)
    fmt.Println("Product:", result)
}

Explanation:

• func multiply(a int, b int) int: यहां multiply function दो integers को accept करता है और एक integer value return करता है।
• return product: Function body में calculated product value को return किया जाता है।
• result := multiply(3, 4): Main function में हमने multiply() function को call किया और returned value को result variable में store किया।

4. Function with Multiple Return Values

Go functions में आप multiple values को एक साथ return कर सकते हैं। यह feature बहुत उपयोगी होता है, खासकर जब आप किसी operation का result और potential error दोनों को return करना चाहते हैं।

Example: Function with Multiple Return Values

package main

import "fmt"

// Function definition with multiple return values
func divide(a int, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func main() {
    // Function call and handling multiple return values
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

Explanation:

• func divide(a int, b int) (int, error): यह function एक integer और एक error value को return करता है।
• if b == 0 { return 0, fmt.Errorf("division by zero") }: अगर divisor 0 है, तो function 0 और एक error message return करता है।
• result, err := divide(10, 2): Main function में हमने function call किया और दोनों returned values (result और err) को handle किया।

5. Named Return Values

Go में आप return values को नाम दे सकते हैं, जिससे code को और भी readable और concise बनाया जा सकता है।

Example: Named Return Values

package main

import "fmt"

// Function definition with named return values
func subtract(a int, b int) (result int) {
    result = a - b
    return
}

func main() {
    // Function call
    result := subtract(10, 3)
    fmt.Println("Result:", result)
}

Explanation:

• func subtract(a int, b int) (result int): यहां return value को result नाम दिया गया है।
• result = a - b: Function body में हमने result variable को directly assign किया।
• return: Named return values के कारण हमें explicitly result को return करने की जरूरत नहीं है; इसे implicit रूप से return किया जाता है।

6. Variadic Functions

Go में आप variadic functions बना सकते हैं, जो कि zero या more arguments को accept कर सकते हैं। इसका उपयोग तब किया जाता है जब आपको एक unknown number of arguments pass करने की जरूरत हो।

Example: Variadic Function

package main

import "fmt"

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

func main() {
    // Function calls with different numbers of arguments
    fmt.Println("Sum:", sum(1, 2, 3))
    fmt.Println("Sum:", sum(10, 20, 30, 40, 50))
}

Explanation:

• func sum(numbers ...int) int: यह variadic function एक या अधिक integers को accept कर सकता है।
• for _, number := range numbers: यह loop सभी passed numbers को iterate करता है और उनका sum calculate करता है।
• sum(1, 2, 3) और sum(10, 20, 30, 40, 50): Main function में variadic function को अलग-अलग arguments के साथ call किया गया है।

Summary

• Basic Functions: Go में functions का उपयोग reusable code blocks बनाने के लिए किया जाता है। ये functions parameters को accept कर सकते हैं और values को return कर सकते हैं।
• Parameters and Return Values: Functions parameters के साथ defined हो सकते हैं और single या multiple values को return कर सकते हैं।
• Named Return Values: Return values को नाम देकर code को अधिक readable बनाया जा सकता है।
• Variadic Functions: Variadic functions एक unknown number of arguments को accept कर सकते हैं, जिससे code और भी flexible हो जाता है।

Go में functions का उपयोग करके आप अपने code को modular, readable और maintainable बना सकते हैं। अगर आपको functions के बारे में और जानकारी चाहिए या कोई specific सवाल है, तो बताइए!

Previous Next