Warum ist nicht meine Stringer interface-Methode immer aufgerufen wird? Bei der Verwendung von fmt.Println

Denke, ich habe den folgenden code:

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

Wenn ich anrufen fmt.Println(myCar) und das Objekt in Frage ist ein Zeiger, my String () - Methode aufgerufen wird, richtig. Wenn jedoch das Objekt ist ein Wert, meine Ausgabe ist formatiert mit dem Standard-Formatierung eingebaut Gehen und meinen code zum formatieren der Sprach-Objekt nicht aufgerufen.

Das interessante an der Sache ist in jedem Fall, wenn ich rufe myCar.String() manuell funktioniert es einwandfrei, ob mein Objekt ist entweder ein Zeiger oder Wert.

Wie kann ich mein Objekt formatiert, wie ich will, egal ob das Objekt Wert-oder pointer-basiert, wenn verwendet mit Println?

Ich will nicht verwenden ein value-Methode für String-denn dann bedeutet dass, dass jedes mal, wenn es aufgerufen wird, das Objekt wird kopiert, die Nähte nicht zumutbar. Und ich will nicht immer manuell aufgerufen .String() entweder, weil ich versuche, lassen die duck-typing-system tun, es ist Arbeit.

InformationsquelleAutor Ralph Caraveo | 2013-06-07

68

Beim Aufruf fmt.Println, myCar implizit in einen Wert vom Typ interface{} wie Sie sehen können aus die Funktion Unterschrift. Den code aus der fmt - Paket, dann wird ein Typ-Schalter, um herauszufinden, wie drucken mit diesem Wert, suchen so etwas wie dieses:
```
switch v := v.(type) {
case string:
    os.Stdout.WriteString(v)
case fmt.Stringer:
    os.Stdout.WriteString(v.String())
//...
}
```
Jedoch die fmt.Stringer Fall nicht, weil Car nicht umsetzen String (wie es definiert ist, auf *Car). Aufruf String manuell funktioniert, weil der compiler sieht, dass String braucht eine *Car und damit automatisch konvertiert myCar.String() zu (&myCar).String(). Für alles, was in Bezug auf Schnittstellen, müssen Sie es manuell tun. So haben Sie entweder zu implementieren String auf Car oder immer übergeben Sie einen Zeiger auf fmt.Println:
```
fmt.Println(&myCar)
```
- Ich nehme an, es ist auch zum Teil, weil die Sprache nicht geben Sie einen Zeiger zu dem, was gespeichert ist, innerhalb einer Schnittstelle Wert (da diese Adresse bis Ende Mai repräsentieren einen anderen Typ, wenn etwas anderes ist, die dem interface zugewiesen).
- warum nicht zu verlassen, alten Wert in einem Zeiger in diesem Fall?
InformationsquelleAutor guelfey
24

Methoden

Zeiger vs. Werte

Der Regel über Zeiger vs. Werte für den Empfänger ist, dass Wert-Methoden
kann aufgerufen werden, die auf Zeigern und Werte, aber Zeiger Methoden nur
aufgerufen auf Zeiger. Dies ist, weil die Zeiger Methoden ändern können, die
Empfänger; Berufung auf eine Kopie des Werts, der würde bewirken, dass diese
änderungen werden verworfen.

Daher, für Ihre String Methode zu arbeiten, wenn aufgerufen, auf beiden Zeiger und Werte, ein Wert-receiver. Zum Beispiel,
```
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)
}
```
Ausgabe:
```
{make:Toyota, year:1996}
{make:Toyota, year:1996}
```
- Bedeutet dies im Grunde bedeutet, dass, wenn ich habe ein großes struct, dass jedes mal, wenn es geht durch Println Es wird kopiert? Wie ich schon sagte, in meinem Beitrag diese Nähte nicht zumutbar.
- Nein, das argument Typ ist interface{} enthält die Typ-Informationen und einen Zeiger auf die struct. Die Struktur selbst wird nicht kopiert.
InformationsquelleAutor peterSO

Definieren fmt.Stringer auf einen Zeiger-Empfänger:

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

Spielplatz

Ausgabe:

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

Dann immer übergeben Sie einen Zeiger auf Instanzen von Auto zu fmt.Println. Diese Weise einem potenziell teuer Wert kopieren vermieden, unter Ihrer Kontrolle.

InformationsquelleAutor zzzz

3

Der OP fragte weiter:

OP: [wenn ein Wert, der receiver ist gebraucht] "Tut dies grundsätzlich bedeuten, dass, wenn ich habe ein großes struct, dann jedes mal geht es durch Println es wird kopiert?"

Folgenden experiment ist der Beweis, dass die Antwort ist "ja" (wenn ein Wert Empfänger verwendet wird). Beachten Sie, dass die String() - Methode erhöht die Jahr in diesem experiment, und prüfen Sie, wie dieses wirkt sich auf die gedruckte Ausgabe.
```
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)
}
```
Mit einem Wert Empfänger (c Car), die folgenden gedruckten Ausgabe zeigt, dass Gehen macht Wert Kopien der Car struct, da die Jahres-Schritten wird nicht reflektiert, die in nachfolgenden aufrufen zu 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}
```
Ändern der Empfänger einen Zeiger (c *Car) aber verändert sonst nichts, die gedruckte Ausgabe wird:
```
{ptr:0xc420094020, make:Toyota, year:1996}
{ptr:0xc420094020, make:Toyota, year:1997}
{1998 Toyota}
{1998 Toyota}
```
Selbst wenn Sie einen Zeiger als argument in einem Aufruf Println, d.h. fmt.Println(&myCar) Gehen macht immer noch einen Wert kopieren der Car struct , wenn ein Wert Empfänger verwendet wird. Die OP vermeiden will, Wert Kopien gemacht, und mein Fazit ist, dass nur Zeiger Empfänger die Erfüllung dieser Anforderung.

InformationsquelleAutor Paulo
-3

Im Allgemeinen ist es am besten zu vermeiden, zuweisen von Werten an Variablen, die über die statischen Initialisierungen, d.h.
```
f := Foo{bar:1,baz:"2"}
```
Dies ist, weil kann es schaffen, genau die Beschwerde, die Sie reden, wenn Sie vergessen, pass foo als Zeiger über &foo oder Sie sich entscheiden, Wert-Empfängern, die Sie am Ende macht eine Menge Klone Ihrer Werte.

Stattdessen versuchen, zuweisen von Zeigern auf statischen Initialisierungen standardmäßig, d.h.
```
f := &Foo{bar:1,baz:"2"}
```
Diese Weise f wird immer ein Zeiger und die einzige Zeit erhalten Sie einen Wert kopieren, wenn Sie explizit Wert-Receiver.

(Natürlich gibt es Zeiten, wenn Sie wollen, speichern Sie den Wert aus einem static-Initialisierer, aber diese sollten Grenzfälle)

InformationsquelleAutor JSS

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.