Type les performances d'assertion et de commutation dans go

dans les langages de programmation, déterminant 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 se plonge dans les caractéristiques de performance de ces techniques.

PROFORMATIONS PROFORMES

Dans certaines langues comme C / C, la découverte de type d'exécution peut entraîner des pénalités de performance. Les programmeurs GO ont réfléchi si les assertions de type ou les commutateurs de type présentent des inefficacités similaires. Pour résoudre ce problème, effectuons une référence complète:

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 quoi que ce soit. importer ( "essai" ) Tapez myInt int64 Tapez l'interface incicérique { Inc () } func (i * myInt) inc () { * i = * i 1 } func benchmarkintMethod (b * test.b) { i: = nouveau (myint) IncnintMethod (I, B.N) } func benchmarkinterface (b * test.b) { i: = nouveau (myint) IncNinterface (I, B.N) } func benchmarktypeswitch (b * test.b) { i: = nouveau (myint) Incnswitch (I, B.N) } func benchmarktypeassertion (b * test.b) { i: = nouveau (myint) IncnAsertion (I, B.N) } func incnintMethod (i * myInt, n int) { pour k: = 0; k

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 directe, implémentations d'interface, assertions de type et commutateurs de type. L'exemple suivant démontre 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'encouragent pas les préjudices de performances notables par rapport aux autres méthodologies de vérification de type.