Golang Strings: Split, Join, Contains, Replace and More

A Go string is an immutable sequence of bytes, normally UTF-8 text. The operators work on the string itself (+, ==, <, indexing, slicing), and everything else lives in the standard strings package.

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "apple,banana,cherry"

	parts := strings.Split(csv, ",")
	fmt.Println(parts, len(parts))

	fmt.Println(strings.Join(parts, " | "))
	fmt.Println(strings.Contains(csv, "nan"))
	fmt.Println(strings.ReplaceAll(csv, ",", ";"))
	fmt.Println(strings.ToUpper(parts[0]))
	fmt.Println(strings.TrimSpace("   padded   ") + "!")
}

Splitting Strings

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,,c", ","))
	fmt.Printf("%q\n", strings.Split("", ","))
	fmt.Printf("%q\n", strings.Fields("  one  two\tthree\n"))
	fmt.Printf("%q\n", strings.SplitN("k=v=x", "=", 2))
	fmt.Printf("%q\n", strings.Split("go", ""))

	key, value, found := strings.Cut("timeout=30s", "=")
	fmt.Println(key, value, found)
}

The Split("", ",") case catches people: an empty input gives a slice of length 1, not 0. When splitting user input, Fields or a check for s == "" first avoids a phantom empty element.

strings.Cut is the cleanest way to split key=value, user@host and similar pairs. Go 1.24 also added iterator versions, strings.SplitSeq and strings.FieldsSeq, which yield parts one at a time without building a slice.

Searching

Every search is case-sensitive except EqualFold. To search case-insensitively, lowercase both sides or use EqualFold for whole-string comparisons.

Transforming

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher!  "

	fmt.Printf("%q\n", strings.TrimSpace(s))
	fmt.Printf("%q\n", strings.Trim("--go--", "-"))
	fmt.Printf("%q\n", strings.TrimPrefix("v1.2.3", "v"))
	fmt.Printf("%q\n", strings.TrimSuffix("report.pdf", ".pdf"))
	fmt.Printf("%q\n", strings.TrimLeft("xxhixx", "x"))

	fmt.Println(strings.ToLower("MiXeD"), strings.ToUpper("mixed"))
	fmt.Println(strings.Replace("a-b-c-d", "-", "+", 2))
	fmt.Println(strings.ReplaceAll("a-b-c-d", "-", ""))
	fmt.Println(strings.Repeat("=", 20))
}

One trap: Trim, TrimLeft and TrimRight take a set of characters, not a prefix. strings.TrimLeft("abcab", "ab") removes every leading a and b and returns "cab". To remove an exact prefix or suffix, use TrimPrefix and TrimSuffix.

Concatenation and strings.Builder

+ joins strings, and fmt.Sprintf formats values into one. Both allocate a new string each time, because strings are immutable. That is fine for a handful of operations and slow in a loop, where each += copies everything built so far. Use strings.Builder instead:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 1; i <= 5; i++ {
		fmt.Fprintf(&b, "row %d", i)
		if i < 5 {
			b.WriteString(", ")
		}
	}
	fmt.Println(b.String())
	fmt.Println("length:", b.Len())

	// joining a slice is simpler still
	names := []string{"Ana", "Ben", "Chen"}
	fmt.Println("Hello " + strings.Join(names, ", "))
}

A zero strings.Builder is ready to use. It implements io.Writer, so fmt.Fprintf writes into it directly. Call b.Grow(n) first if you know roughly how big the result will be. Do not copy a Builder after writing to it; pass a pointer.

Multiline and Raw Strings

Go has two kinds of string literal:

package main

import "fmt"

func main() {
	interpreted := "line one\nline two\ttabbed \"quoted\""
	raw := `C:\Users\ana\notes.txt
second line, \n stays literal`

	fmt.Println(interpreted)
	fmt.Println(raw)

	query := `
SELECT id, name
FROM users
WHERE active = true`
	fmt.Println(query)
}

Double-quoted strings process escapes (\n, \t, \", \\, \u00e9) and must fit on one line. Backquoted raw strings take everything literally, including newlines, which makes them the way to write multiline strings, regular expressions, JSON and Windows paths. A raw string cannot contain a backquote, and carriage returns inside it are dropped. Note that the query above starts with a newline, since the literal begins right after the opening backquote.

Length, Indexing and Substrings

len(s) is the number of bytes. s[i] is a byte, and s[i:j] is a substring by byte positions:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "naïve café"

	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[0], string(s[0]))
	fmt.Println(s[:5]) // first 5 bytes
	fmt.Println(s[6:]) // from byte 6 to the end

	r := []rune(s)
	fmt.Println(string(r[:5])) // first 5 characters
}

ï and é take two bytes each, so the string is 12 bytes and 10 characters. Slicing by bytes is safe as long as the positions come from strings.Index or similar, which return byte offsets on character boundaries. To take "the first n characters", convert to []rune first. Runes and bytes explains UTF-8 in depth.

Strings Are Immutable

You cannot change a byte in place: s[0] = 'H' is a compile error (cannot assign to s[0] (neither addressable nor a map index expression)). Every function in strings returns a new string. To edit, convert to []byte or []rune, change the slice, and convert back:

b := []byte("hello")
b[0] = 'H'
s := string(b) // "Hello"

Immutability is also why substrings are cheap: s[2:5] shares memory with s instead of copying it. The flip side is that a small substring of a huge string keeps the whole huge string alive. Use strings.Clone (Go 1.20) when you keep a short piece of a large input.

Comparing Strings

== and != compare content, and <, > compare byte by byte, which is alphabetical for ASCII. strings.Compare exists but is rarely needed; slices.Sort on a []string uses <. For locale-aware sorting of non-English text, use golang.org/x/text/collate.

Converting Other Types

Numbers become strings with strconv.Itoa, strconv.FormatFloat or fmt.Sprintf, and strings become numbers with strconv.Atoi and strconv.ParseFloat. Do not write string(42): it produces the character with code point 42, "*". The type conversion page has the full table.

query := `SELECT id, name
FROM users
WHERE active = true`