Does the Go language have function/method overloading?

According to this, it doesn't: http://golang.org/doc/go_for_cpp_programmers.html

In the Conceptual Differences section, it says:

Go does not support function overloading and does not support user defined operators.

No, Go doesn't have overloading.

Overloading adds compiler complexity and will likely never be added.

As Lawrence Dol mentioned, you could use a variadic function at the cost of no type checking.

Your best bet is to use generics and type constraints that were added in Go 1.18

To answer VityaSchel's question, in the comments of Lawrence's answer, of how to make a generic sum function, I've written one below.

https://go.dev/play/p/hRhInhsAJFT

package main

import "fmt"

type Number interface {
  int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64
}

func Sum[number Number](a number, b number) number {
  return a + b
}

func main() {
  var a float64 = 5.1
  var b float64 = 3.2
  println(Sum(a, b))

  var a2 int = 5
  var b2 int = 3
  println(Sum(a2, b2))
}

Even though this question is really old, what I still want to say is that there is a way to acheive something close to overloading functions. Although it may not make the code so easy to read.

Say if you want to overload the funtion Test():

func Test(a int) {
    println(a);
}
func Test(a int, b string) {
    println(a);
    println(b);
}

The code above will cause error. However if you redefine the first Test() to Test1() and the second to Test2(), and define a new function Test() using go's ..., you would be able to call the function Test() the way it is overloaded. code:

package main;

func Test1(a int) {
    println(a);
}
func Test2(a int, b string) {
    println(a);
    println(b);
}
func Test(a int, bs ...string) {
    if len(bs) == 0 {
        Test1(a);
    } else {
        Test2(a, bs[0]);
    }
}
func main() {
    Test(1);
    Test(1, "aaa");
}

output:

1
1
aaa

see more at: https://golangbyexample.com/function-method-overloading-golang/ (I'm not the author of this linked article but personally consider it useful)

You can also do it by making the function variadic using ...interface{}, this will make the param as of type Slice, and then just take off the first value in it using param[0]

func (e *Easy)SetOption(option Option, param ...interface{}) {
    e.code = Code(C.curl_wrapper_easy_setopt_str(e.curl, C.CURLoption(option), C.CString(param[0])))
}

now argument of any type is valid, but at the cost of type checking

As others said the answer is No!

But Golang provides another feature called as receivers which can be used to write something close to overloading:

Basically we are using receiver as a way to differentiate the functions and are able to use same function name for two different functions which can have same args or diff args, but the only caveat is that you can invoke the function only with receiver as its attached to it !

I doubt this kind of code could be useful as it can be confusing, but nevertheless its possible :)

package main

import "fmt"

type hello struct {
    name string
}

func main() {
    fmt.Println(returnNumber(777))
    h := hello{name: "hello"}
    fmt.Println(h.returnNumber("world"))
}

func returnNumber(i int) int {
    return i
}

func (h hello) returnNumber(s string) string {
    return h.name + s
}