How to implement function overloading in golang?

The Go language does not support traditional function overloading, but similar effects can be achieved by: using named functions: creating unique names for functions with different parameters or return types; using generics (Go 1.18 and above): for different types Parameters create a single version of the function.

Golang function overloading implementation

In Golang, function overloading in the traditional sense is not supported, that is, the same There are multiple versions of a function name with different parameter lists or return types. However, we can achieve an effect similar to function overloading through the following methods:

1. Using named functions

We can have different parameter lists or return types function to create a unique name, for example:

func Sum(a, b int) int {
    return a + b
}

func SumFloat(a, b float64) float64 {
    return a + b
}

2. Using Generics (>= Go 1.18)

Go 1.18 introduced generics, allowing us to A single version of a function is created at compile time for different types of arguments. For example:

func Sum[T numeric](a, b T) T {
    return a + b
}

Practical case

Suppose we need to create two functions to calculate the length, one function is used to calculate the string length, and the other function is used to calculate the array length.

Using named functions

func StringLength(str string) int {
    return len(str)
}

func ArrayLength(arr []int) int {
    return len(arr)
}

Using generics (>= Go 1.18)

func Length[T any](data T) int {
    return len(data)
}

The above is the detailed content of How to implement function overloading in golang?. For more information, please follow other related articles on the PHP Chinese website!