How to (deep) copy a string in Go?

String in go are immutable once created. Go specs

I will prefer builder as below. You go on adding to buffer of builder (mutably) WriteString and once done call String method which is returning pointer and not another copy of the buffer slice.

    somestring := "Hello Go"
    var sb strings.Builder
    if _, err := sb.WriteString(somestring); err != nil {
        //log & return
    }
    newstring := sb.String()

Check the implementation of String() of builder from go source. It is returning pointer and cast as *string. No second copy.

// String returns the accumulated string.
func (b *Builder) String() string {
    return *(*string)(unsafe.Pointer(&b.buf))
}

The string is implemented as a pointer to the underlying byte array and the length of the string. When you create a slice from an existing string, the new string still points to the underlying array, possibly to a different offset in that array, with a different length. That way, many small strings can use the single underlying large array.

As you noted, if you have a large string and you parse it to get smaller strings, you end up keeping the large string in memory, because the GC only knows about the underlying array and pointers to it. There are two ways you can deal with this:

• Instead of a large string, keep a []byte or use a byte-stream based reader/scanner, and as you parse create strings from the input. That way GC will collect the underlying []byte when parsing is done and you will have your strings without the underlying large block.
• Do what you already described, and deep-copy string using string([]byte(s[x:y])), or by using copy.

Use the following function to deep copy a string:

func deepCopy(s string) string {
    b := make([]byte, len(s))
    copy(b, s)
    return *(*string)(unsafe.Pointer(&b))
}

The function copies the data to a newly allocated slice of bytes. The function uses the unsafe package to convert the slice header to a string header with no copying of the bytes.

If direct use of the unsafe package is a concern, then use strings.Builder. The strings.Builder type executes the unsafe shenanigans under the covers.

 func deepCopy(s string) string {
     var sb strings.Builder
     sb.WriteString(s)
     return sb.String()
 }

There's no need to check the error returned from sb.WriteString. The Builder.WriteString method has an error return so that the Builder type satisfies the io.StringWriter interface, not because WriteString can return a non-nil error.

The alternative would be, starting with go 1.18 (Q4 2021):

sCopy := strings.Clone(s)

It comes from issues 40200 and 45038, and starts in CLs (change lists) 334884 and 345849

bytes, strings: add Clone

Working directly with []byte and string are common and needing to copy them comes up fairly often.
This change adds a Clone helper to both strings and bytes to fill this need.
A benchmark was also added to provide evidence for why bytes.Clone was implemented with copy.

strings: add Clone function

The new strings.Clone function copies the input string without the returned cloned string referencing the input strings memory

See strings/clone.go

// Clone returns a fresh copy of s.
//
// It guarantees to make a copy of s into a new allocation,
// which can be important when retaining only a small substring
// of a much larger string. Using Clone can help such programs
// use less memory. 
//
// Of course, since using Clone makes a copy,
// overuse of Clone can make programs use more memory.
//
// Clone should typically be used only rarely, and only when
// profiling indicates that it is needed.
//
func Clone(s string) string {
    b := make([]byte, len(s))
    copy(b, s)
    return *(*string)(unsafe.Pointer(&b))
}

Another way of cloning a string is to create a new one by concatenation with non-empty string, this will allocate a new underlying buffer, and then take a substring of a result:

cloned := (s + ".")[:len(s)]