How to split a string in Go

1strings.SplitRecommended

strings.Split(s, sep) cuts s at every occurrence of the sep string and returns the pieces. The separator is a string, not a set of characters and not a pattern, so " -> " is one separator rather than four. Nothing is trimmed and nothing is skipped: n separators always produce n+1 elements.

package main

import (
	"fmt"
	"strings"
)

func main() {
	parts := strings.Split("go,rust,zig", ",")
	fmt.Println(parts, len(parts))
	fmt.Println(parts[0], parts[2])

	// The separator can be any string, not just one character
	fmt.Println(strings.Split("a -> b -> c", " -> "))

	// Separator not found: one element, the whole input
	missing := strings.Split("nope", ",")
	fmt.Printf("%q %d\n", missing, len(missing))

	// Empty input: a slice holding one EMPTY string, not an empty slice
	empty := strings.Split("", ",")
	fmt.Printf("%q %d\n", empty, len(empty))
}

Prints [go rust zig] 3, go zig, [a b c], then the two edge cases everybody trips over: a missing separator gives ["nope"] 1, and an empty input gives [""] 1 — length one, not zero, so len(parts) == 0 is never the test for "nothing here". One more thing worth knowing: the returned pieces are sub-slices of the original string, so no bytes are copied, but keeping one short field alive keeps the entire original string in memory.

2Splitting on whitespace: strings.Fields

Splitting a sentence into words with strings.Split(s, " ") is the single most common splitting bug in Go. Every double space produces an empty element, a tab isn't a separator at all, and leading or trailing spaces add empties at the ends. strings.Fields is the function you actually want: it splits around each run of whitespace, as defined by unicode.IsSpace, and returns only the non-empty pieces.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  ship   it   fast\tnow\n"

	// Fields: split on any RUN of whitespace, drop the empties
	fmt.Printf("%q\n", strings.Fields(s))

	// Split on a single space: every gap becomes an empty element,
	// and the tab and newline are not separators at all
	bad := strings.Split(s, " ")
	fmt.Printf("%q %d\n", bad, len(bad))

	// All-whitespace input gives a slice of length 0
	blank := strings.Fields("   \t\n")
	fmt.Printf("%q %d\n", blank, len(blank))
}

Fields gives the four words you expected — ["ship" "it" "fast" "now"] — while Split(s, " ") returns nine elements, five of them empty, with the tab and the newline glued into "fast\tnow\n". Note also that all-whitespace input gives [] 0 here, whereas Split would give a one-element slice. If you only need to strip the ends, don't split at all — strings.TrimSpace does that job.

3Limiting the pieces: SplitN and SplitAfter

strings.SplitN(s, sep, n) stops after n pieces and leaves the rest of the string — separators and all — in the final element. That is exactly what you want for values that may legally contain the separator, like a key=value pair whose value has an = in it. strings.SplitAfter is the other variant: same cuts, but each piece keeps its trailing separator.

package main

import (
	"fmt"
	"strings"
)

func main() {
	path := "usr/local/go/bin"

	// At most 2 pieces -- everything after the first "/" stays together
	fmt.Printf("%q\n", strings.SplitN(path, "/", 2))

	// More slots than separators is fine
	fmt.Printf("%q\n", strings.SplitN(path, "/", 99))

	// n < 0 means no limit, exactly like strings.Split
	fmt.Printf("%q\n", strings.SplitN(path, "/", -1))

	// n == 0 returns a nil slice
	fmt.Println(strings.SplitN(path, "/", 0) == nil)

	// SplitAfter keeps the separator on the end of each piece
	fmt.Printf("%q\n", strings.SplitAfter(path, "/"))
}

n = 2 gives ["usr" "local/go/bin"]; asking for 99 pieces of a four-piece string just gives the four; n = -1 means unlimited (strings.Split is literally SplitN(s, sep, -1)); and n = 0 returns nil, which prints true here — a real trap if n is computed. SplitAfter prints ["usr/" "local/" "go/" "bin"], keeping the slashes so the pieces still concatenate back to the original.

4Splitting exactly once: strings.Cut

Go 1.18 added strings.Cut(s, sep), and it has quietly replaced most two-piece splits. It returns before, after, found — three values instead of a slice you then have to length-check and index. Nothing is allocated: before and after are windows onto the original string. Reach for it any time you are parsing key=value, host:port or name<email>.

package main

import (
	"fmt"
	"strings"
)

func main() {
	key, value, found := strings.Cut("HOST=db.internal:5432", "=")
	fmt.Println(key, "|", value, "|", found)

	// Not found: before is the whole string, after is empty, found is false
	b, a, ok := strings.Cut("PLAIN", "=")
	fmt.Printf("%q %q %v\n", b, a, ok)

	env := []string{"USER=ada", "EMPTY=", "# a comment", "PATH=/usr/bin"}
	for _, line := range env {
		k, v, ok := strings.Cut(line, "=")
		if !ok {
			fmt.Printf("skipping %q\n", line)
			continue
		}
		fmt.Printf("%s -> %q\n", k, v)
	}
}

The first line prints HOST | db.internal:5432 | true — note the colon inside the value survives, because Cut only ever cuts once. When the separator is absent you get "PLAIN" "" false: the whole input comes back as before, which is why the found flag matters — an empty after is ambiguous on its own, as EMPTY= in the loop shows. Go 1.20 added the same shape for affixes: strings.CutPrefix and strings.CutSuffix return the trimmed string plus a found bool.

5Splitting a string into lines

strings.Split(text, "\n") looks like the answer and is wrong twice: a file that ends in a newline gains a phantom empty last line, and Windows text keeps a stray \r on the end of every line — which you then compare against and lose an afternoon to. bufio.Scanner over a strings.NewReader handles both, and it's the same code you would use for a real file.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	text := "alpha\nbeta\r\ngamma\n"

	// Naive split: the trailing newline leaves a phantom empty line,
	// and the \r from the Windows ending rides along on "beta"
	raw := strings.Split(text, "\n")
	fmt.Printf("%q %d\n", raw, len(raw))

	// bufio.Scanner strips \n and \r\n and never yields the phantom
	sc := bufio.NewScanner(strings.NewReader(text))
	n := 0
	for sc.Scan() {
		n++
		fmt.Printf("%d %q\n", n, sc.Text())
	}
	fmt.Println("lines:", n)
}

The naive split prints ["alpha" "beta\r" "gamma" ""] 4 — four "lines" for three lines of text, one of them carrying a carriage return. The scanner prints alpha, beta, gamma and lines: 3. It does keep genuinely blank lines, which is usually what you want. Two caveats: check sc.Err() after the loop, and remember the scanner rejects any line longer than bufio.MaxScanTokenSize (64 KB) unless you hand it a bigger buffer with sc.Buffer(...).

6Several delimiters at once — and single characters

Split takes one separator string, so "split on ; or , or |" needs a different tool. strings.FieldsFunc takes a predicate and cuts at every run of runes that satisfies it — no regexp engine, no allocation beyond the result. regexp.Split is the heavier option, worth it when the pattern is data or genuinely needs regex. The two disagree about empty fields, which is the detail that decides most of these bugs.

package main

import (
	"fmt"
	"regexp"
	"strings"
)

func main() {
	s := "go;rust,zig|c"

	// FieldsFunc: you decide, per rune, what counts as a separator
	fmt.Printf("%q\n", strings.FieldsFunc(s, func(r rune) bool {
		return r == ';' || r == ',' || r == '|'
	}))

	// Same job with a regexp: slower, but the pattern can be data
	re := regexp.MustCompile(`[;,|]`)
	fmt.Printf("%q\n", re.Split(s, -1))

	// The difference that bites: FieldsFunc drops empty fields,
	// regexp.Split keeps them
	comma := func(r rune) bool { return r == ',' }
	fmt.Printf("%q\n", strings.FieldsFunc("a,,b", comma))
	fmt.Printf("%q\n", regexp.MustCompile(",").Split("a,,b", -1))

	// Into characters: an empty separator splits per UTF-8 character
	fmt.Printf("%q\n", strings.Split("Go言", ""))
	fmt.Println(len("Go言"), len([]rune("Go言")))
}

Both splitters give ["go" "rust" "zig" "c"] on the mixed input, but on "a,,b" FieldsFunc returns ["a" "b"] and regexp.Split returns ["a" "" "b"] — pick the one whose empty-field policy you want. Splitting on "" is UTF-8 aware, so "Go言" becomes three pieces even though the last line prints 5 3: five bytes, three characters. For characters prefer []rune(s) or for _, r := range s — they give you rune values instead of a slice of one-character strings. (The same byte-versus-rune split decides reversing a string.)

7Which should you use?