Basically I have []int{1, 2, 3}, I want a one-liner that transforms this into the string "1, 2, 3" (I need the delimiter to be custom, sometimes ., sometimes ,, etc). Below is the best I could come up with. Searched online and did not seem to find a better answer.
In most languages there is in-built support for this, e.g.:
python:
> A = [1, 2, 3]
> ", ".join([str(a) for a in A])
'1, 2, 3'
go:
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, ", "))
}
Surely there must be an utility buried into go that allows me to do this with a one-liner?
I know that there is strings.Join(A, ", "), but that only works if A is already []string.
To convertA := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
to a one line delimited string like
"1,2,3,4,5,6,7,8,9"
use:
strings.Trim(strings.Join(strings.Fields(fmt.Sprint(A)), delim), "[]")
or:
strings.Trim(strings.Join(strings.Split(fmt.Sprint(A), " "), delim), "[]")
or:
strings.Trim(strings.Replace(fmt.Sprint(A), " ", delim, -1), "[]")
and return it from a function such as in this example:
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
}
To include a space after the comma you could call arrayToString(A, ", ") or conversely define the return as return strings.Trim(strings.Replace(fmt.Sprint(a), " ", delim + " ", -1), "[]") to force its insertion after the delimiter.
I believe that you can go with the fmt.Sprint family of functions. I am not expert in go formatting flags, and maybe you can make it with just a Sprintf, but here's a one-liner that works:
data := []int{1,2,3}
func(x string) string { return x[6:len(x)-1]; }(fmt.Sprintf("%#v", data)) // 1, 2, 3
In general, you could use strings.Replace to come up with different separators (as long as you can safely replace the , or default separator):
// 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}), "--"))
I've just run into the same problem today, since I've not found anything on standard library, I've recompiled 3 ways to do this conversion
Create a string and appending the values from the array by converting it using strconv.Itoa:
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
}
Create a []string, convert each array value and then return a joined string from []string:
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, ",")
}
Convert the []int to a string and replace / trim the value:
func IntToString3() string {
a := []int{1, 2, 3, 4, 5}
return strings.Trim(strings.Replace(fmt.Sprint(a), " ", ",", -1), "[]")
}
Performance is quite different depending on implementation:
BenchmarkIntToString1-12 3000000 539 ns/op
BenchmarkIntToString2-12 5000000 359 ns/op
BenchmarkIntToString3-12 1000000 1162 ns/op
Personally, I'll go with IntToString2, so the final function could be an util package in my project like this:
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)
}
You can always json.Marshal:
data := []int{1,2,3}
s, _ := json.Marshal(data)
fmt.Println(string(s))
// output: [1, 2, 3]