Fonction ToString() en Go

Question

El strings.Join ne prend que des tranches de chaînes de caractères :

s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", "))

Mais il serait agréable de pouvoir passer des objets arbitraires qui implémentent une fonction de type ToString() fonction.

type ToStringConverter interface {
    ToString() string
}

Existe-t-il quelque chose comme cela dans Go ou dois-je décorer les types existants comme int avec les méthodes ToString et écrire un wrapper autour de strings.Join ?

func Join(a []ToStringConverter, sep string) string

Answer 1

Attachez un String() string à tout type nommé et profiter de toute fonctionnalité "ToString" personnalisée :

package main

import "fmt"

type bin int

func (b bin) String() string {
        return fmt.Sprintf("%b", b)
}

func main() {
        fmt.Println(bin(42))
}

Terrain de jeux : http://play.golang.org/p/Azql7_pDAA

---

Sortie

101010

Answer 2

Lorsque vous avez votre propre struct vous auriez pu posséder convertir en chaîne de caractères fonction.

package main

import (
    "fmt"
)

type Color struct {
    Red   int `json:"red"`
    Green int `json:"green"`
    Blue  int `json:"blue"`
}

func (c Color) String() string {
    return fmt.Sprintf("[%d, %d, %d]", c.Red, c.Green, c.Blue)
}

func main() {
    c := Color{Red: 123, Green: 11, Blue: 34}
    fmt.Println(c) //[123, 11, 34]
}

Answer 3

Un autre exemple avec une structure :

package types

import "fmt"

type MyType struct {
    Id   int    
    Name string
}

func (t MyType) String() string {
    return fmt.Sprintf(
    "[%d : %s]",
    t.Id, 
    t.Name)
}

Soyez prudent lorsque vous l'utilisez,
Concaténation avec '+'. ne compile pas :

t := types.MyType{ 12, "Blabla" }

fmt.Println(t) // OK
fmt.Printf("t : %s \n", t) // OK
//fmt.Println("t : " + t) // Compiler error !!!
fmt.Println("t : " + t.String()) // OK if calling the function explicitly

Answer 4

• Cela fonctionne bien

` paquetage principal

import "fmt"

type Person struct {
    fname, sname string 
    address string 
}

func (p *Person) String() string {
    s:=  fmt.Sprintf("\n %s %s  lives at %s \n", p.fname, p.sname, p.address)
    return s
}

func main(){
    alex := &Person{"Alex", "Smith", "33 McArthur Bvd"}
    fmt.Println(alex)

}

` Sortie :

Alex Smith vit au 33 McArthur Bvd

Answer 5

Voici un moyen simple de gérer cette situation :

package main

import (
    "fat"
    "strconv"
)

type Person struct {
    firstName, lastName string
    age int
}

func (p Person) GetFullName() string {
    return p.firstName + " " + p.lastName
}

func (p Person) GetAge() int {
    return p.age
}

func (p Person) GetAgeAsString() string {
    return strconv.Itoa(p.age)
}

func main() {
    p := Person {"John", "Doe", 21}
    fmt.Println(p.GetFullName())
    fmt.Println(p.GetAgeAsString())
}

Sortie :

"John Doe"
"21"