Dlaczego moja metoda interfejsu Stringer nie jest wywoływana? Podczas stosowania fmt.Println

Metody

Wskaźniki vs. wartości

Reguła o wskaźnikach a wartościach dla odbiorników jest taka, że metody wartości można wywoływać na wskaźnikach i wartościach, ale metody wskaźników mogą być wywoływane na wskaźnikach. Dzieje się tak dlatego, że metody wskaźników mogą modyfikować odbiorcę; wywołanie ich na kopii wartości spowoduje, że te zmiany, które należy usunąć.

Dlatego, aby twoja metoda String działała, gdy jest wywoływana zarówno na wskaźnikach, jak i wartościach, użyj odbiornika wartości. Na przykład,

package main

import "fmt"

type Car struct {
    year int
    make string
}

func (c Car) String() string {
    return fmt.Sprintf("{make:%s, year:%d}", c.make, c.year)
}

func main() {
    myCar := Car{year: 1996, make: "Toyota"}
    fmt.Println(myCar)
    fmt.Println(&myCar)
}

Wyjście:

{make:Toyota, year:1996}
{make:Toyota, year:1996}

Zdefiniuj swoje fmt.Stringer na odbiorniku wskaźnika:

package main

import "fmt"

type Car struct {
        year int
        make string
}

func (c *Car) String() string {
        return fmt.Sprintf("{maker:%s, produced:%d}", c.make, c.year)
}

func main() {
        myCar := Car{year: 1996, make: "Toyota"}
        myOtherCar := &Car{year: 2013, make: "Honda"}
        fmt.Println(&myCar)
        fmt.Println(myOtherCar)
}

Plac zabaw

Wyjście:

{maker:Toyota, produced:1996}
{maker:Honda, produced:2013}    

Następnie zawsze przekaż wskaźnik do instancji Car do fmt.Println. W ten sposób unika się potencjalnie kosztownej kopii wartości pod twoją kontrolą.

OP zapytał dalej:

OP: [gdy używany jest odbiornik wartości] "czy to w zasadzie oznacza, że jeśli mam dużą strukturę, to za każdym razem, gdy przechodzi przez Println, zostanie skopiowana?"

Poniższy eksperyment jest dowodem na to, że odpowiedź brzmi " tak " (gdy używany jest odbiornik wartości). Zauważ, że metoda String() zwiększa rok w tym eksperymencie i sprawdź, jak wpływa to na wydruk.

type Car struct {
    year int
    make string
}

func (c Car) String() string {
    s := fmt.Sprintf("{ptr:%p, make:%s, year:%d}", c, c.make, c.year)
    // increment the year to prove: is c a copy or a reference?
    c.year += 1
    return s
}

func main() {
    myCar := Car{year: 1996, make: "Toyota"}
    fmt.Println(&myCar)
    fmt.Println(&myCar)
    fmt.Println(myCar)
    fmt.Println(myCar)
}

Z wartością receiver (c Car), następujące wydrukowane wyjście pokazuje, że Go wykonuje kopie wartości struktury Car, ponieważ przyrost roku nie jest odzwierciedlany w kolejnych wywołaniach Println:

{ptr:%!p(main.Car={1996 Toyota}), make:Toyota, year:1996}
{ptr:%!p(main.Car={1996 Toyota}), make:Toyota, year:1996}
{ptr:%!p(main.Car={1996 Toyota}), make:Toyota, year:1996}
{ptr:%!p(main.Car={1996 Toyota}), make:Toyota, year:1996}

Zmieniając odbiornik na wskaźnik (c *Car) ale nie zmieniając nic innego, wydrukowane wyjście staje się:

{ptr:0xc420094020, make:Toyota, year:1996}
{ptr:0xc420094020, make:Toyota, year:1997}
{1998 Toyota}
{1998 Toyota}

Nawet jeśli wskaźnik jest dostarczany jako argument w wywołaniu Println, tzn. fmt.Println(&myCar), Go nadal tworzy kopię struktury Car , gdy używany jest odbiornik wartości. PO chce uniknąć wartość kopii są wykonane, a mój wniosek jest taki, że tylko odbiorniki wskaźników spełniają ten wymóg.

Jest to jednak związane tylko z implementacją fmt zamiast Go.

String () with pointer receiver would be called by https://github.com/davecgh/go-spew ponieważ spew Drukuj rzeczy w ten sposób:

v = reflect.ValueOf(arg)

...

switch iface := v.Interface().(type) {
    case fmt.Stringer:
        defer catchPanic(w, v)
        if cs.ContinueOnMethod {
            w.Write(openParenBytes)
            w.Write([]byte(iface.String()))
            w.Write(closeParenBytes)
            w.Write(spaceBytes)
            return false
        }
        w.Write([]byte(iface.String()))
        return true
    }

Ogólnie rzecz biorąc, najlepiej unikać przypisywania wartości do zmiennych za pomocą statycznych inicjalizatorów, tj.

f := Foo{bar:1,baz:"2"}

To dlatego, że może stworzyć dokładnie skargę, o której mówisz, jeśli zapomnisz przekazać foo jako wskaźnik przez &foo albo decydujesz się użyć odbiorników wartości, w końcu tworzysz wiele klonów swoich wartości.

Zamiast tego spróbuj przypisać wskaźniki do statycznych inicjalizatorów domyślnie , tzn.

f := &Foo{bar:1,baz:"2"}

This way f will always be a pointer a jedyny czas, kiedy otrzymasz kopię wartości, to jawne użycie odbiorników wartości.

(są oczywiście chwile, kiedy chcesz zapisać wartość z inicjalizatora statycznego, ale powinny to być przypadki brzegowe)