Verkettung von Funktionen in Go?

Habe ich versucht, dies zu tun:

package main

import (
    "fmt"
    "strings"
)

type String string


func (s *String) tolower() String {
    *s = String(strings.ToLower(string(*s)))
    return *s
}

func (s *String) toupper() String {
    *s = String(strings.ToUpper(string(*s)))
    return *s
}

func main() {
    var s String = "ASDF"
    (s.tolower()).toupper() //this fails
    //s.toupper();s.tolower(); //this works
    //s.tolower().toupper() //this fails too
    fmt.Println(s)
}

Aber ich habe diese Fehler:

prog.go:30: cannot call pointer method on s.tolower()
prog.go:30: cannot take the address of s.tolower()

Program exited.

Warum kann ich nicht machen diese Kette zu arbeiten?

Beachten Sie, dass s.tolower().toupper() wird auch funktionieren (Sie brauchen nicht die zusätzlichen Klammern: (s.tolower()).toupper()), zumindest im Gehen 1.1 (vielleicht scheitert es in der Go 1.0).

InformationsquelleAutor Derek | 2013-08-09

Dies funktioniert:

package main

import (
    "fmt"
    "strings"
)

type String string


func (s *String) tolower() *String {
    *s = String(strings.ToLower(string(*s)))
    return s
}

func (s *String) toupper() *String {
    *s = String(strings.ToUpper(string(*s)))
    return s
}

func main() {
    var s String = "ASDF"
    (s.tolower()).toupper()
    s.toupper();
    s.tolower();
    s.tolower().toupper()
    fmt.Println(s)
}

Ihr Rückgabetyp ist String-Funktionen definiert, die sich auf Zeiger auf String. Es würde keinen Sinn machen, um in der Lage sein Kette Sie.

InformationsquelleAutor Seth Hoenig

4

tolower() und toupper() haben Zeiger-auf-String, wie der Empfänger, aber Sie sind der Rückgabe-String (nicht-Zeiger-auf-String).

Können Sie dieses Problem beheben Sie, indem Sie eine oder das andere.

z.B. änderung der Signatur der Funktion: entweder
```
func (s *String) toupper() *String
```
oder
```
func (s String) toupper() String
```
(siehe: http://play.golang.org/p/FaCD8AQtIX)
- Nicht genau das, was ich versuche zu tun, ich will verändern Sie den Wert des Objekts, nicht eine neue zu erstellen.
InformationsquelleAutor mrjones
3

Beim Aufruf einer Methode mit einem Zeiger-Empfänger an eine variable (s in deinem Beispiel), dann eine Adresse von diesem Wert wird automatisch eingezogen werden. Also, Sie sind im Grunde die Berufung (&s).toupper(). Dieser Mechanismus funktioniert für alle Werte, die adressierbar.

Rückgabewerte von Funktionen sind nicht adressierbar, es sei denn, Sie speichern Sie in einer Variablen (so dass Sie einen festen Platz in der aktuellen stack-frame oder auf dem heap).

Ich würde empfehlen, die folgenden API, weil es aussieht wie die Benutzer der string-Typ ist, soll die Arbeit mit String und nicht *String. Deshalb macht es Sinn, design eine einheitliche API, die auch verwendet String um Verwirrung zu vermeiden. Übergeben Sie eine Zeichenfolge nach Wert ist extrem schnell sowieso, weil Sie umgesetzt werden als Hinweise auf immutable arrays intern:
```
func (s String) tolower() String {
    return String(strings.ToLower(string(s)))
}
```
Diesem Verfahren nicht mit einem Zeiger-Empfänger, weil es nicht zu ändern, um die aktuelle Zeichenfolge. Es gibt eine neue Zeichenfolge statt. Sie können auch einfach eine Kette dieser Methoden.

Alternativ können Sie die Methoden implementieren, die auf diese Weise:
```
func (s *String) tolower() *String {
    *s = String(strings.ToLower(string(*s)))
    return s
}
```
In diesem Fall, Sie immer wieder die gleichen Zeiger. Also, um zu rufen (s.tolower()).toupper() Sie müssen in der Lage sein, die Adresse s was möglich ist, da Sie zugewiesen haben es in eine variable. Dann alle weiteren Methodenaufrufe in der Kette sind ebenfalls möglich, da Sie diese aufrufen mit einem Zeiger auf die erste variable. Dies unterscheidet sich von Ihrem Versuch der Verkettung Methoden wurden jeweils den Aufruf der Methode muss die Adresse eine temporäre variable, um es zu ändern (was nicht sehr nützlich).

InformationsquelleAutor tux21b

vielleicht können Sie versuchen, dieses Projekt: https://github.com/Laisky/go-chaining

import "github.com/Laisky/go-chaining"

func toLower(c *chaining.Chain) (interface{}, error) {
    v := c.GetString()
    return strings.ToLower(v), nil
}

func toUpper(c *chaining.Chain) (interface{}, error) {
    v := c.GetString()
    return strings.ToUpper(v), nil
}

func TestChainWithString(t *testing.T) {
    f := func() (string, error) { return "aBcD", nil }
    r := chaining.New(f()).
        Next(toLower).
        Next(toUpper)

    expectVal := "ABCD"
    if r.GetString() != expectVal {
        t.Errorf("expect %v, got %v", expectVal, r.GetString())
    }
}

InformationsquelleAutor Laisky

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.