Wie füge ich einem vorhandenen Typ in Go neue Methoden hinzu?

Ich möchte Route- gorilla/muxund Routertypen eine praktische Util-Methode hinzufügen :

package util

import(
    "net/http"
    "github.com/0xor1/gorillaseed/src/server/lib/mux"
)

func (r *mux.Route) Subroute(tpl string, h http.Handler) *mux.Route{
    return r.PathPrefix("/" + tpl).Subrouter().PathPrefix("/").Handler(h)
}

func (r *mux.Router) Subroute(tpl string, h http.Handler) *mux.Route{
    return r.PathPrefix("/" + tpl).Subrouter().PathPrefix("/").Handler(h)
}

aber der Compiler informiert mich

Neue Methoden für den nicht lokalen Typ mux.Router können nicht definiert werden

Wie würde ich das erreichen? Erstelle ich einen neuen Strukturtyp mit anonymen Feldern mux.Route und mux.Router? Oder etwas anderes?

Wie der Compiler erwähnt, können Sie vorhandene Typen in einem anderen Paket nicht erweitern. Sie können Ihren eigenen Alias ​​oder Ihr eigenes Unterpaket wie folgt definieren:

type MyRouter mux.Router

func (m *MyRouter) F() { ... }

oder durch Einbetten des Original-Routers:

type MyRouter struct {
    *mux.Router
}

func (m *MyRouter) F() { ... }

...
r := &MyRouter{router}
r.F()

Ich wollte die Antwort von @jimt hier erweitern . Diese Antwort ist richtig und hat mir enorm geholfen, dies zu klären. Es gibt jedoch einige Einschränkungen bei beiden Methoden (Alias, Einbettung), mit denen ich Probleme hatte.

Hinweis : Ich verwende die Begriffe Eltern und Kind, bin mir jedoch nicht sicher, ob dies für die Komposition am besten geeignet ist. Grundsätzlich ist Eltern der Typ, den Sie lokal ändern möchten. Child ist der neue Typ, der versucht, diese Änderung zu implementieren.

Methode 1 - Typdefinition

type child parent
// or
type MyThing imported.Thing

• Bietet Zugriff auf die Felder.
• Bietet keinen Zugriff auf die Methoden.

Methode 2 - Einbetten ( offizielle Dokumentation )

type child struct {
    parent
}
// or with import and pointer
type MyThing struct {
    *imported.Thing
}

• Bietet Zugriff auf die Felder.
• Bietet Zugriff auf die Methoden.
• Erfordert die Berücksichtigung für die Initialisierung.

Zusammenfassung

• Bei Verwendung der Kompositionsmethode wird das eingebettete übergeordnete Element nicht initialisiert, wenn es sich um einen Zeiger handelt. Das übergeordnete Element muss separat initialisiert werden.
• Wenn das eingebettete übergeordnete Element ein Zeiger ist und beim Initialisieren des untergeordneten Elements nicht initialisiert wird, tritt ein Nullzeiger-Dereferenzierungsfehler auf.
• Sowohl Typdefinitions- als auch Einbettungsfälle bieten Zugriff auf die Felder des übergeordneten Elements.
• Die Typdefinition ermöglicht keinen Zugriff auf die Methoden des übergeordneten Elements, das Einbetten des übergeordneten Elements jedoch.

Sie können dies im folgenden Code sehen.

Arbeitsbeispiel auf dem Spielplatz

package main

import (
    "fmt"
)

type parent struct {
    attr string
}

type childAlias parent

type childObjParent struct {
    parent
}

type childPointerParent struct {
    *parent
}

func (p *parent) parentDo(s string) { fmt.Println(s) }
func (c *childAlias) childAliasDo(s string) { fmt.Println(s) }
func (c *childObjParent) childObjParentDo(s string) { fmt.Println(s) }
func (c *childPointerParent) childPointerParentDo(s string) { fmt.Println(s) }

func main() {
    p := &parent{"pAttr"}
    c1 := &childAlias{"cAliasAttr"}
    c2 := &childObjParent{}
    // When the parent is a pointer it must be initialized.
    // Otherwise, we get a nil pointer error when trying to set the attr.
    c3 := &childPointerParent{}
    c4 := &childPointerParent{&parent{}}

    c2.attr = "cObjParentAttr"
    // c3.attr = "cPointerParentAttr" // NOGO nil pointer dereference
    c4.attr = "cPointerParentAttr"

    // CAN do because we inherit parent's fields
    fmt.Println(p.attr)
    fmt.Println(c1.attr)
    fmt.Println(c2.attr)
    fmt.Println(c4.attr)

    p.parentDo("called parentDo on parent")
    c1.childAliasDo("called childAliasDo on ChildAlias")
    c2.childObjParentDo("called childObjParentDo on ChildObjParent")
    c3.childPointerParentDo("called childPointerParentDo on ChildPointerParent")
    c4.childPointerParentDo("called childPointerParentDo on ChildPointerParent")

    // CANNOT do because we don't inherit parent's methods
    // c1.parentDo("called parentDo on childAlias") // NOGO c1.parentDo undefined

    // CAN do because we inherit the parent's methods
    c2.parentDo("called parentDo on childObjParent")
    c3.parentDo("called parentDo on childPointerParent")
    c4.parentDo("called parentDo on childPointerParent")
}