Comment ajouter de nouvelles méthodes à un type existant dans Go?

Je souhaite ajouter une méthode utilitaire aux gorilla/muxtypes de routage et de routeur:

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

mais le compilateur m'informe

Impossible de définir de nouvelles méthodes sur un mux de type non local.

Alors, comment pourrais-je y parvenir? Est-ce que je crée un nouveau type de structure qui a des champs mux.Route et mux.Router anonymes? Ou autre chose?

Comme le compilateur le mentionne, vous ne pouvez pas étendre les types existants dans un autre package. Vous pouvez définir votre propre alias ou sous-package comme suit:

type MyRouter mux.Router

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

ou en intégrant le routeur d'origine:

type MyRouter struct {
    *mux.Router
}

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

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

Je voulais développer la réponse donnée par @jimt ici . Cette réponse est correcte et m'a énormément aidé à régler ce problème. Cependant, il y a quelques mises en garde concernant les deux méthodes (alias, incorporer) avec lesquelles j'ai eu des problèmes.

Remarque : j'utilise les termes parent et enfant, même si je ne suis pas sûr que ce soit le meilleur pour la composition. Fondamentalement, parent est le type que vous souhaitez modifier localement. Child est le nouveau type qui tente d'implémenter cette modification.

Méthode 1 - Définition du type

type child parent
// or
type MyThing imported.Thing

• Donne accès aux champs.
• Ne donne pas accès aux méthodes.

Méthode 2 - Intégration ( documentation officielle )

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

• Donne accès aux champs.
• Donne accès aux méthodes.
• Nécessite une considération pour l'initialisation.

Résumé

• En utilisant la méthode de composition, le parent incorporé ne s'initialise pas s'il s'agit d'un pointeur. Le parent doit être initialisé séparément.
• Si le parent incorporé est un pointeur et n'est pas initialisé lorsque l'enfant est initialisé, une erreur de déréférence de pointeur nil se produit.
• La définition de type et les cas incorporés donnent tous deux accès aux champs du parent.
• La définition de type n'autorise pas l'accès aux méthodes du parent, contrairement à l'incorporation du parent.

Vous pouvez voir cela dans le code suivant.

exemple de travail sur l'aire de jeux

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