Umwandeln unbekannte Schnittstelle zu float64 in Golang

Dave C eine gute Antwort mit reflect, und ich werde vergleichen Sie das mit Typ-Typ-code unten. Erstens, zu tun, was Sie bereits getan haben, prägnanter, können Sie die Typ-Schalter:

    switch i := unk.(type) {
    case float64:
            return i, nil
    case float32:
            return float64(i), nil
    case int64:
            return float64(i), nil
    //...other cases...
    default:
            return math.NaN(), errors.New("getFloat: unknown value is of incompatible type")
    }

Den case float64: ist wie Ihre if i, ok := unk.(float64); ok { ... }. Code für den Fall, dass ein Zugriff auf die float64 als i. Trotz der fehlenden geschweiften Klammern die Fälle handeln, wie Blöcke: i's Typ ist anders unter jedem case und es gibt keine C-style-fallthrough.

Beachten Sie auch, groß int64s (über 2⁵³) gerundet werden bei der Konvertierung in float64, so, wenn Sie denken float64 als "universal" Typ Zahl, nehmen Ihre Einschränkungen zu berücksichtigen.

Ein Beispiel dafür ist der Spielplatz am http://play.golang.org/p/EVmv2ibI_j.

Dave C erwähnt Sie kann vermeiden Sie das schreiben von einzelnen Fällen, wenn Sie reflect; seine Antwort-code, und auch Griffe benannte Typen und Hinweise auf geeignete Arten. Er erwähnt auch die Handhabung von strings und Arten Cabrio zu Ihnen. Nach einem naiven test Vergleich Optionen:

• Vorbei an der reflect version eine int bekommt der von mir über 3 Millionen Konvertierungen pro Sekunde; der overhead ist nicht erkennbar, es sei denn, Sie konvertieren, Millionen von Artikeln.
• Sie können schreiben, ein Schalter behandeln einige gemeinsame Arten dann wieder fallen zu reflect; das ist ein wenig schneller für die gängigsten Typen (9m/s), aber behält die Flexibilität des reflect code.
• Eine switch nur über Anzahl Arten verliert einige Flexibilität, aber kann squeeze-out einige zusätzliche perf, weil escape-Analyse bestimmen kann, seine Eingabe nicht entkommen.

Den code auf dem Spielplatz und unten:

package main

/* To actually run the timings, you need to run this from your machine, not the Playground */

import (
    "errors"
    "fmt"
    "math"
    "reflect"
    "runtime"
    "strconv"
    "time"
)

var floatType = reflect.TypeOf(float64(0))
var stringType = reflect.TypeOf("")

func getFloat(unk interface{}) (float64, error) {
    switch i := unk.(type) {
    case float64:
        return i, nil
    case float32:
        return float64(i), nil
    case int64:
        return float64(i), nil
    case int32:
        return float64(i), nil
    case int:
        return float64(i), nil
    case uint64:
        return float64(i), nil
    case uint32:
        return float64(i), nil
    case uint:
        return float64(i), nil
    case string:
        return strconv.ParseFloat(i, 64)
    default:
        v := reflect.ValueOf(unk)
        v = reflect.Indirect(v)
        if v.Type().ConvertibleTo(floatType) {
            fv := v.Convert(floatType)
            return fv.Float(), nil
        } else if v.Type().ConvertibleTo(stringType) {
            sv := v.Convert(stringType)
            s := sv.String()
            return strconv.ParseFloat(s, 64)
        } else {
            return math.NaN(), fmt.Errorf("Can't convert %v to float64", v.Type())
        }
    }
}

func getFloatReflectOnly(unk interface{}) (float64, error) {
    v := reflect.ValueOf(unk)
    v = reflect.Indirect(v)
    if !v.Type().ConvertibleTo(floatType) {
        return math.NaN(), fmt.Errorf("cannot convert %v to float64", v.Type())
    }
    fv := v.Convert(floatType)
    return fv.Float(), nil
}

var errUnexpectedType = errors.New("Non-numeric type could not be converted to float")

func getFloatSwitchOnly(unk interface{}) (float64, error) {
    switch i := unk.(type) {
    case float64:
        return i, nil
    case float32:
        return float64(i), nil
    case int64:
        return float64(i), nil
    case int32:
        return float64(i), nil
    case int:
        return float64(i), nil
    case uint64:
        return float64(i), nil
    case uint32:
        return float64(i), nil
    case uint:
        return float64(i), nil
    default:
        return math.NaN(), errUnexpectedType
    }
}

func main() {
    var m1, m2 runtime.MemStats

    runtime.ReadMemStats(&m1)
    start := time.Now()
    for i := 0; i < 1e6; i++ {
        getFloatReflectOnly(37)
    }
    fmt.Println("Reflect-only, 1e6 runs:")
    fmt.Println("Wall time:", time.Now().Sub(start))
    runtime.ReadMemStats(&m2)
    fmt.Println("Bytes allocated:", m2.TotalAlloc-m1.TotalAlloc)

    runtime.ReadMemStats(&m1)
    start = time.Now()
    for i := 0; i < 1e6; i++ {
        getFloat(37)
    }
    fmt.Println("\nReflect-and-switch, 1e6 runs:")
    fmt.Println("Wall time:", time.Since(start))
    runtime.ReadMemStats(&m2)
    fmt.Println("Bytes allocated:", m2.TotalAlloc-m1.TotalAlloc)

    runtime.ReadMemStats(&m1)
    start = time.Now()
    for i := 0; i < 1e6; i++ {
        getFloatSwitchOnly(37)
    }
    fmt.Println("\nSwitch only, 1e6 runs:")
    fmt.Println("Wall time:", time.Since(start))
    runtime.ReadMemStats(&m2)
    fmt.Println("Bytes allocated:", m2.TotalAlloc-m1.TotalAlloc)
}

/*
Reflect-only, 1e6 runs:
Wall time: 297.335642ms
Bytes allocated: 16006648

Reflect-and-switch, 1e6 runs:
Wall time: 110.40057ms
Bytes allocated: 8001144

Switch only, 1e6 runs:
Wall time: 15.069157ms
Bytes allocated: 64
*/