Golang切片连接成字符串的实现示例

不是不知道

目录

• 1.问题
  
• 2.使用反射实现
  
• 3.dablelv/cyan
  
• 4.小结
  
• 参考文献
  

1.问题

如何将一个切片连接成一个字符串呢？
您最先想到的可能是标准库 strings 包的 Join 函数。

1. func Join(elems []string, sep string) string

复制代码

Join 将字符串切片的所有元素连接成一个字符串，各个元素间使用给定的字符串分隔。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "strings"
   
6. )
   
7. 
   
8. func main() {
   
9.         s := []string{"foo", "bar", "baz"}
   
10.         fmt.Println(strings.Join(s, ", "))
    
11. }

复制代码

运行输出：

1. foo, bar, baz

复制代码

strings.Join 只能将字符串切片连接成字符串，但对于其他类型的切片呢？
事实上，标准库并没有针对每种类型的切片都给出一个实现，也没有使用反射给出一个通用的实现。既然没有那我们自己来实现一个吧。

2.使用反射实现

如果想要将任意类型的切片连接成字符串，可以使用反射（reflect）包来动态处理不同类型的切片，将元素转换为字符串，并连接成一个字符串。

1. // JoinE concatenates all elements of Array, Slice or String to a single string with a separator
   
2. // and returns an error if an error occurred.
   
3. // E.g. input []int{1, 2, 3} and separator ",", output is a string "1,2,3".
   
4. // It panics if a's Kind is not Array, Slice, or String.
   
5. func JoinE(a any, sep string) (string, error) {
   
6.         v := reflect.ValueOf(a)
   
7.         if v.Kind() == reflect.String {
   
8.                 return JoinE(strings.Split(a.(string), ""), sep)
   
9.         }
   
10.         var s string
    
11.         for i := 0; i < v.Len(); i++ {
    
12.                 if len(s) > 0 {
    
13.                         s += sep
    
14.                 }
    
15.                 str, err := conv.ToStringE(v.Index(i).Interface())
    
16.                 if err != nil {
    
17.                         return "", err
    
18.                 }
    
19.                 s += str
    
20.         }
    
21.         return s, nil
    
22. }

复制代码

其中 ToStringE 是将任意类型转为字符串。

1. // ToStringE casts any type to a string type.
   
2. func ToStringE(i any) (string, error) {
   
3.         i = indirectToStringerOrError(i)
   
4. 
   
5.         switch s := i.(type) {
   
6.         case string:
   
7.                 return s, nil
   
8.         case bool:
   
9.                 return strconv.FormatBool(s), nil
   
10.         case int:
    
11.                 return strconv.Itoa(s), nil
    
12.         case int64:
    
13.                 return strconv.FormatInt(s, 10), nil
    
14.         case int32:
    
15.                 return strconv.Itoa(int(s)), nil
    
16.         case int16:
    
17.                 return strconv.FormatInt(int64(s), 10), nil
    
18.         case int8:
    
19.                 return strconv.FormatInt(int64(s), 10), nil
    
20.         case uint:
    
21.                 return strconv.FormatUint(uint64(s), 10), nil
    
22.         case uint64:
    
23.                 return strconv.FormatUint(uint64(s), 10), nil
    
24.         case uint32:
    
25.                 return strconv.FormatUint(uint64(s), 10), nil
    
26.         case uint16:
    
27.                 return strconv.FormatUint(uint64(s), 10), nil
    
28.         case uint8:
    
29.                 return strconv.FormatUint(uint64(s), 10), nil
    
30.         case float64:
    
31.                 return strconv.FormatFloat(s, 'f', -1, 64), nil
    
32.         case float32:
    
33.                 return strconv.FormatFloat(float64(s), 'f', -1, 32), nil
    
34.         case json.Number:
    
35.                 return s.String(), nil
    
36.         case []byte:
    
37.                 return string(s), nil
    
38.         case template.HTML:
    
39.                 return string(s), nil
    
40.         case template.HTMLAttr:
    
41.                 return string(s), nil
    
42.         case template.URL:
    
43.                 return string(s), nil
    
44.         case template.JS:
    
45.                 return string(s), nil
    
46.         case template.JSStr:
    
47.                 return string(s), nil
    
48.         case template.CSS:
    
49.                 return string(s), nil
    
50.         case template.Srcset:
    
51.                 return string(s), nil
    
52.         case nil:
    
53.                 return "", nil
    
54.         case fmt.Stringer:
    
55.                 return s.String(), nil
    
56.         case error:
    
57.                 return s.Error(), nil
    
58.         default:
    
59.                 return "", fmt.Errorf("unable to cast %#v of type %T to string", i, i)
    
60.         }
    
61. }
    
62. 
    
63. // Copied from html/template/content.go.
    
64. // indirectToStringerOrError returns the value, after dereferencing as many times
    
65. // as necessary to reach the base type (or nil) or an implementation of fmt.Stringer
    
66. // or error.
    
67. func indirectToStringerOrError(a any) any {
    
68.         if a == nil {
    
69.                 return nil
    
70.         }
    
71.         v := reflect.ValueOf(a)
    
72.         for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Pointer && !v.IsNil() {
    
73.                 v = v.Elem()
    
74.         }
    
75.         return v.Interface()
    
76. }

复制代码

如果不关心错误，可以再封装一下。

1. // Join concatenates all elements of Array, Slice or String to a single string with a separator.
   
2. func Join(a any, sep string) string {
   
3.         s, _ := JoinE(a, sep)
   
4.         return s
   
5. }

复制代码

我们使用不同类型的切片来验证一下。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "strings"
   
6. )
   
7. 
   
8. func main() {
   
9.         s := []string{"foo", "bar", "baz"}
   
10.         fmt.Println(Join(s, ", "))
    
11.        
    
12.         i := []int{1, 2, 3}
    
13.         fmt.Println(Join(i, ", "))
    
14. 
    
15.         f := []float64{1.1, 2.2, 3.3}
    
16.         fmt.Println(Join(f, ", "))
    
17.        
    
18.         b := []bool{true, false, true}
    
19.         fmt.Println(Join(b, ", "))
    
20. 
    
21.         // 可以将字符串看成字符切片。
    
22.         str := "foo"
    
23.         fmt.Println(Join(str, ", "))
    
24. }

复制代码

运行输出：

1. foo, bar, baz1, 2, 31.1, 2.2, 3.3true, false, truef, o, o

复制代码

输出符合预期，我们通过反射，只用一个函数便可将任意类型的切片连接成字符串。

3.dablelv/cyan

以上代码已放到开源 Go 工具函数库 dablelv/cyan，可直接通过 go mod 方式进行 import 然后使用。
欢迎大家协同共建该工具函数库。

1. import (
   
2.         "github.com/dablelv/cyan/str"
   
3. )
   
4. 
   
5. str.Join([]string{"foo", "bar", "baz"}, ", ")
   
6. str.Join([]int{1, 2, 3}, ", ")
   
7. str.Join([]float64{1.1, 2.2, 3.3}, ", ")
   
8. str.Join([]bool{true, false, true}, ", ")
   
9. str.Join("foo", ", ")

复制代码

4.小结

对于字符串切片可以使用标准库 strings.Join 函数，对于其他任意类型的切片，利用 Golang 提供的反射能力，在运行时将切片元素转换为字符串并连接到一起。

参考文献

strings - Go Packages
github.com/dablelv/go-huge-util
到此这篇关于Golang切片连接成字符串的实现示例的文章就介绍到这了,更多相关Golang切片连接成字符串内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

静止684

感谢楼主，顶。

水云洞天拿

路过，支持一下