{"id":411,"date":"2024-09-25T07:35:35","date_gmt":"2024-09-25T00:35:35","guid":{"rendered":"https:\/\/gotutorial.org\/?page_id=411"},"modified":"2024-09-25T07:35:37","modified_gmt":"2024-09-25T00:35:37","slug":"go-empty-interface","status":"publish","type":"page","link":"https:\/\/www.gotutorial.org\/go-tutorial\/go-empty-interface\/","title":{"rendered":"Go Empty Interface"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn about the Go empty interface (interface {}<\/code>) that can hold a value of any type.<\/p>\n\n\n\n

Go interface {}<\/h2>\n\n\n\n

In Go, you can declare an interface without any methods:<\/p>\n\n\n

interface<\/span> {}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
It is called an empty interface. <\/p>\n\n\n\n
The empty interface is the most general type in Go’s type system because you can use it to represent any type.<\/p>\n\n\n\n
Empty interfaces are flexible because you can use them in functions or data structures that can work with values of any type.<\/p>\n\n\n\n
Defining generic functions<\/h3>\n\n\n\n
In the following program, we define a print()<\/code> function that uses a parameter with the type is an empty interface:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> print<\/span>(x interface<\/span>{})<\/span><\/span> {\n    fmt.Println(x)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    print<\/span>(\"Hi\"<\/span>)\n    print<\/span>(100<\/span>)\n    print<\/span>(true<\/span>)\n    print<\/span>([]int<\/span>{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>})\n    print<\/span>([]string<\/span>{\"apple\"<\/span>, \"banana\"<\/span>, \"strawberry\"<\/span>})\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi\n100<\/span>\ntrue<\/span>\n[1<\/span> 2<\/span> 3<\/span> 4<\/span> 5<\/span>]\n[apple banana strawberry]<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
The print()<\/code> function accepts any type and uses the Println<\/code> function from the fmt<\/code> package to write the value to the standard output, which is the screen.<\/p>\n\n\n\n
Defining variadic functions with empty interfaces<\/h3>\n\n\n\n
To allow the print()<\/code> function to accept a variable number of arguments, you can convert it to a variadic function as follows:<\/p>\n\n\n
func<\/span> print<\/span>(args ...interface<\/span>{})<\/span><\/span> {\n\tfmt.Println(args...)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax, the ...<\/code>, which appears in front of the interface {}<\/code>, denotes that the print()<\/code> function can accept a variable number of arguments. Since the type of each argument is an interface {}<\/code>, you can pass arguments of any type to the print()<\/code> function.<\/p>\n\n\n\n
The following program how to pass any number of arguments of any type to the print()<\/code> function:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> print<\/span>(args ...interface<\/span>{})<\/span><\/span> {\n    fmt.Println(args...)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    print<\/span>(\"Hi\"<\/span>, 10<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
print<\/span>(\"Hi\"<\/span>, 10<\/span>)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Notice that the fmt.Println<\/code>() function uses the type any<\/code>, which is the alias of an empty interface (interface {}<\/code>):<\/p>\n\n\n
func<\/span> Println<\/span>(a ...any)<\/span> (n int<\/span>, err error)<\/span><\/span> {\n    return<\/span> Fprintln(os.Stdout, a...)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Here’s the definition of the type any in the Go’s fmt<\/code> package:<\/p>\n\n\n
type<\/span> any = interface<\/span>{}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Defining data structures of any types<\/h3>\n\n\n\n
You can use empty interfaces to define a data structure such as arrays or slices. For example:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\ntype<\/span> AnySlice []interface<\/span>{}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    s := AnySlice{1<\/span>, \"one\"<\/span>, 2.0<\/span>, true<\/span>}\n    for<\/span> _, v := range<\/span> s {\n        fmt.Println(v)\n    }\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define an alias for a slice of empty interface {}<\/code>, which is a slice of values of any type:<\/p>\n\n\n
type<\/span> AnySlice []interface<\/span>{}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, declare and initialize a slice that can store a mix of values of any type:<\/p>\n\n\n
s := AnySlice{1<\/span>, \"one\"<\/span>, 2.0<\/span>, true<\/span>}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, iterate over the elements of the slice and display them on the screen:<\/p>\n\n\n
for<\/span> _, v := range<\/span> s {\n    fmt.Println(v)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
1<\/span>\none\n2<\/span>\ntrue<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Handling JSON with dynamic data<\/h3>\n\n\n\n
When working with JSON or other data formats where you don’t know the structure at compile time, you can use the interface {}<\/code> to represent the data. For example:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> (\n    \"encoding\/json\"<\/span>\n    \"fmt\"<\/span>\n    \"os\"<\/span>\n)\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    profileJSON := `{\"name\":\"Anthony\", \"age\":25, \"tags\":[\"golang\", \"programming\"]}`<\/span>\n    var<\/span> data map<\/span>[string<\/span>]interface<\/span>{}\n\n    if<\/span> err := json.Unmarshal([]byte<\/span>(profileJSON), &data); err != nil<\/span> {\n        fmt.Print(err)\n        os.Exit(1<\/span>)\n    }\n\n    fmt.Println(data)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
map<\/span>[age:25<\/span> name:Anthony tags:[golang programming]]<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Type Assertions<\/h2>\n\n\n\n
In Go, type assertions allow you to retrieve the dynamic value stored in the interface {}<\/code> variable and convert it back to its original type. For example:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> (\n    \"fmt\"<\/span>\n    \"strings\"<\/span>\n)\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    \/\/ store the value in an empty interface<\/span>\n    var<\/span> x interface<\/span>{} = \"hello\"<\/span>\n\n    \/\/ type assertion<\/span>\n    msg, ok := x.(string<\/span>)\n\n    \/\/ if x is a string<\/span>\n    if<\/span> ok {\n        fmt.Println(strings.ToLower(msg))\n    } else<\/span> {\n        fmt.Println(\"x is not a string\"<\/span>)\n    }\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, store a literal string in a variable of type interface {}<\/code>:<\/p>\n\n\n
var<\/span> x interface<\/span>{} = \"hello\"<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, assert that the type of x<\/code> is interface {}<\/code>:<\/p>\n\n\n
msg, ok := x.(string<\/span>)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
The x.(string)<\/code> attempts to assert that the dynamic value stored in the variable x<\/code> is of type string. It returns two values:<\/p>\n\n\n\n
    \n
  • msg<\/code> holds the asserted value if the assertion is successful.<\/li>\n\n\n\n
  • ok<\/code> is true<\/code> if the assertion is successful and false<\/code> otherwise.<\/li>\n<\/ul>\n\n\n\n
    Third, check the value of ok<\/code>, if it is true, meaning the value stored in the x<\/code> variable is a string:<\/p>\n\n\n
    if<\/span> ok {\n    fmt.Println(strings.ToLower(msg))\n} else<\/span> {\n    fmt.Println(\"x is not a string\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Type Switch<\/h2>\n\n\n\n
    In Go, you can use a type switch to process values of different types stored in an interface {}<\/code> variable. For example:<\/p>\n\n\n
    package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    values := []interface<\/span>{}{\"Apple\"<\/span>, 100<\/span>, 15.5<\/span>, true<\/span>}\n\n    for<\/span> _, value := range<\/span> values {\n        switch<\/span> v := value.(type<\/span>) {\n        case<\/span> int<\/span>:\n            fmt.Println(\"int:\"<\/span>, v)\n        case<\/span> string<\/span>:\n            fmt.Println(\"string:\"<\/span>, v)\n        case<\/span> bool<\/span>:\n            fmt.Println(\"bool:\"<\/span>, v)\n        default<\/span>:\n            fmt.Println(\"Unknown type\"<\/span>)\n        }\n    }\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    string<\/span>: Apple\nint<\/span>: 100<\/span>\nUnknown type<\/span>\nbool<\/span>: true<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • An empty interface is an interface without method signatures.<\/li>\n\n\n\n
    • An empty interface interface{}<\/code> can represent a value of any type.<\/li>\n\n\n\n
    • Use empty interfaces to create generic functions and data structures that handle dynamic data.<\/li>\n\n\n\n
    • Use type assertions to retrieve the original values stored in an empty interface.<\/li>\n\n\n\n
    • Use type switches to process values of different types stored in an empty interface.<\/li>\n<\/ul>\n
      \n\t
      Was this tutorial helpful?<\/div>\n\t
      \n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t Yes <\/span>\n\t\t<\/button>\n\n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t No <\/span>\n\t\t<\/button>\n\t<\/div>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t