[]string)编码和解码成字节数组 ([]byte)的最佳方法是什么?[]byte(str))。[]byte到[]string的转换也要支持。先不考虑这是Go语言。第一件事就是需要一个序列化格式将[]string编组。
有很多选择。你可以自己构建或使用库。我假设你不想自己构建并直接跳到Go支持的序列化格式。
在所有示例中，数据是[]string，fp是你要读取/写入的文件。错误被忽略，请检查函数的返回值以处理错误。
Gob是仅适用于Go的二进制格式。随着字符串数量的增加，它应该相对占用空间较少。
enc := gob.NewEncoder(fp)
enc.Encode(data)
阅读也很简单
var data []string
dec := gob.NewDecoder(fp)
dec.Decode(&data)
Gob 简单明了，但其格式只能与其他 Go 代码一起阅读。
接下来是 Json。Json 是一种几乎在任何地方都被使用的格式。这种格式同样容易使用。
enc := json.NewEncoder(fp)
enc.Encode(data)
关于阅读：
var data []string
dec := json.NewDecoder(fp)
dec.Decode(&data)
XML是另一种常见的格式。然而，它具有相当高的开销并且不太容易使用。虽然您可以像处理gob和json一样来处理它，但适当的xml需要一个根标记。在本例中，我们使用根标记“Strings”，每个字符串都包含在“S”标记中。
type Strings struct {
S []string
}
enc := xml.NewEncoder(fp)
enc.Encode(Strings{data})
var x Strings
dec := xml.NewDecoder(fp)
dec.Decode(&x)
data := x.S
CSV与其他文件格式不同。您有两个选项，使用一个包含n行的记录或n个只有1行的记录。以下示例使用n个只有1行的记录。如果我使用一个记录将会很无聊，看起来太像其他文件格式了。CSV只能保存字符串。
enc := csv.NewWriter(fp)
for _, v := range data {
enc.Write([]string{v})
}
enc.Flush()
阅读：
var err error
var data string
dec := csv.NewReader(fp)
for err == nil { // reading ends when an error is reached (perhaps io.EOF)
var s []string
s, err = dec.Read()
if len(s) > 0 {
data = append(data, s[0])
}
}
gob包会为您完成这个任务 http://godoc.org/encoding/gob
可供测试的示例 http://play.golang.org/p/e0FEZm-qiS
以下是相同的源代码。
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
func main() {
// store to byte array
strs := []string{"foo", "bar"}
buf := &bytes.Buffer{}
gob.NewEncoder(buf).Encode(strs)
bs := buf.Bytes()
fmt.Printf("%q", bs)
// Decode it back
strs2 := []string{}
gob.NewDecoder(buf).Decode(&strs2)
fmt.Printf("%v", strs2)
}
使用字符串包很容易完成。首先，您需要将字符串切片转换为字符串。
func Join(elems []string, sep string) string
package main
import (
"fmt"
"strings"
)
func main() {
//Slice of Strings
sliceStr := []string{"a","b","c","d"}
fmt.Println(sliceStr) //prints [a b c d]
//Converting slice of String to String
str := strings.Join(sliceStr,"")
fmt.Println(str) // prints abcd
//Converting String to slice of Bytes
sliceByte := []byte(str) //prints [97 98 99 100]
fmt.Println(sliceByte)
//Converting slice of bytes a String
str2 := string(sliceByte)
fmt.Println(str2) // prints abcd
//Converting string to a slice of Strings
sliceStr2 := strings.Split(str2,"")
fmt.Println(sliceStr2) //prints [a b c d]
}
[]string转换为[]byte。var str = []string{"str1","str2"}
var x = []byte{}
for i:=0; i<len(str); i++{
b := []byte(str[i])
for j:=0; j<len(b); j++{
x = append(x,b[j])
}
}
将[]byte转换为string
str := ""
var x = []byte{'c','a','t'}
for i := 0; i < len(x); i++ {
str += string(x[i])
}
for _, s := range str { x = append(x, s...) }。但这并不能解决问题：“解决方案必须能够将其从[]byte转换为string[]。” - peterSO[]string转换为[]byte，然后再将[]byte转换为[]string。这比你想象的要难。 - peterSO[]string转换为[]byte，然后再将[]byte转换回[]string，这里提供一个简单的解决方案：package main
import (
"encoding/binary"
"fmt"
)
const maxInt32 = 1<<(32-1) - 1
func writeLen(b []byte, l int) []byte {
if 0 > l || l > maxInt32 {
panic("writeLen: invalid length")
}
var lb [4]byte
binary.BigEndian.PutUint32(lb[:], uint32(l))
return append(b, lb[:]...)
}
func readLen(b []byte) ([]byte, int) {
if len(b) < 4 {
panic("readLen: invalid length")
}
l := binary.BigEndian.Uint32(b)
if l > maxInt32 {
panic("readLen: invalid length")
}
return b[4:], int(l)
}
func Decode(b []byte) []string {
b, ls := readLen(b)
s := make([]string, ls)
for i := range s {
b, ls = readLen(b)
s[i] = string(b[:ls])
b = b[ls:]
}
return s
}
func Encode(s []string) []byte {
var b []byte
b = writeLen(b, len(s))
for _, ss := range s {
b = writeLen(b, len(ss))
b = append(b, ss...)
}
return b
}
func codecEqual(s []string) bool {
return fmt.Sprint(s) == fmt.Sprint(Decode(Encode(s)))
}
func main() {
var s []string
fmt.Println("equal", codecEqual(s))
s = []string{"", "a", "bc"}
e := Encode(s)
d := Decode(e)
fmt.Println("s", len(s), s)
fmt.Println("e", len(e), e)
fmt.Println("d", len(d), d)
fmt.Println("equal", codecEqual(s))
}
输出：
equal true
s 3 [ a bc]
e 19 [0 0 0 3 0 0 0 0 0 0 0 1 97 0 0 0 2 98 99]
d 3 [ a bc]
equal true
len(s)，并使用 []byte(str) 将 str 传递给某个 io.Writer。通过从 Uvarint 中获取字符串长度，可以创建一个缓冲区 buf := make([]byte, n) 并将其传递给某个 io.Reader。
var lines = []string
var ctx = []byte{}
for _, s := range lines {
ctx = append(ctx, []byte(s)...)
}