Go语言模型:string的底层数据结构与高效操作详解

 package main import ( "fmt" "unsafe" ) // from: string.go 在GoLand IDE中双击shift快速找到 type stringStruct struct { array unsafe.Pointer // 指向一个 [len]byte 的数组 length int    // 长度 } func main() { test := "hello" p := (*str)(unsafe.Pointer(&test)) fmt.Println(&p, p) // 0xc420070018 &{0xa3f71 5} c := make([]byte, p.length) for i := 0; i  string, "hello" test2 := test + " world" // 字符串是不可变类型，会生成一个新的string实例 p2 := (*str)(unsafe.Pointer(&test2)) fmt.Println(&p2, p2) // 0xc420028030 &{0xc42000a2e5 11} fmt.Println(test2) // hello, world } 

 25		test2 := test + " world" 0x00000000004824d7 <+1127>:	lea 0x105a2(%rip),%rax  # 0x492a80 0x00000000004824de <+1134>:	mov %rax,(%rsp) 0x00000000004824e2 <+1138>:	callq 0x40dda0  # 调用newobject函数 0x00000000004824e7 <+1143>:	mov 0x8(%rsp),%rax 0x00000000004824ec <+1148>:	mov %rax,0xa0(%rsp) 0x00000000004824f4 <+1156>:	mov 0xa8(%rsp),%rax 0x00000000004824fc <+1164>:	mov 0x8(%rax),%rcx 0x0000000000482500 <+1168>:	mov (%rax),%rax 0x0000000000482503 <+1171>:	mov %rax,0x8(%rsp) 0x0000000000482508 <+1176>:	mov %rcx,0x10(%rsp) 0x000000000048250d <+1181>:	movq $0x0,(%rsp) 0x0000000000482515 <+1189>:	lea 0x30060(%rip),%rax  # 0x4b257c 0x000000000048251c <+1196>:	mov %rax,0x18(%rsp) 0x0000000000482521 <+1201>:	movq $0x6,0x20(%rsp) 0x000000000048252a <+1210>:	callq 0x43cc00  # 调用concatstring2函数 

 func concatstring2(buf *tmpBuf, a [2]string) string { return concatstrings(buf, a[:]) } // concatstrings implements a Go string concatenation x+y+z+... // The operands are passed in the slice a. // If buf != nil, the compiler has determined that the result does not // escape the calling function, so the string data can be stored in buf // if small enough. func concatstrings(buf *tmpBuf, a []string) string { idx := 0 l := 0 count := 0 for i, x := range a { n := len(x) if n == 0 { continue } if l+n 

 func main() { var buf bytes.Buffer for i := 0; i <10; i++ { buf.WriteString("hi ") } fmt.Println(buf.String()) }

 // @file: buffer.go func (b *Buffer) WriteString(s string) (n int, err error) { b.lastRead = opInvalid m, ok := b.tryGrowByReslice(len(s)) if !ok { m = b.grow(len(s)) // 高效的增长策略 -> let capacity get twice as large } return copy(b.buf[m:], s), nil } // @file: buffer.go // let capacity get twice as large !!! func (b *Buffer) grow(n int) int { m := b.Len() // If buffer is empty, reset to recover space. if m == 0 && b.off != 0 { b.Reset() } // Try to grow by means of a reslice. if i, ok := b.tryGrowByReslice(n); ok { return i } // Check if we can make use of bootstrap array. if b.buf == nil && n <= len(b.bootstrap) { b.buf = b.bootstrap[:n] return 0 } c := cap(b.buf) if n <= c/2-m { // We can slide things down instead of allocating a new // slice. We only need m+n <= c to slide, but // we instead let capacity get twice as large so we // don't spend all our time copying. copy(b.buf, b.buf[b.off:]) } else if c > maxInt-c-n { panic(ErrTooLarge) } else { // Not enough space anywhere, we need to allocate. buf := makeSlice(2*c + n) copy(buf, b.buf[b.off:]) b.buf = buf } // Restore b.off and len(b.buf). b.off = 0 b.buf = b.buf[:m+n] return m } 

 func main() { var strs []string for i := 0; i <10; i++ { strs = append(strs, "hi") } fmt.Println(strings.Join(strs, " ")) }

 // Join concatenates the elements of a to create a single string. The separator string // sep is placed between elements in the resulting string. func Join(a []string, sep string) string { switch len(a) { case 0: return "" case 1: return a[0] case 2: // Special case for common small values. // Remove if golang.org/issue/6714 is fixed return a[0] + sep + a[1] case 3: // Special case for common small values. // Remove if golang.org/issue/6714 is fixed return a[0] + sep + a[1] + sep + a[2] } // 计算好最终的string的大小 n := len(sep) * (len(a) - 1) // for i := 0; i 

 func main() { var s strings.Builder for i := 0; i <10; i++ { s.WriteString("hi ") } fmt.Println(s.String()) }

 @file: builder.go // WriteString appends the contents of s to b's buffer. // It returns the length of s and a nil error. func (b *Builder) WriteString(s string) (int, error) { b.copyCheck() b.buf = append(b.buf, s...) return len(s), nil }

 func boo(a int, b int)(int, string){ return a + b, "abcd" }

 81079 000000000044dfa0 : 81080 44dfa0:>------48 c7 44 24 18 00 00 >--movq $0x0,0x18(%rsp) 81081 44dfa7:>------00 00- 81082 44dfa9:>------0f 57 c0    >--xorps %xmm0,%xmm0 81083 44dfac:>------0f 11 44 24 20  >--movups %xmm0,0x20(%rsp) 81084 44dfb1:>------48 8b 44 24 08  >--mov 0x8(%rsp),%rax 81085 44dfb6:>------48 03 44 24 10  >--add 0x10(%rsp),%rax 81086 44dfbb:>------48 89 44 24 18  >--mov %rax,0x18(%rsp) 81087 44dfc0:>------48 8d 05 d4 eb 01 00 >--lea 0x1ebd4(%rip),%rax  # 46cb9b  81088 44dfc7:>------48 89 44 24 20  >--mov %rax,0x20(%rsp) 81089 44dfcc:>------48 c7 44 24 28 04 00 >--movq $0x4,0x28(%rsp) 81090 44dfd3:>------00 00- 81091 44dfd5:>------c3     >--retq---

 81087 44dfc0:>------48 8d 05 d4 eb 01 00 >--lea 0x1ebd4(%rip),%rax  # 46cb9b  81088 44dfc7:>------48 89 44 24 20  >--mov %rax,0x20(%rsp) 81089 44dfcc:>------48 c7 44 24 28 04 00 >--movq $0x4,0x28(%rsp) 81090 44dfd3:>------00 00- 81091 44dfd5:>------c3     >--retq--- lea 0x1ebd4(%rip),%rax得到char*, mov %rax,0x20(%rsp)复制给返回值, movq $0x4,0x28(%rsp)把长度也填进去,