How Can I Check for Interface Implementation in Go?

Understanding Interface Implementation Checks in Go

In Go, determining if a value implements an interface can be a confusing task for beginners. This article aims to clarify the process with examples to follow.

Why Use Interface Implementation Checks?

Normally, the compiler automatically performs interface implementation checks based on the value's known type. However, when working with values of unknown types, it becomes necessary to manually check if an interface is implemented.

Example Code Analysis

Consider the following example:

type Somether interface {
    Method() bool
}

type MyType string

func (mt MyType) Method2() bool {
    return true
}

func main() {
    val := MyType("hello")
    _, ok := val.(Somether)
    var _ Iface = (*MyType)(nil)
}

Method 1: Assertion with type switch

In the first attempt, the type switch (_(Somether)) is used to check if the value val implements the interface Somether. However, this approach requires a type switch, which may not be optimal.

Method 2: Assignment to empty interface

The second method uses the empty interface:

var _ Iface = (*MyType)(nil)

This technique assigns a pointer of type MyType to an empty interface variable. If MyType implemented Somether, the code would compile without errors. However, since it doesn't, a compile-time error will be thrown indicating that MyType does not implement Somether.

Simplicity of Interface Implementation Checks

It is important to note that these checks are primarily used when the value's type is unknown. When the type is known, the compiler automatically verifies interface implementation.

The above is the detailed content of How Can I Check for Interface Implementation in Go?. For more information, please follow other related articles on the PHP Chinese website!