Однострочное преобразование [] int в строку

В принципе, у меня есть []int{1, 2, 3}, я хочу, чтобы однострочный, который преобразовывал это в строку "1, 2, 3" (мне нужно, чтобы разделитель был обычным, иногда ., иногда , и т.д.)., Ниже приводится лучшее, что я мог бы придумать. Поиск в Интернете и, похоже, не нашел лучшего ответа.

В большинстве языков встроенная поддержка для этого, например:

питон:

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

идут:

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

Конечно, должна быть утилита, заглубленная в путь, которая позволяет мне делать это с помощью одного лайнера?

Я знаю, что существует strings.Join(A, ", "), но это работает, только если A уже [].

Ответы

Ответ 1

Конвертировать
A := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

в строку с разделителями одной строки, например, "1,2,3,4,5,6,7,8,9"
Применение:

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

или

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

или

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

и вернуть его из функции, такой как в этом примере:

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
}

Чтобы включить пробел после запятой, вы можете вызвать arrayToString(A, ", ") или, наоборот, определить возврат как return strings.Trim(strings.Replace(fmt.Sprint(a), " ", delim + " ", -1), "[]"), чтобы принудительно вставить его после разделителя.

Ответ 2

Я сегодня столкнулся с одной и той же проблемой, так как я ничего не нашел в стандартной библиотеке, я перекомпилировал 3 способа сделать это преобразование

Создайте строку и добавьте значения из массива, преобразуя ее с помощью 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
}

Создайте строку [], преобразуйте каждое значение массива и верните объединенную строку из строки []:

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

Преобразовать [] int в строку и заменить/обрезать значение:

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

Производительность сильно различается в зависимости от реализации:

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

Лично я пойду с IntToString2, так что конечная функция может быть пакетом утилиты в моем проекте следующим образом:

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

Ответ 3

Я считаю, что вы можете пойти с семейством функций fmt.Sprint. Я не являюсь экспертом в форматировании флагов go, и, возможно, вы можете сделать это всего лишь с помощью Sprintf, но здесь работает однострочный файл:

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

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

В общем случае вы можете использовать strings.Replace для создания разных разделителей (если вы можете безопасно заменить разделитель по умолчанию , или ):

// 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}), "--"))