Go Tutorials

Go Programs

Go any


Go any

In this tutorial, we will learn about the 'any' data type in Go. We will cover the basics of defining and using the 'any' data type, including how to create, access, and manipulate values of this type.


Understanding the 'any' Data Type in Go

The any data type in Go is a type alias for interface{}, which means it can hold a value of any type. This makes it a powerful and flexible data type for cases where the type of value is not known at compile time.


Defining a Variable of Type 'any'

Variables of type any can be defined using the var keyword or by type inference.

var x any
x = 42
x = "Hello, Go!"

Accessing and Manipulating 'any' Values

Values stored in variables of type any can be accessed and manipulated, but you need to use type assertions to work with the underlying type.

var x any = 42
value, ok := x.(int)
if ok {
    fmt.Println(value)
}


Defining and using 'any' Data Type

We can define a variable of type 'any' and assign different types of values to it.

For example,

  1. Define a variable of type any and assign an integer value to it.
  2. Print the value to the console.
  3. Reassign a string value to the variable and print it again.

Go Program

package main
import "fmt"
func main() {
    var x any
    x = 42
    fmt.Println(x)
    x = "Hello, Go!"
    fmt.Println(x)
}

Output

42
Hello, Go!


Type Assertion with 'any'

We can use type assertions to access the underlying type of a value stored in a variable of type 'any'.

For example,

  1. Define a variable of type any and assign an integer value to it.
  2. Use a type assertion to extract the integer value and print it to the console.
  3. Handle the case where the type assertion fails by checking the boolean value returned by the assertion.

Go Program

package main
import "fmt"
func main() {
    var x any = 42
    // Type assertion to extract the underlying int value
    value, ok := x.(int)
    if ok {
        fmt.Println(value) // prints the integer value if type assertion is successful
    } else {
        fmt.Println("Type assertion failed") // prints a message if type assertion fails
    }

    // Another example with a failed type assertion
    var y any = "Hello, Go!"
    value, ok = y.(int)
    if ok {
        fmt.Println(value) // this will not execute
    } else {
        fmt.Println("Type assertion failed") // this will execute
    }
}

Output

42
Type assertion failed


Using 'any' in a Function

We can use the 'any' data type as a parameter or return type in a function to allow flexibility with the types of values it can accept or return.

For example,

  1. Define a function named printValue that takes a parameter of type any.
  2. Inside the function, use a type assertion to determine the underlying type and print the value accordingly.
  3. Call the function with different types of arguments and print the results.

Go Program

package main
import "fmt"
func printValue(val any) {
    // Type assertion inside a switch to determine the underlying type
    switch v := val.(type) {
    case int:
        fmt.Printf("%d is an integer\n", v)
    case string:
        fmt.Printf("%s is a string\n", v)
    default:
        fmt.Printf("%v is of unknown type\n", v)
    }
}
func main() {
    printValue(42)         // calls printValue with an int
    printValue("Hello")   // calls printValue with a string
    printValue(3.14)      // calls printValue with a float64
}

Output

42 is an integer
Hello is a string
3.14 is of unknown type