Comment les assertions de type et les commutateurs de type de Go fonctionnent-ils par rapport aux autres méthodologies de vérification de type ?

Assertion de type et performances de commutation dans Go

Dans les langages de programmation, déterminer le type d'une variable ou d'un objet pendant l'exécution est une opération fondamentale. Go utilise des assertions de type et des commutateurs de type pour faciliter ce processus. Cet article examine les caractéristiques de performances de ces techniques.

Problèmes de performances

Dans certains langages comme C/C, la découverte de types d'exécution peut entraîner des pénalités de performances. Les programmeurs Go se sont demandé si les assertions de type ou les commutateurs de type présentaient des inefficacités similaires. Pour résoudre ce problème, effectuons un benchmark complet :

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

L'exemple de code utilise un commutateur de type pour déterminer le type de variable d'entrée.

Comparaison des benchmarks

Une série de tests de référence ont été menés pour comparer les performances des assertions de type et des commutateurs avec les appels de méthode directs et l'interface. implémentations :

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

Sur plusieurs machines de test, les résultats révèlent systématiquement que les quatre méthodes fonctionnent à des vitesses similaires : appels de méthode directs, implémentations d'interface, assertions de type et commutateurs de type. L'exemple suivant illustre ces résultats :

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

Par conséquent, notre conclusion est que les assertions de type et les commutateurs de type dans Go n'entraînent pas de pertes de performances notables par rapport à d'autres méthodologies de vérification de type.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!