Go Variadic Function

Variadic function হলো এমন একটি ফাংশন যা যেকোনো সংখ্যক argument নিতে পারে।

🧺 অ্যানালজি: বাজারের ব্যাগের মতো — একটা, দুটো, বা দশটা জিনিসও ধরে। আলাদা আলাদা ব্যাগ লাগে না।

১. Syntax 📌


//              ↓ এই ... মানে "যেকোনো সংখ্যক"
func sum(nums ...int) int {
    total := 0
    for _, n := range nums { // ভেতরে nums হলো []int
        total += n
    }
    return total
}
 
fmt.Println(sum(1, 2, 3))       // 6
fmt.Println(sum(10, 20))        // 30
fmt.Println(sum())              // 0 — argument না দিলেও চলে

সাধারণ ফাংশন vs Variadic:


// ❌ সাধারণ — প্রতিটি সংখ্যার জন্য আলাদা ফাংশন লিখতে হবে
func sum2(a, b int) int         { return a + b }
func sum3(a, b, c int) int      { return a + b + c }
 
// ✅ Variadic — একটাই যথেষ্ট
func sum(nums ...int) int       { /* ... */ }

২. ভেতরে কীভাবে কাজ করে?

...T parameter-টি ফাংশনের ভেতরে []T slice হিসেবে কাজ করে।

পরিস্থিতি	`nums`-এর ভ্যালু	`len(nums)`
`sum(1, 2, 3)`	`[]int{1, 2, 3}`	3
`sum(5)`	`[]int{5}`	1
`sum()`	`[]int{}`	0

⚠️ argument না দিলে nil নয়, empty slice হয়। তবে len(nums) == 0 দিয়ে চেক করাই নিরাপদ।

৩. Rules 📌

নিয়ম	উদাহরণ
একটি ফাংশনে শুধু একটি variadic parameter	`func f(a ...int, b ...int)` — ❌ compile error
সবসময় সবার শেষে থাকতে হবে	`func f(prefix string, vals ...int)` — ✅
Variadic parameter-এ একই type	`...int`, `...string`, `...any`


func greet(greeting string, names ...string) {
    for _, name := range names {
        fmt.Println(greeting, name)
    }
}
 
greet("Hello", "Rahim", "Karim", "Jamal")
// Hello Rahim
// Hello Karim
// Hello Jamal

৪. Slice Unpacking — `...` অপারেটর

আগে থেকে তৈরি slice পাস করতে ... দিয়ে unpack করুন:


nums := []int{1, 2, 3, 4, 5}
 
sum(nums...)        // ✅ slice unpack করে পাস
sum(nums)           // ❌ compile error — []int পাস করা যাবে না সরাসরি


// Forwarding — এক variadic থেকে আরেকটায় পাস করা
func logAll(vals ...any) {
    fmt.Println(vals...)   // ✅ unpack করে fmt.Println-এ পাস
}

৫. Stdlib-এ Variadic (Real-world Usage)

Go standard library-তে variadic ব্যাপকভাবে ব্যবহৃত:

Function	Signature
`fmt.Println`	`func Println(a ...any) (n int, err error)`
`fmt.Sprintf`	`func Sprintf(format string, a ...any) string`
`append`	`func append(slice []T, elems ...T) []T`
`strings.Join`	argument নয়, কিন্তু variadic wrapper সাধারণ


// append — Go-র সবচেয়ে বেশি ব্যবহৃত variadic function
s := []int{1, 2}
s = append(s, 3, 4, 5)     // ✅ একাধিক element
s = append(s, other...)     // ✅ আরেকটি slice unpack করে

৬. Functional Options Pattern (Production Critical) 🔥

Production Go code-এ variadic function-এর সবচেয়ে গুরুত্বপূর্ণ ব্যবহার হলো Functional Options Pattern। এটি grpc, zap, cobra সহ প্রায় সব বড় library-তে ব্যবহৃত হয়।


type Server struct {
    host    string
    port    int
    timeout int
}
 
type Option func(*Server)
 
func WithPort(port int) Option {
    return func(s *Server) { s.port = port }
}
 
func WithTimeout(t int) Option {
    return func(s *Server) { s.timeout = t }
}
 
// Variadic দিয়ে optional config নেওয়া হচ্ছে
func NewServer(host string, opts ...Option) *Server {
    s := &Server{host: host, port: 8080, timeout: 30} // defaults
    for _, opt := range opts {
        opt(s)
    }
    return s
}
 
// Usage — caller শুধু যা দরকার তাই দেয়
s1 := NewServer("localhost")                          // শুধু default
s2 := NewServer("localhost", WithPort(9090))          // port override
s3 := NewServer("localhost", WithPort(9090), WithTimeout(60)) // দুটোই

কেন এটা ভালো? নতুন option যোগ করলে existing code ভাঙে না। NewServer(host, port, timeout, maxConn, ...) এভাবে বাড়তে থাকলে API জটিল হয়।

৭. `any` দিয়ে Mixed Types


// Go 1.18+ — interface{} এর পরিবর্তে 'any' ব্যবহার করুন
func printAll(vals ...any) {
    for _, v := range vals {
        switch v := v.(type) {
        case int:
            fmt.Printf("int: %d\n", v)
        case string:
            fmt.Printf("string: %s\n", v)
        default:
            fmt.Printf("unknown: %T\n", v)
        }
    }
}
 
printAll(42, "hello", true) // type switch দিয়ে handle করা হচ্ছে

৮. Common Mistakes ⚠️

ভুল	সমস্যা	সমাধান
`sum(nums)` — slice সরাসরি পাস	compile error	`sum(nums...)` ব্যবহার করুন
empty args চেক না করা	index out of range panic	`if len(nums) == 0` দিয়ে guard রাখুন
`any` এ unchecked type assertion	runtime panic	type switch ব্যবহার করুন
Variadic parameter প্রথমে রাখা	compile error	সবসময় সবার শেষে রাখুন


// ❌ Unchecked — panic হবে যদি কোনো arg না থাকে
func first(vals ...int) int {
    return vals[0] // panic if len == 0
}
 
// ✅ Safe
func first(vals ...int) (int, bool) {
    if len(vals) == 0 {
        return 0, false
    }
    return vals[0], true
}

৯. Interview Cheat Sheet

Q: Variadic function-এর ভেতরে parameter-এর type কী?

...T parameter ফাংশনের ভেতরে []T slice হিসেবে থাকে।

Q: Argument না দিলে কী হয়?

nil নয়, empty slice ([]T{}) হয়। len == 0 হবে।

Q: Slice কীভাবে variadic function-এ পাস করবেন?

func(slice...) — ... দিয়ে unpack করতে হবে।

Q: একটি ফাংশনে কতটি variadic parameter থাকতে পারে?

মাত্র একটি, এবং সেটি সবসময় সবার শেষ parameter হতে হবে।

Q: Production-এ variadic function-এর সবচেয়ে গুরুত্বপূর্ণ use case কী?

Functional Options Pattern — optional config গ্রহণ করার জন্য। grpc.Dial(), zap.New() এভাবেই কাজ করে।

Q: ...any vs নির্দিষ্ট type — কোনটা ভালো?

নির্দিষ্ট type সবসময় ভালো — type safety থাকে। ...any শুধু তখনই ব্যবহার করুন যখন সত্যিই mixed types দরকার (যেমন fmt.Println)।