CODEWITHSUNDEEP
go
Muhammad Lukman Low
Muhammad Lukman Low

Reputation: 8533

How do you make a function accept multiple types?

I am having a function like this:

package main
import "flag"
import "fmt"

func print_out_type(x anything) string {
    switch v := x.(type) {
        case string:
             return "A string"
        case int32:
             return "An Integer"
        default:
             return "A default"
    }
}

func main() {
    wordPtr := flag.String("argument1", "foo", "a String")
    numPtr := flag.Int("argument2", 42, "an Integer")
    flag.Parse()
    fmt.Println("word: ", *wordPtr)
    fmt.Println("number: ", *numPtr)
}

I am trying to return different types of strings based on the type. I am just stuck at the point of how do I write a function that accepts arguments of different types.

Upvotes: 33

Views: 68504

Answers (3)

fengzixu
fengzixu

Reputation: 9

You can use an interface{} type variable as a parameter to the function. In the function, you can use type assertion or type switch to check the parameter's real type and print it out.

Upvotes: -5

Damir Luketic
Damir Luketic

Reputation: 101

Starting with Go 1.18. you can use generics to specify which types can be used in a function.

func print_out_type[T any](x T) string {
    return fmt.Sprintf("%T", x)
}

https://go.dev/doc/tutorial/generics

Upvotes: 10

jussius
jussius

Reputation: 3274

You can use interface types as arguments, in which case you can call the function with any type that implements the given interface. In Go types automatically implement any interfaces if they have the interface's methods. So if you want to accept all possible types, you can use empty interface (interface{}) since all types implement that. No other modification needs to be done to your function.

func print_out_type(x interface{}) string {
    switch v := x.(type) {
        case string:
             return "A string"
        case int32:
             return "An Integer"
        default:
             return "A default"
    }
}

You can also use the reflect package to study the type of an interface variable. For Example:

func print_out_type(x interface{}) string {
    return reflect.TypeOf(x).String()
}

func main() {
    fmt.Println(print_out_type(42))
    fmt.Println(print_out_type("foo"))
}

Will print

int

string

Upvotes: 61

Related Questions