Wie können wir mithilfe von Go Reflection benutzerdefinierte Typen von integrierten Typen unterscheiden?

Identifizieren nicht integrierter Typen mithilfe von Reflexion

Identifizieren benutzerdefinierter Typen

Um zwischen benutzerdefinierten Typen und vordefinierten Typen zu unterscheiden, können wir zwei Reflexionsmethoden verwenden:

• Type.PkgPath(): Gibt das Paket zurück Pfad eines benannten Typs. Vordefinierte Typen haben einen leeren Paketpfad.
• Type.Name(): Gibt den Namen eines benannten Typs zurück. Unbenannte Typen geben eine leere Zeichenfolge zurück.

Benutzerdefinierte Typen haben einen nicht leeren Paketpfad und einen nicht leeren Namen. Umgekehrt haben vordefinierte Typen einen leeren Paketpfad.

Umgang mit Sonderfällen

Anonyme Strukturtypen:

Anonyme Strukturtypen sind unbenannt, können aber einen haben Felder benutzerdefinierter Typen. Wir können nach benutzerdefinierten Typen suchen, indem wir die Felder der Struktur durchlaufen und prüfen, ob einige davon benutzerdefiniert sind.

Kartentypen:

Kartentypen können benutzerdefinierte Schlüssel oder Werte haben Typen. Wir können den Werttyp mit Type.Elem() und den Schlüsseltyp mit Type.Key() abfragen.

Implementierungsbeispiel

func isCustom(t reflect.Type) bool {
    if t.PkgPath() != "" {
        return true
    }

    if k := t.Kind(); k == reflect.Array || k == reflect.Chan || k == reflect.Map ||
        k == reflect.Ptr || k == reflect.Slice {    
        return isCustom(t.Elem()) || (k == reflect.Map && isCustom(t.Key()))
    } else if k == reflect.Struct {
        for i := t.NumField() - 1; i >= 0; i-- {
            if isCustom(t.Field(i).Type) {
                return true
            }
        }
    }

    return false
}

Testen

fmt.Println(isCustom(reflect.TypeOf("")))                // false
fmt.Println(isCustom(reflect.TypeOf(int(2))))            // false
fmt.Println(isCustom(reflect.TypeOf([]int{})))           // false
fmt.Println(isCustom(reflect.TypeOf(struct{ i int }{}))) // false
fmt.Println(isCustom(reflect.TypeOf(&i)))                // false
fmt.Println(isCustom(reflect.TypeOf(map[string]int{})))  // false
fmt.Println(isCustom(reflect.TypeOf(A{})))               // true
fmt.Println(isCustom(reflect.TypeOf(&A{})))              // true
fmt.Println(isCustom(reflect.TypeOf([]A{})))             // true
fmt.Println(isCustom(reflect.TypeOf([][]A{})))           // true
fmt.Println(isCustom(reflect.TypeOf(struct{ a A }{})))   // true
fmt.Println(isCustom(reflect.TypeOf(map[K]int{})))       // true
fmt.Println(isCustom(reflect.TypeOf(map[string]K{})))    // true

Das obige ist der detaillierte Inhalt vonWie können wir mithilfe von Go Reflection benutzerdefinierte Typen von integrierten Typen unterscheiden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!