详解golangstring和[]byte的对比

type string

string is the set of all strings of 8-bit bytes, conventionally but not necessarily representing UTF-8-encoded text. A string may be empty, but not nil. Values of string type are immutable.

type stringStruct struct {

    str unsafe.Pointer

    len int}

func gostringnocopy(str *byte) string {

    ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}

    s := *(*string)(unsafe.Pointer(&ss))    return s

}

type slice struct { array unsafe.Pointer

    len   int

    cap   int}

s := "A1" // 分配存储"A1"的内存空间，s结构体里的str指针指向这快内存

s = "A2"  // 重新给"A2"的分配内存空间，s结构体里的str指针指向这快内存

s := []byte{1} // 分配存储1数组的内存空间，s结构体的array指针指向这个数组。s = []byte{2}  // 将array的内容改为2

func stringtoslicebyte(buf *tmpBuf, s string) []byte {  var b []byte

    if buf != nil && len(s) <= len(buf) {

        *buf = tmpBuf{}

        b = buf[:len(s)]

    } else {

        b = rawbyteslice(len(s))

    }

    copy(b, s)  return b

}func rawstring(size int) (s string, b []byte) {

    p := mallocgc(uintptr(size), nil, false)

    stringStructOf(&s).str = p  stringStructOf(&s).len = size

    *(*slice)(unsafe.Pointer(&b)) = slice{p, size, size}    return}

func slicebytetostring(buf *tmpBuf, b []byte) string {

    l := len(b) if l == 0 {     // Turns out to be a relatively common case.

        // Consider that you want to parse out data between parens in "foo()bar",

        // you find the indices and convert the subslice to string.

        return ""

    }   if raceenabled && l > 0 {

        racereadrangepc(unsafe.Pointer(&b[0]),

            uintptr(l),

            getcallerpc(unsafe.Pointer(&buf)),

            funcPC(slicebytetostring))

    }   if msanenabled && l > 0 {

        msanread(unsafe.Pointer(&b[0]), uintptr(l))

    }

    s, c := rawstringtmp(buf, l)

    copy(c, b)  return s

}func rawstringtmp(buf *tmpBuf, l int) (s string, b []byte) {   if buf != nil && l <= len(buf) {

        b = buf[:l]

        s = slicebytetostringtmp(b)

    } else {

        s, b = rawstring(l)

    }   return}

package string_slicebyte_testimport (   "log"

    "reflect"

    "testing"

    "unsafe")func stringtoslicebyte(s string) []byte {

    sh := (*reflect.StringHeader)(unsafe.Pointer(&s))

    bh := reflect.SliceHeader{

        Data: sh.Data,

        Len:  sh.Len,

        Cap:  sh.Len,

    }   return *(*[]byte)(unsafe.Pointer(&bh))

}func slicebytetostring(b []byte) string {

    bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))

    sh := reflect.StringHeader{

        Data: bh.Data,

        Len:  bh.Len,

    }   return *(*string)(unsafe.Pointer(&sh))

}func TestStringSliceByte(t *testing.T) {

    s1 := "abc"

    b1 := []byte("def")

    copy(b1, s1)

    log.Println(s1, b1)

    s := "hello"

    b2 := stringtoslicebyte(s)

    log.Println(b2)    // b2[0] = byte(99) unexpected fault address

    b3 := []byte("test")

    s3 := slicebytetostring(b3)

    log.Println(s3)

}