In Go, this pattern is known as the comma-ok idiom, and it's a common way to do a type assertion safely.

Now let's look at some real examples:

Also, if you've created your own custom interface, you can do the same thing:

In the example above, we used type assertion inside the DescribeShape function.

Type assertion is also useful for checking whether a value implements a specific interface. In this approach, we need to declare our variable as an interface type, or convert it to type interface using a type conversion, then put the value we want into that variable, and finally use a type assertion to check whether that data type implements the interface we want. Take a look at the example below:

Using a Type Switch

To check the actual type of a value that has an interface type, besides type assertion, you can use a type switch.

The Empty Interface

The empty interface, interface{}, means "any type." Because it has no methods, every type in Go implements it by default.

The empty interface can hold any kind of data, so wherever you need to be able to accept any kind of data, you can use the empty interface.

In Go 1.18, the any type was added to the language, and it's really just an alias for interface{}, but it makes code look more readable.

any is like a nicer name for interface{} that makes the code more readable.

Drawbacks of Using the Empty Interface

1. The empty interface, interface{}, is a form of type erasure, meaning the actual type is hidden, and to use it again you need to use a type assertion or a type switch.

2. Using interface{} excessively or without good reason makes the code lose readability and type safety, because during development we need to check the older code to make sure what type of data was passed to the interface.

Interface Composition

In Go, instead of inheritance, composition is used to build more complex structs and interfaces. This way, several interfaces can be combined to build a larger interface.

Suppose we have two separate interfaces:

Now we want to build a new interface that has both Read and Write:

Here, ReadWriter is a composition of Reader and Writer. Any type that implements both Reader and Writer has also implemented ReadWriter.

In Go, it's recommended that, instead of designing large interfaces, you design small interfaces with one or two methods and combine them through composition when needed. This is one of Go's well-known principles:

Design small interfaces. Compose them when needed

Previous part: The struct Data Type | Golang basics

Next part: Generics | Golang basics