Functions in detailed

Advanced Function Concepts in Go

चलिए, Go में functions के कुछ और advanced concepts को समझते हैं:

1. Anonymous Functions

Go में आप functions को बिना नाम के भी define कर सकते हैं, जिन्हें anonymous functions कहते हैं। Anonymous functions को आप तुरंत declare और execute कर सकते हैं, या उन्हें variables में assign कर सकते हैं।

Example: Anonymous Function

package main

import "fmt"

func main() {
    // Anonymous function executed immediately
    func() {
        fmt.Println("Hello from an anonymous function!")
    }()

    // Anonymous function assigned to a variable
    greet := func(name string) {
        fmt.Printf("Hello, %s!\n", name)
    }

    // Calling the anonymous function via the variable
    greet("Gopher")
}

Explanation:

• func() { ... }(): यह एक anonymous function है जो तुरंत execute हो जाता है।
• greet := func(name string) { ... }: इस anonymous function को हमने एक variable greet में assign किया है, और बाद में इसे call किया जा सकता है।

2. Higher-Order Functions

Higher-order functions वे होते हैं जो या तो दूसरे functions को as a parameter accept करते हैं, या उन्हें as a return value देते हैं। Go में functions को first-class citizens माना जाता है, जिसका मतलब है कि आप functions को अन्य data types की तरह treat कर सकते हैं।

Example: Higher-Order Function

package main

import "fmt"

// Higher-order function: takes a function as an argument
func applyOperation(x, y int, operation func(int, int) int) int {
    return operation(x, y)
}

// A simple function to be passed as an argument
func add(a, b int) int {
    return a + b
}

func main() {
    result := applyOperation(3, 4, add)
    fmt.Println("Result:", result)
}

Explanation:

• applyOperation(x, y int, operation func(int, int) int) int: यह higher-order function है जो एक function (operation) को as a parameter accept करता है।
• add(a, b int) int: यह simple function है जिसे हम applyOperation में pass कर सकते हैं।
• result := applyOperation(3, 4, add): यहां add function को applyOperation के साथ use किया गया है।

3. Closures

Closures Go में powerful feature हैं, जो functions को उनकी surrounding scope से variables को "capture" करने की अनुमति देते हैं। Closure एक ऐसा function है जो अपने lexical environment में declared variables को reference करता है, भले ही वह scope खत्म हो चुका हो।

Example: Closures

package main

import "fmt"

func main() {
    // A closure that captures the variable `x`
    x := 10
    increment := func() int {
        x++
        return x
    }

    fmt.Println(increment()) // Output: 11
    fmt.Println(increment()) // Output: 12
}

Explanation:

• increment := func() int { ... }: यह closure x variable को capture करता है और उसे modify करता है।
• x++: हर बार जब increment function call होता है, x की value बढ़ जाती है।
• यह function उस scope के बाहर से भी x को access कर सकता है जहां उसे originally define किया गया था।

4. Recursion

Recursion वह process है जिसमें एक function खुद को call करता है। Recursive functions तब useful होते हैं जब problem को smaller subproblems में divide किया जा सकता है।

Example: Recursion

package main

import "fmt"

// Recursive function to calculate factorial
func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

func main() {
    fmt.Println("Factorial of 5:", factorial(5)) // Output: 120
}

Explanation:

• factorial(n int) int: यह function एक recursive function है जो factorial calculate करता है।
• if n == 0 { return 1 }: Base case है जब recursion को stop होना चाहिए।
• return n * factorial(n-1): Recursive step है जो function को खुद को call करने के लिए कहता है।

5. Method Receivers

Go में आप functions को methods के रूप में भी define कर सकते हैं, जो कि specific types के साथ associated होते हैं। Method receivers का उपयोग struct या types के साथ functions को associate करने के लिए किया जाता है।

Example: Method Receivers

package main

import "fmt"

// Define a struct
type Rectangle struct {
    width, height int
}

// Method associated with the Rectangle struct
func (r Rectangle) Area() int {
    return r.width * r.height
}

func main() {
    rect := Rectangle{10, 5}
    fmt.Println("Area of Rectangle:", rect.Area())
}

Explanation:

• type Rectangle struct { ... }: यहां एक struct Rectangle define की गई है।
• func (r Rectangle) Area() int: यह method receiver है जो Rectangle struct के साथ associated है।
• rect.Area(): Method को Rectangle object rect के साथ call किया गया है।

6. Defer in Functions

defer keyword का उपयोग किसी function को delay करने के लिए किया जाता है जब तक कि surrounding function return न हो जाए। यह resource cleanup के लिए बहुत useful है, जैसे file या network connection को close करना।

Example: Defer

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Create("test.txt")
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    defer file.Close() // Ensure file is closed after function finishes

    fmt.Fprintln(file, "Hello, World!")
    fmt.Println("File written successfully.")
}

Explanation:

• defer file.Close(): यह statement file को close करने के लिए defer किया गया है, जो function के end में execute होगा।
• defer: किसी भी resource cleanup operation को perform करने के लिए useful है, जो कि function के return होने से पहले execute किया जाना चाहिए।

Summary of Advanced Function Concepts

• Anonymous Functions: Functions को बिना नाम के define और use किया जा सकता है।
• Higher-Order Functions: Functions जो दूसरे functions को as a parameter accept करते हैं या उन्हें return करते हैं।
• Closures: Functions जो अपनी surrounding scope से variables को capture कर सकते हैं।
• Recursion: Functions जो खुद को call करते हैं, complex problems को हल करने के लिए।
• Method Receivers: Structs या types के साथ associated functions।
• Defer: Delayed execution के लिए, जो function return होने से पहले execute होती है।

ये advanced concepts Go में functions के साथ काम करने के लिए आपके toolset को और भी powerful बनाते हैं। अगर आपको इन concepts के बारे में और जानकारी चाहिए या कोई specific सवाल है, तो बताइए!

Previous Next