Brave Search

How to efficiently concatenate strings in go

stackoverflow.com › questions › 1760757 › how-to-efficiently-concatenate-strings-in-go

New Way:

From Go 1.10 there is a strings.Builder type, please take a look at this answer for more detail.

Old Way:

Use the bytes package. It has a Buffer type which implements io.Writer.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buffer bytes.Buffer

    for i := 0; i < 1000; i++ {
        buffer.WriteString("a")
    }

    fmt.Println(buffer.String())
}

This does it in O(n) time.

Answer from marketer on Stack Overflow

Go Packages

pkg.go.dev › strings

strings package - strings - Go Packages

String returns the accumulated string. ... Write appends the contents of p to b's buffer. Write always returns len(p), nil. ... WriteByte appends the byte c to b's buffer. The returned error is always nil. ... WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer. It returns the length of r and a nil error. func (b *Builder) WriteString(s string) (int, error)

Stack Overflow

stackoverflow.com › questions › 1760757 › how-to-efficiently-concatenate-strings-in-go

How to efficiently concatenate strings in go - Stack Overflow

New Way:

From Go 1.10 there is a strings.Builder type, please take a look at this answer for more detail.

Old Way:

Use the bytes package. It has a Buffer type which implements io.Writer.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buffer bytes.Buffer

    for i := 0; i < 1000; i++ {
        buffer.WriteString("a")
    }

    fmt.Println(buffer.String())
}

This does it in O(n) time.

2 of 16

644

In Go 1.10+ there is strings.Builder, here.

A Builder is used to efficiently build a string using Write methods. It minimizes memory copying. The zero value is ready to use.

Example

It's almost the same with bytes.Buffer.

package main

import (
    "strings"
    "fmt"
)

func main() {
    // ZERO-VALUE:
    //
    // It's ready to use from the get-go.
    // You don't need to initialize it.
    var sb strings.Builder

    for i := 0; i < 1000; i++ {
        sb.WriteString("a")
    }

    fmt.Println(sb.String())
}

Click to see this on the playground.

Supported Interfaces

strings.Builder's methods are being implemented with the existing interfaces in mind so that you can switch to the new Builder type easily in your code.

Method Signature	Interface	Description
`Grow(int)`	`bytes.Buffer`	Grows the buffer's capacity by the specified amount. See bytes.Buffer#Grow for more information.
`Len() int`	`bytes.Buffer`	Returns the number of bytes in the buffer. See bytes.Buffer#Len for more information.
`Reset()`	`bytes.Buffer`	Resets the buffer to be empty. See bytes.Buffer#Reset for more information.
`String() string`	`fmt.Stringer`	Returns the contents of the buffer as a string. See fmt.Stringer for more information.
`Write([]byte) (int, error)`	`io.Writer`	Writes the given bytes to the buffer. See io.Writer for more information.
`WriteByte(byte) error`	`io.ByteWriter`	Writes the given byte to the buffer. See io.ByteWriter for more information.
`WriteRune(rune) (int, error)`	`bufio.Writer` or `bytes.Buffer`	Writes the given rune to the buffer. See bufio.Writer#WriteRune or bytes.Buffer#WriteRune for more information.
`WriteString(string) (int, error)`	`io.stringWriter`	Writes the given string to the buffer. See io.stringWriter for more information.

Differences from bytes.Buffer

It can only grow or reset.
It has a copyCheck mechanism built-in that prevents accidentally copying it. In bytes.Buffer, one can access the underlying bytes like this: (*Buffer).Bytes(). strings.Builder prevents this problem. Sometimes, this is not a problem, though, and is desired instead. For example: For the peeking behavior when the bytes are passed to an io.Reader etc.
bytes.Buffer.Reset() rewinds and reuses the underlying buffer whereas the strings.Builder.Reset() does not, it detaches the buffer.

Note

Do not copy a strings.Builder value as it caches the underlying data.
If you want to share a strings.Builder value, use a pointer to it.

Check out its source code for more details, here.

Discussions

strings: Copying Builders allows string mutation

I think another level of indirection is needed in the implementation, so that the internal buffer is shared even after a copy has been made More on github.com

github.com

December 11, 2017

proposal: strings: string transformation functions for Builder

Proposal Details There is currently no support for appending the result of any of the string transformation functions1 (Join, Replace(All)?, Repeat, Map, To(Title|Upper|Lower)(Special)?, ToValidUtf... More on github.com

github.com

January 29, 2024

proposal: strings/builder: strings.Builder.Set(index, byte)

However, currently there is no way to modify a specific byte in the strings.Builder after writing, such as replacing the last comma with a closing brace (}). More on github.com

github.com

April 7, 2025

I created a strings.Builder alternative that is more efficient

You may also on 125-126 lines consider instead of s.buf = [][]string{} s.reverseBuf = [][]string{} just resetting slice lengths to not create tasks for garbage collector immediately and also probably reuse some allocated memory s.buf = s.buf[:0] s.reverseBuf = s.reverseBuf[:0] More on reddit.com

r/golang

May 10, 2025

Videos