字符串拼接的几种方式对比

func Benchmark_test(b *testing.B) {
	for i := 0; i < b.N ; i++ {
		s := make([]int, 0)
		for i := 0; i < 10000; i++ {
			s = append(s, i)
		}
	}
}

$ go test -bench=. -benchmem
goos: darwin
goarch: amd64
pkg: program/benchmark
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
Benchmark_test-12        7439091               152.0 ns/op           248 B/op          5 allocs/op
PASS
ok      promgram/benchmark    1.304s

package main

import "fmt"

func main() {
	name := "name"
	val := "tony"
	age := "18"
	sex := "male"
	country := "china"
	city := "bj"
	str := name + val + sex + age + country + city
	fmt.Println(str)
}

        0x021c 00540 (test.go:12)       MOVL    $6, CX
        0x0221 00545 (test.go:12)       MOVQ    CX, DI
        0x0224 00548 (test.go:12)       PCDATA  $1, $0
        0x0224 00548 (test.go:12)       CALL    runtime.concatstrings(SB)
        0x0229 00553 (test.go:12)       MOVQ    AX, "".str+88(SP)
        0x022e 00558 (test.go:12)       MOVQ    BX, "".str+96(SP)
        0x0233 00563 (test.go:13)       MOVUPS  X15, ""..autotmp_8+168(SP)
        0x023c 00572 (test.go:13)       LEAQ    ""..autotmp_8+168(SP), DX
        0x0244 00580 (test.go:13)       MOVQ    DX, ""..autotmp_12+40(SP)

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 < l {
			throw("string concatenation too long")
		}
		l += n
		count++
		idx = i
	}
	if count == 0 {
		return ""
	}

	// If there is just one string and either it is not on the stack
	// or our result does not escape the calling frame (buf != nil),
	// then we can return that string directly.
	if count == 1 && (buf != nil || !stringDataOnStack(a[idx])) {
		return a[idx]
	}
	//会涉及内存申请
	s, b := rawstringtmp(buf, l)
	for _, x := range a {
		//内存拷贝
		copy(b, x)
		b = b[len(x):]
	}
	return s
}

str := name + val
str += sex
str += age
str += country
str += city

func Sprintf(format string, a ...interface{}) string {
	p := newPrinter()
	p.doPrintf(format, a)
	s := string(p.buf)
	p.free()
	return s
}

func (p *pp) doPrintf(format string, a []interface{}) {
	end := len(format)
	argNum := 0         // we process one argument per non-trivial format
	afterIndex := false // previous item in format was an index like [3].
	p.reordered = false
formatLoop:
	for i := 0; i < end; {
		p.goodArgNum = true
		lasti := i
		for i < end && format[i] != '%' {
			i++ // 一直累加 直到遇到 ‘%’ 或者到达format的末尾
		}
		if i > lasti {
			p.buf.WriteString(format[lasti:i]) // 输出普通字符
		}
		if i >= end {
			// done processing format string
			break
		}

		// Process one verb
		i++ // 将索引后移 比如遇到了%d 那么i++之后就会指向d

		// Do we have flags?
		p.fmt.clearflags() // 确保fmtFlags被清空 可能并不需要这么做 但是加上比较稳妥
	simpleFormat:
		for ; i < end; i++ {
			c := format[i]
            // 记录 '#' '0' '+' '-' ' ' 标记 在打印不同类型的地方 会根据标记 有不同的处理
			switch c {
			case '#':
				p.fmt.sharp = true
			case '0':
				p.fmt.zero = !p.fmt.minus // Only allow zero padding to the left.
			case '+':
				p.fmt.plus = true
			case '-':
				p.fmt.minus = true
				p.fmt.zero = false // Do not pad with zeros to the right.
			case ' ':
				p.fmt.space = true
			default:
				// Fast path for common case of ascii lower case simple verbs
				// without precision or width or argument indices.
				if 'a' <= c && c <= 'z' && argNum < len(a) {
					// %v 打印值的默认格式
					if c == 'v' {
						// %+v 如果是结构体 打印字段名
						// Go syntax
						p.fmt.sharpV = p.fmt.sharp
						p.fmt.sharp = false
						// %#v 用go的语法格式打印
						// Struct-field syntax
						p.fmt.plusV = p.fmt.plus
						p.fmt.plus = false
					}
					// 打印参数
					p.printArg(a[argNum], rune(c))
					argNum++
					i++
					continue formatLoop
				}
				// Format is more complex than simple flags and a verb or is malformed.
				break simpleFormat
			}
		}

		// 处理使用[] 指定参数值索引的情况
		// Do we have an explicit argument index?
		argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))

		// ‘*’ 通过参数指定宽度或精度
		// Do we have width?
		if i < end && format[i] == '*' {
			i++
			p.fmt.wid, p.fmt.widPresent, argNum = intFromArg(a, argNum)

			if !p.fmt.widPresent {
				p.buf.WriteString(badWidthString)
			}

			// We have a negative width, so take its value and ensure
			// that the minus flag is set
			if p.fmt.wid < 0 {
				p.fmt.wid = -p.fmt.wid
				p.fmt.minus = true
				p.fmt.zero = false // Do not pad with zeros to the right.
			}
			afterIndex = false
		} else {
			// 使用数字指定宽度
			p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
			if afterIndex && p.fmt.widPresent { // "%[3]2d"
				p.goodArgNum = false
			}
        }

		// 处理精度
		// Do we have precision?
		if i+1 < end && format[i] == '.' {
			i++
			if afterIndex { // "%[3].2d"
				p.goodArgNum = false
			}
			argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
			if i < end && format[i] == '*' {
				i++
				p.fmt.prec, p.fmt.precPresent, argNum = intFromArg(a, argNum)
				// Negative precision arguments don't make sense
				if p.fmt.prec < 0 {
					p.fmt.prec = 0
					p.fmt.precPresent = false
				}
				if !p.fmt.precPresent {
					p.buf.WriteString(badPrecString)
				}
				afterIndex = false
			} else {
				p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i, end)
				if !p.fmt.precPresent {
					p.fmt.prec = 0
					p.fmt.precPresent = true
				}
			}
		}

		if !afterIndex {
			argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
		}

		if i >= end {
			p.buf.WriteString(noVerbString)
			break
		}

		verb, size := rune(format[i]), 1
		if verb >= utf8.RuneSelf {
			verb, size = utf8.DecodeRuneInString(format[i:])
		}
		i += size

		switch {
		case verb == '%': // Percent does not absorb operands and ignores f.wid and f.prec.
			p.buf.WriteByte('%') // 使用 ‘%%’ 来打印 ‘%’
		case !p.goodArgNum:
			p.badArgNum(verb)
		case argNum >= len(a): // No argument left over to print for the current verb.
			p.missingArg(verb) // 参数数量不足
		case verb == 'v':
			// Go syntax
			p.fmt.sharpV = p.fmt.sharp
			p.fmt.sharp = false
			// Struct-field syntax
			p.fmt.plusV = p.fmt.plus
			p.fmt.plus = false
			fallthrough
		default:
			p.printArg(a[argNum], verb)
			argNum++
		}
	}

	// 处理参数多于占位符的情况
	// Check for extra arguments unless the call accessed the arguments
	// out of order, in which case it's too expensive to detect if they've all
	// been used and arguably OK if they're not.
	if !p.reordered && argNum < len(a) {
		p.fmt.clearflags()
		p.buf.WriteString(extraString)
		for i, arg := range a[argNum:] {
			if i > 0 {
				p.buf.WriteString(commaSpaceString)
			}
			if arg == nil {
				p.buf.WriteString(nilAngleString)
			} else {
				p.buf.WriteString(reflect.TypeOf(arg).String())
				p.buf.WriteByte('=')
				p.printArg(arg, 'v')
			}
		}
		p.buf.WriteByte(')')
	}
}

func (p *pp) printArg(arg interface{}, verb rune) {
	p.arg = arg
	p.value = reflect.Value{}

	if arg == nil {
		switch verb {
		case 'T', 'v':
			p.fmt.padString(nilAngleString)
		default:
			p.badVerb(verb)
		}
		return
	}

	// Special processing considerations.
	// %T (the value's type) and %p (its address) are special; we always do them first.
	switch verb {
	case 'T': // 打印类型
		p.fmt.fmt_s(reflect.TypeOf(arg).String())
		return
	case 'p': // 打印指针
		p.fmtPointer(reflect.ValueOf(arg), 'p')
		return
	}

	// Some types can be done without reflection.
	switch f := arg.(type) {
	case bool:
		p.fmtBool(f, verb)
	case float32:
		p.fmtFloat(float64(f), 32, verb)
	case float64:
		p.fmtFloat(f, 64, verb)
	case complex64:
		p.fmtComplex(complex128(f), 64, verb)
	case complex128:
		p.fmtComplex(f, 128, verb)
	case int:
		p.fmtInteger(uint64(f), signed, verb)
	case int8:
		p.fmtInteger(uint64(f), signed, verb)
	case int16:
		p.fmtInteger(uint64(f), signed, verb)
	case int32:
		p.fmtInteger(uint64(f), signed, verb)
	case int64:
		p.fmtInteger(uint64(f), signed, verb)
	case uint:
		p.fmtInteger(uint64(f), unsigned, verb)
	case uint8:
		p.fmtInteger(uint64(f), unsigned, verb)
	case uint16:
		p.fmtInteger(uint64(f), unsigned, verb)
	case uint32:
		p.fmtInteger(uint64(f), unsigned, verb)
	case uint64:
		p.fmtInteger(f, unsigned, verb)
	case uintptr:
		p.fmtInteger(uint64(f), unsigned, verb)
	case string:
		p.fmtString(f, verb)
	case []byte:
		p.fmtBytes(f, verb, "[]byte")
	case reflect.Value:
		// Handle extractable values with special methods
		// since printValue does not handle them at depth 0.
		if f.IsValid() && f.CanInterface() {
			p.arg = f.Interface()
			if p.handleMethods(verb) {
				return
			}
		}
		p.printValue(f, verb, 0)
	default:
		// If the type is not simple, it might have methods.
		if !p.handleMethods(verb) {
			// Need to use reflection, since the type had no
			// interface methods that could be used for formatting.
			p.printValue(reflect.ValueOf(f), verb, 0)
		}
	}
}

		var buffer bytes.Buffer
		n := 0
		for j := 0; j < len(list); j++ {
			n += len(list[j])
		}
		buffer.Grow(n)
		for j := 0; j < len(list); j++ {
			buffer.WriteString(list[j])
		}
		tmp := buffer.String()
		_ = tmp

		var builder strings.Builder
		for j := 0; j < len(list); j++ {
			builder.WriteString(list[j])
		}
		tmp := builder.String()
		_ = tmp

func Join(elems []string, sep string) string {
	switch len(elems) {
	case 0:
		return ""
	case 1:
		return elems[0]
	}
	n := len(sep) * (len(elems) - 1)
	for i := 0; i < len(elems); i++ {
		n += len(elems[i])
	}

	var b Builder
	b.Grow(n)
	b.WriteString(elems[0])
	for _, s := range elems[1:] {
		b.WriteString(sep)
		b.WriteString(s)
	}
	return b.String()
}

package string_test10_test

import (
	"bytes"
	"fmt"
	"strings"
	"testing"
)

var (
	list = []string{"test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10"}
)

func BenchmarkOperatorOnce(b *testing.B) {
	for i := 0; i < b.N; i++ {
		tmp := list[0] + list[1] + list[2] + list[3] + list[4] + list[5] + list[6] + list[7] + list[8] + list[9]
		_ = tmp
	}
}

func BenchmarkOperatorLoop(b *testing.B) {
	for i := 0; i < b.N; i++ {
		tmp := ""
		for _, data := range list {
			tmp += data
		}
		_ = tmp
	}
}

func BenchmarkSprintf(b *testing.B) {
	for i := 0; i < b.N; i++ {
		tmp := fmt.Sprintf("%s%s%s%s%s%s%s%s%s%s", list[0], list[1], list[2], list[3], list[4], list[5], list[6], list[7], list[8], list[9])
		_ = tmp
	}
}

func BenchmarkJoin(b *testing.B) {
	for i := 0; i < b.N; i++ {
		tmp := strings.Join(list, "")
		_ = tmp
	}
}

func BenchmarkBuffer(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var buffer bytes.Buffer
		for j := 0; j < len(list); j++ {
			buffer.WriteString(list[j])
		}
		tmp := buffer.String()
		_ = tmp
	}
}

func BenchmarkBufferOptimize(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var buffer bytes.Buffer
		n := 0
		for j := 0; j < len(list); j++ {
			n += len(list[j])
		}
		buffer.Grow(n)
		for j := 0; j < len(list); j++ {
			buffer.WriteString(list[j])
		}
		tmp := buffer.String()
		_ = tmp
	}
}

func BenchmarkBuilder(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var builder strings.Builder
		for j := 0; j < len(list); j++ {
			builder.WriteString(list[j])
		}
		tmp := builder.String()
		_ = tmp
	}
}

func BenchmarkBuilderOptimize(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var builder strings.Builder
		n := 0
		for j := 0; j < len(list); j++ {
			n += len(list[j])
		}
		builder.Grow(n)
		for j := 0; j < len(list); j++ {
			builder.WriteString(list[j])
		}
		tmp := builder.String()
		_ = tmp
	}
}