Split Strings on Whitespace in Go with strings.Fields

You will learn how to use Go's strings.Fields to split text on runs of whitespace. It automatically ignores leading and trailing whitespace, collapses repeated separators, and returns a []string containing the words.

strings.Fields is the standard Go tool for turning whitespace-separated text into words.

It scans a string and divides it wherever it finds Unicode whitespace. Consecutive whitespace is treated as one separator, so you do not need to call strings.TrimSpace first or write a regular expression for this common task.

words := strings.Fields(input)

For this input:

input := "  word1   word2 word3   word4  "

strings.Fields returns:

[]string{"word1", "word2", "word3", "word4"}

This matters because user input, copied text, log lines, and text files often contain inconsistent spacing: multiple spaces, tabs, line breaks, or non-ASCII whitespace. Using strings.Fields makes parsing that input predictable without manually cleaning it first.

Think of whitespace as empty gaps between labeled boxes.

strings.Fields walks across the text, skips every empty gap, and collects each non-empty run of characters into a box. Whether a gap contains one space, ten spaces, a tab, or a newline does not matter: it is still just a boundary between words.

For example:

  red     green\tblue\npurple

becomes:

[red] [green] [blue] [purple]

There are no empty boxes for the extra whitespace.

Import the strings package and pass the input to strings.Fields.

package main

import (
	"fmt"
	"strings"
)

func main() {
	input := "  word1   word2 word3   word4  "
	words := strings.Fields(input)

	fmt.Println(words)
	fmt.Printf("%q\n", words)
}

Output:

[word1 word2 word3 word4]
["word1" "word2" "word3" "word4"]

%q is useful while learning because it makes each slice element clear.

strings.Fields also handles tabs, line breaks, and Unicode whitespace:

input := "one\ttwo\nthree\u00a0four"
words := strings.Fields(input)

fmt.Printf("%q\n", words)
// ["one" "two" "three" "four"]

The \u00a0 escape represents a non-breaking space, a Unicode whitespace character.

Consider this program:

input := "  Go\t is\nfun  "
words := strings.Fields(input)
fmt.Printf("%q\n", words)

Execution proceeds as follows:

1. input contains leading spaces, a tab between Go and is, a newline between is and fun, and trailing spaces.
2. strings.Fields skips the two leading spaces.
3. It reads Go and adds it as the first slice element.
4. It sees a tab and treats it as a separator.
5. It reads is, then treats the newline as another separator.
6. It reads fun and ignores the trailing spaces.
7. The result is:

[]string{"Go", "is", "fun"}

1. fmt.Printf("%q\n", words) prints:

["Go" "is" "fun"]

Common uses of strings.Fields include:

• Command-line style input: Split "build --release --verbose" into individual arguments when a full shell parser is not required.
• Text-file processing: Read lines from a report where columns are separated by inconsistent spaces or tabs.
• Search terms: Convert a search box value such as " go string parsing " into search tokens.
• Log analysis: Extract whitespace-separated fields from simple log formats.
• Data cleanup: Normalize text copied from documents or web pages, where whitespace may include tabs, newlines, or non-breaking spaces.

Example: counting words in a sentence.

text := "Go makes   text processing\nstraightforward."
count := len(strings.Fields(text))

fmt.Println(count) // 5

In production code, strings.Fields is commonly used at an input boundary: after reading text from a file, HTTP request, environment variable, or command-line argument.

Validate parsed input

If the input must contain at least two words, check the result before indexing it:

func parseName(input string) (string, string, error) {
	parts := strings.Fields(input)
	if len(parts) < 2 {
		return "", "", fmt.Errorf("expected a first and last name")
	}

	return parts[0], parts[1], nil
}

The early return prevents a panic from accessing parts[0] or parts[1] when the input is empty.

Normalize before joining

A useful normalization pattern is to split fields and join them with one standard space:

func normalizeWhitespace(input string) string {
	return strings.Join(strings.Fields(input), " ")
}

fmt.Println(normalizeWhitespace("  hello\t\tworld\n"))
// hello world

Choose stricter parsing when needed

strings.Fields is ideal when any whitespace is a separator. If a file format requires exact comma-separated values, quoted fields, or fixed columns, use a parser designed for that format instead, such as encoding/csv for CSV.

Using strings.Split with a single space

This does not collapse repeated spaces and does not handle tabs or newlines:

input := "  word1   word2  "
parts := strings.Split(input, " ")
fmt.Printf("%q\n", parts)
// ["" "" "word1" "" "" "word2" "" ""]

Use strings.Fields when whitespace should act as a flexible separator.

parts := strings.Fields(input)
// ["word1" "word2"]

Trimming before calling Fields

This is unnecessary:

parts := strings.Fields(strings.TrimSpace(input))

It works, but strings.Fields already ignores leading and trailing whitespace. Prefer:

parts := strings.Fields(input)

Assuming an empty string produces one empty item

parts := strings.Fields("   ")
fmt.Printf("%q\n", parts)
// []

Whitespace-only input has no fields. Check len(parts) before accessing an element.

Using Fields when spaces are meaningful

strings.Fields cannot preserve empty values or distinguish one space from several spaces. For example, it is not appropriate for data where blank columns matter.

input := "first,,third"
parts := strings.Split(input, ",")
// ["first" "" "third"]

For delimiter-based formats, split on the actual delimiter or use a dedicated parser.

Use strings.Fields for the Go equivalent of the common intent behind Java's trim().split("\\s+"): extract non-empty words separated by whitespace.

Use strings.FieldsFunc when your separators include additional characters. For example, split on whitespace or commas:

parts := strings.FieldsFunc("go, rust  python", func(r rune) bool {
	return unicode.IsSpace(r) || r == ','
})

fmt.Printf("%q\n", parts)
// ["go" "rust" "python"]

This example requires imports for both strings and unicode.

import "strings"

// Split on one or more Unicode whitespace characters.
fields := strings.Fields(input)

• Return type: []string
• Leading whitespace: ignored
• Trailing whitespace: ignored
• Repeated whitespace: treated as one separator
• Whitespace-only input: returns an empty slice
• Supports spaces, tabs, newlines, and Unicode whitespace recognized by Go
• No strings.TrimSpace call is needed first

strings.Fields("  a   b\tc\n")
// []string{"a", "b", "c"}

Normalize arbitrary whitespace to single spaces:

normalized := strings.Join(strings.Fields(input), " ")

For custom separators:

parts := strings.FieldsFunc(input, func(r rune) bool {
	return r == ',' || r == ';'
})

How do I split a string by spaces in Go?

Use strings.Fields(input) when you want words and do not care how many whitespace characters separate them.

Does strings.Fields remove leading and trailing spaces?

Yes. It ignores whitespace at both ends of the string, so a separate strings.TrimSpace call is not necessary.

Does strings.Fields handle tabs and newlines?

Yes. Tabs, newlines, and other Unicode whitespace characters are separators.

What does strings.Fields("") return?

It returns an empty slice because there are no non-whitespace fields.

Why does strings.Split(input, " ") return empty strings?

strings.Split splits at every exact occurrence of the delimiter. Consecutive spaces create empty text between delimiters, and leading or trailing spaces create empty items at the ends.

Should I use a regular expression to split whitespace in Go?

Usually no. strings.Fields is simpler and directly expresses the requirement of extracting whitespace-separated fields. Use regular expressions only when your splitting rule is more complex.

Can strings.Fields preserve multiple spaces?

No. It treats every consecutive run of whitespace as a separator. If spacing itself is meaningful, process the original string differently.

• strings.Split — Split text at an exact delimiter such as a comma or slash.
• strings.FieldsFunc — Split using a custom function when whitespace alone is not enough.
• strings.TrimSpace — Remove whitespace from only the beginning and end of a string.
• strings.Join — Combine a slice of strings, often used after Fields to normalize whitespace.
• Runes and Unicode in Go — Useful for understanding why whitespace processing is based on Unicode characters.
• Input validation — Important when checking that a parsed slice contains the expected number of fields.
• encoding/csv — Use this instead of basic splitting for CSV data with quotes and escaped commas.