زبان برنامه‌نویسی گو/توابع ناشناس و توابع به عنوان مقادیر

توابع ناشناس و توابع به عنوان مقادیر در Go

زبان برنامه‌نویسی Go توابع را به عنوان مقدارهای درجه اول (First-class Citizens) در نظر می‌گیرد. این ویژگی به شما اجازه می‌دهد تا توابع را مانند هر مقدار دیگری (مانند اعداد، رشته‌ها یا ساختارها) در متغیرها ذخیره کنید، به‌عنوان آرگومان به توابع دیگر ارسال کنید، و حتی به‌عنوان خروجی از یک تابع برگردانید.

توابع ناشناس (Anonymous Functions)

توابع ناشناس توابعی هستند که نامی ندارند و معمولاً به صورت inline تعریف می‌شوند. این توابع برای استفاده‌ی سریع و کوتاه‌مدت طراحی شده‌اند، به‌ویژه زمانی که نیازی به تعریف یک تابع مستقل و جداگانه وجود ندارد.

تعریف تابع ناشناس

package main

import "fmt"

func main() {
    // تعریف یک تابع ناشناس و اجرای فوری آن
    func() {
        fmt.Println("سلام از یک تابع ناشناس!")
    }()
}

ذخیره‌سازی توابع در متغیرها

توابع ناشناس و حتی توابع معمولی را می‌توان در متغیرها ذخیره کرد و در مواقع لازم اجرا نمود.

package main

import "fmt"

func main() {
    // ذخیره تابع ناشناس در متغیر
    greet := func(name string) string {
        return "سلام، " + name
    }

    // فراخوانی تابع از طریق متغیر
    message := greet("دوست من")
    fmt.Println(message)
}

توابع به عنوان آرگومان

یکی از کاربردهای مهم توابع به عنوان مقادیر، ارسال آن‌ها به توابع دیگر به عنوان آرگومان است. این امکان باعث می‌شود که بتوانیم الگوهایی مانند Higher-Order Functions یا Callbacks را پیاده‌سازی کنیم.

package main

import "fmt"

// تابعی که یک تابع دیگر را به عنوان آرگومان می‌گیرد
func processNumbers(numbers []int, operation func(int) int) []int {
    var result []int
    for _, n := range numbers {
        result = append(result, operation(n))
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    // ارسال تابع ناشناس به عنوان آرگومان
    doubled := processNumbers(numbers, func(n int) int {
        return n * 2
    })

    fmt.Println("اعداد اصلی:", numbers)
    fmt.Println("اعداد دو برابر شده:", doubled)
}

توابع به عنوان خروجی

توابع می‌توانند خروجی یک تابع دیگر باشند. این قابلیت برای ساخت Closureها و ایجاد توابع سفارشی بسیار پرکاربرد است.

package main

import "fmt"

// تابعی که یک تابع دیگر برمی‌گرداند
func multiplier(factor int) func(int) int {
    return func(n int) int {
        return n * factor
    }
}

func main() {
    double := multiplier(2)
    triple := multiplier(3)

    fmt.Println("2 * 5 =", double(5))
    fmt.Println("3 * 5 =", triple(5))
}

کلوزرها (Closures)

یک Closure تابعی است که به متغیرهای محیطی در محدوده‌ی خودش دسترسی دارد، حتی اگر آن محیط دیگر وجود نداشته باشد. این ویژگی به ما اجازه می‌دهد حالت (state) را درون یک تابع نگه‌داریم.

package main

import "fmt"

// ایجاد یک شمارنده با کلوزر
func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    c1 := counter()
    c2 := counter()

    fmt.Println(c1()) // 1
    fmt.Println(c1()) // 2
    fmt.Println(c2()) // 1 (شمارنده مستقل)
}

جمع‌بندی

• در Go، توابع مقدارهای درجه اول هستند.
• می‌توان آن‌ها را در متغیر ذخیره کرد، به توابع دیگر ارسال کرد یا از آن‌ها برگرداند.
• توابع ناشناس برای استفاده‌های سریع و موقتی بسیار مناسب هستند.
• کلوزرها قدرت نگه‌داری وضعیت داخلی در توابع را فراهم می‌کنند.

این قابلیت‌ها Go را به زبانی قدرتمند برای طراحی برنامه‌های انعطاف‌پذیر و ماژولار تبدیل می‌کند.