Wie funktionieren die Typzusicherungen und Typwechsel von Go im Vergleich zu anderen Typprüfungsmethoden?

Typzusicherung und Switch-Leistung in Go

In Programmiersprachen ist die Bestimmung des Typs einer Variablen oder eines Objekts während der Laufzeit ein grundlegender Vorgang. Go verwendet Typzusicherungen und Typschalter, um diesen Prozess zu erleichtern. Dieser Artikel befasst sich mit den Leistungsmerkmalen dieser Techniken.

Leistungsbedenken

In einigen Sprachen wie C/C kann die Erkennung von Laufzeittypen zu Leistungseinbußen führen. Go-Programmierer haben darüber nachgedacht, ob Typzusicherungen oder Typschalter ähnliche Ineffizienzen aufweisen. Um dies zu beheben, führen wir einen umfassenden Benchmark durch:

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")
    }
}

Der Beispielcode verwendet einen Typschalter, um den Typ der Eingabevariablen zu bestimmen.

Benchmark-Vergleich

Eine Reihe von Benchmark-Tests wurde durchgeführt, um die Leistung von Typzusicherungen und -schaltern mit direkten Methodenaufrufen und Schnittstellen zu vergleichen Implementierungen:

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()
        }
    }
}

Auf mehreren Testmaschinen zeigen die Ergebnisse durchweg, dass alle vier Methoden mit ähnlichen Geschwindigkeiten arbeiten: direkte Methodenaufrufe, Schnittstellenimplementierungen, Typzusicherungen und Typwechsel. Das folgende Beispiel veranschaulicht diese Ergebnisse:

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

Daher ist unsere Schlussfolgerung, dass Typzusicherungen und Typwechsel in Go im Vergleich zu anderen Typprüfungsmethoden keine spürbaren Leistungseinbußen mit sich bringen.

Das obige ist der detaillierte Inhalt vonWie funktionieren die Typzusicherungen und Typwechsel von Go im Vergleich zu anderen Typprüfungsmethoden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!