One-liner pour transformer [] int en chaîne

Fondamentalement, je n'ai []int{1, 2, 3}je veux un one-liner qui transforme ce dans la chaîne de caractères "1, 2, 3" (j'ai besoin de le délimiteur à être personnalisées, parfois .parfois ,etc). Ci-dessous est le meilleur que je pouvais venir. Des recherches en ligne et ne semble pas trouver une meilleure réponse.

Dans la plupart des langues, il y a un support intégré pour cela, par exemple:

python:

> A = [1, 2, 3]
> ", ".join([str(a) for a in A])
'1, 2, 3'

aller:

package main

import (
    "bytes"
    "fmt"
    "strconv"
)

//Could not find a one-liner that does this :(.
func arrayToString(A []int, delim string) string {

    var buffer bytes.Buffer
    for i := 0; i < len(A); i++ {
        buffer.WriteString(strconv.Itoa(A[i]))
        if i != len(A)-1 {
            buffer.WriteString(delim)
        }
    }

    return buffer.String()
}

func main() {
    A := []int{1, 2, 3}
    fmt.Println(arrayToString(A, ", "))
}

Il doit sûrement y avoir un utilitaire enterré en ce qui me permet de le faire avec un one-liner?

Je sais qu'il y a strings.Join(A, ", ")mais qui ne fonctionne que si Un est déjà []chaîne.

source d'informationauteur N0thing

Pour convertir

A := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

à une ligne de chaîne délimitée comme

"1,2,3,4,5,6,7,8,9"

utilisation:

strings.Trim(strings.Join(strings.Fields(fmt.Sprint(A)), delim), "[]")

ou:

strings.Trim(strings.Join(strings.Split(fmt.Sprint(A), " "), delim), "[]")

ou:

strings.Trim(strings.Replace(fmt.Sprint(A), " ", delim, -1), "[]")

et de le retourner à partir d'une fonction comme dans cet exemple:

package main

import "fmt"
import "strings"

func arrayToString(a []int, delim string) string {
    return strings.Trim(strings.Replace(fmt.Sprint(a), " ", delim, -1), "[]")
    //return strings.Trim(strings.Join(strings.Split(fmt.Sprint(a), " "), delim), "[]")
    //return strings.Trim(strings.Join(strings.Fields(fmt.Sprint(a)), delim), "[]")
}

func main() {
    A := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

    fmt.Println(arrayToString(A, ",")) //1,2,3,4,5,6,7,8,9
}

Pour inclure un espace après la virgule que vous pourriez appeler arrayToString(A, ", ") ou, à l'inverse de définir le retour comme return strings.Trim(strings.Replace(fmt.Sprint(a), " ", delim + " ", -1), "[]") à la force de son insertion, après le séparateur.

Je viens de lancer dans le même problème aujourd'hui, puisque je n'ai pas trouvé quoi que ce soit sur la bibliothèque standard, j'ai recompilé 3 façons de faire cette conversion

Créer une chaîne et en ajoutant les valeurs du tableau par la conversion à l'aide de strconv.Ltid:

func IntToString1() string {
    a := []int{1, 2, 3, 4, 5}
    b := ""
    for _, v := range a {
        if len(b) > 0 {
            b += ","
        }
        b += strconv.Itoa(v)
    }

    return b
}

Créer un []chaîne, convertir chaque tableau de la valeur, et de renvoyer un joint de chaîne à partir de []chaîne:

func IntToString2() string {
    a := []int{1, 2, 3, 4, 5}
    b := make([]string, len(a))
    for i, v := range a {
        b[i] = strconv.Itoa(v)
    }

    return strings.Join(b, ",")
}

Convertir [], int à une chaîne et remplacer /garniture de la valeur:

func IntToString3() string {
    a := []int{1, 2, 3, 4, 5}
    return strings.Trim(strings.Replace(fmt.Sprint(a), " ", ",", -1), "[]")
}

La Performance est tout à fait différent en fonction de la mise en œuvre:

BenchmarkIntToString1-12         3000000           539 ns/op
BenchmarkIntToString2-12         5000000           359 ns/op
BenchmarkIntToString3-12         1000000          1162 ns/op

Personnellement, je vais aller avec IntToString2, de sorte que la fonction finale pourrait être un paquet util dans mon projet comme ceci:

func SplitToString(a []int, sep string) string {
    if len(a) == 0 {
        return ""
    }

    b := make([]string, len(a))
    for i, v := range a {
        b[i] = strconv.Itoa(v)
    }
    return strings.Join(b, sep)
}

Je crois que vous pouvez aller avec le fmt.Sprint famille de fonctions. Je ne suis pas expert en aller de mise en forme de drapeaux, et peut-être vous pouvez le faire avec juste un Sprintfmais ici, c'est un one-liner qui fonctionne:

data := []int{1,2,3}

func(x string) string { return x[6:len(x)-1]; }(fmt.Sprintf("%#v", data)) //1, 2, 3

En général, vous pouvez utiliser strings.Replace à venir avec différents séparateurs (aussi longtemps que vous pouvez sans problème remplacer le , ou le séparateur par défaut):

//Produces 1--2--3
magic := func(s, d string) string { return strings.Replace(s[1:len(s)-1], " ", d, -1)  }
fmt.Println(magic(fmt.Sprint([]int{1, 2, 3}), "--"))

//As one liner
fmt.Println(func(s, d string) string { return strings.Replace(s[1:len(s)-1], " ", d, -1)  }(fmt.Sprint([]int{1, 2, 3}), "--"))

Vous pouvez toujours json.Marshal:

data := []int{1,2,3}
s, _ := json.Marshal(data)
fmt.Println(string(s))
//output: [1, 2, 3]

Vous devez vous connecter pour publier un commentaire.