How Do Go's Type Assertions and Type Switches Perform Compared to Other Type-Checking Methodologies?

Type Assertion and Switch Performance in Go

In programming languages, determining the type of a variable or object during runtime is a fundamental operation. Go employs type assertions and type switches to facilitate this process. This article delves into the performance characteristics of these techniques.

Performance Concerns

In some languages like C/C , runtime type discovery can incur performance penalties. Go programmers have pondered whether type assertions or type switches exhibit similar inefficiencies. To address this, let's perform a comprehensive benchmark:

package main

import (
    "fmt"
    "testing"
)

func question(anything interface{}) {
    switch v := anything.(type) {
        case string:
            fmt.Println(v)
        case int32, int64:
            fmt.Println(v)
        case SomeCustomType:
            fmt.Println(v)
        default:
            fmt.Println("unknown")
    }
}

The sample code uses a type switch to determine the type of input variable anything.

Benchmark Comparison

A series of benchmark tests were conducted to compare the performance of type assertions and switches with direct method calls and interface implementations:

package main

import (
    "testing"
)

type myint int64

type Inccer interface {
    inc()
}

func (i *myint) inc() {
    *i = *i + 1
}

func BenchmarkIntmethod(b *testing.B) {
    i := new(myint)
    incnIntmethod(i, b.N)
}

func BenchmarkInterface(b *testing.B) {
    i := new(myint)
    incnInterface(i, b.N)
}

func BenchmarkTypeSwitch(b *testing.B) {
    i := new(myint)
    incnSwitch(i, b.N)
}

func BenchmarkTypeAssertion(b *testing.B) {
    i := new(myint)
    incnAssertion(i, b.N)
}

func incnIntmethod(i *myint, n int) {
    for k := 0; k < n; k++ {
        i.inc()
    }
}

func incnInterface(any Inccer, n int) {
    for k := 0; k < n; k++ {
        any.inc()
    }
}

func incnSwitch(any Inccer, n int) {
    for k := 0; k < n; k++ {
        switch v := any.(type) {
        case *myint:
            v.inc()
        }
    }
}

func incnAssertion(any Inccer, n int) {
    for k := 0; k < n; k++ {
        if newint, ok := any.(*myint); ok {
            newint.inc()
        }
    }
}

On multiple test machines, the results consistently reveal that all four methods perform at similar speeds: direct method calls, interface implementations, type assertions, and type switches. The following example demonstrates these findings:

BenchmarkIntmethod-16           2000000000           1.67 ns/op
BenchmarkInterface-16           1000000000           2.03 ns/op
BenchmarkTypeSwitch-16          2000000000           1.70 ns/op
BenchmarkTypeAssertion-16       2000000000           1.67 ns/op

Hence, our conclusion is that type assertions and type switches in Go do not incur noticeable performance detriments when compared to other type checking methodologies.

The above is the detailed content of How Do Go's Type Assertions and Type Switches Perform Compared to Other Type-Checking Methodologies?. For more information, please follow other related articles on the PHP Chinese website!