How to trim whitespace from a string in Go

1strings.TrimSpaceRecommended

strings.TrimSpace(s) strips whitespace off both ends and leaves the middle alone. It takes no second argument, which is the whole point — there is nothing to get wrong. This is the right answer for cleaning up a scanned line, a CSV cell, or a value from os.Getenv, and it is the function you want roughly nine times out of ten.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "\t  hello, world \n"

	fmt.Printf("%q\n", s)
	fmt.Printf("%q\n", strings.TrimSpace(s))

	// TrimSpace only touches the ends -- inner runs are left alone.
	fmt.Printf("%q\n", strings.TrimSpace("  go   is   fun  "))

	// Strings are immutable: TrimSpace returns a new one, s is untouched.
	fmt.Printf("%q\n", s)

	// Nothing to trim? You get the same string back, no allocation.
	fmt.Printf("%q\n", strings.TrimSpace("already clean"))
}

The %q verb quotes the string and escapes the invisibles, so line 1 echoes the input exactly as written — a leading \t, two spaces, the text, then a space and a \n — while line 2 is the trimmed "hello, world". Line 3 keeps every one of the three-space gaps between the words: TrimSpace works inward from each end and stops at the first non-space rune, so the middle is never reached. Line 4 reprints the original, unchanged, because TrimSpace returns a new string rather than editing one — and when there is nothing to remove it hands back the input as-is (a reslice of the same bytes, no copy), so calling it defensively is cheap.

2What counts as whitespace (and what doesn't)

TrimSpace delegates to unicode.IsSpace, which is Unicode's White_Space property — so \t \n \v \f \r and space are in, and so are U+0085, the non-breaking space U+00A0, and the ideographic space U+3000. What is not in: the zero-width space U+200B and the BOM U+FEFF. Those two are the reason a "trimmed" string pasted from a web page still fails an equality check.

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	nbsp := "\u00a0go\u00a0" // U+00A0 NO-BREAK SPACE
	zwsp := "\u200bgo\u200b" // U+200B ZERO WIDTH SPACE

	fmt.Printf("%q -> %q\n", nbsp, strings.TrimSpace(nbsp))
	fmt.Printf("%q -> %q\n", zwsp, strings.TrimSpace(zwsp))

	// TrimSpace defers to unicode.IsSpace, i.e. Unicode's White_Space property.
	fmt.Println(unicode.IsSpace('\u00a0'), unicode.IsSpace('\u200b'))

	// Widen the definition yourself for the invisible non-space runes.
	blank := func(r rune) bool {
		return unicode.IsSpace(r) || r == '\u200b' || r == '\ufeff'
	}
	fmt.Printf("%q\n", strings.TrimFunc("\ufeff \u200bgo\u200b ", blank))

	// TrimLeftFunc / TrimRightFunc do one end only.
	fmt.Printf("%q\n", strings.TrimRightFunc("id-42-\t", unicode.IsSpace))
	fmt.Printf("%q\n", strings.TrimRightFunc("id-42-\t", func(r rune) bool {
		return unicode.IsSpace(r) || r == '-'
	}))
}

The non-breaking space is trimmed — "\u00a0go\u00a0" -> "go" — but the zero-width space is not: "\u200bgo\u200b" comes back identical, and unicode.IsSpace confirms it with true false. strings.TrimFunc takes any func(rune) bool, so widening the definition to include U+200B and U+FEFF gets you a clean "go". The last two lines show TrimRightFunc doing one end only: with unicode.IsSpace you get "id-42-", and with the dash added, "id-42".

3TrimLeft/TrimRight vs TrimPrefix/TrimSuffix

This pair looks interchangeable and is not. TrimLeft(s, cutset) reads the second argument as an unordered set of runes and keeps eating characters off the front for as long as each one is a member. TrimPrefix(s, prefix) reads it as a literal substring and removes it exactly once. Reach for TrimLeft when you mean "strip these padding characters", and for TrimPrefix when you mean "strip this exact text".

package main

import (
	"fmt"
	"strings"
)

func main() {
	url := "https://sports.example.com/"

	// TrimLeft takes a CUTSET: every leading rune that appears in the
	// string "https://" is eaten, one at a time.
	fmt.Printf("%q\n", strings.TrimLeft(url, "https://"))

	// TrimPrefix takes a SUBSTRING: it removes that exact prefix, once.
	fmt.Printf("%q\n", strings.TrimPrefix(url, "https://"))
	fmt.Printf("%q\n", strings.TrimSuffix(url, "/"))

	// No match? TrimPrefix/TrimSuffix return the string unchanged.
	fmt.Printf("%q\n", strings.TrimPrefix(url, "http://"))

	// Cutsets are order- and duplicate-insensitive; these are the same set.
	fmt.Printf("%q\n", strings.TrimRight("value;;;", ";"))
	fmt.Printf("%q\n", strings.TrimRight("value;;;", ";;;"))
}

Here is the bug in one line: TrimLeft(url, "https://") yields "orts.example.com/" — the cutset is {h,t,p,s,:,/}, so it chews straight through the scheme and then keeps going into s and p of "sports". TrimPrefix gives the intended "sports.example.com/", and it returns the string untouched when the prefix doesn't match, which makes it safe to call unconditionally. Note also TrimRight("value;;;", ";") and TrimRight("value;;;", ";;;") both print "value": duplicates in a cutset are meaningless.

4strings.Trim with a custom cutset

strings.Trim(s, cutset) is TrimSpace with the whitespace rule replaced by your own character set. It shines on messy real-world data, where a field can be padded with spaces and wrapped in quotes and you don't know which order they arrive in — a set handles both without a loop. It always stops at the first rune that isn't a member, so anything in the middle is safe.

package main

import (
	"fmt"
	"strings"
)

func main() {
	// A scraped field: quotes AND whitespace, in either order.
	field := "  \"Ada Lovelace\" \t"
	fmt.Printf("%q\n", strings.Trim(field, " \t\""))

	// Trim stops at the first rune that isn't in the cutset.
	fmt.Printf("%q\n", strings.Trim("...go...", "."))
	fmt.Printf("%q\n", strings.Trim("/api/v1/users/", "/"))
	fmt.Printf("%q\n", strings.Trim("--a--b--", "-"))

	// Cutsets combine happily: digits and dashes off the end.
	fmt.Printf("%q\n", strings.TrimRight("report-2026-000", "-0123456789"))
}

The scraped field becomes "Ada Lovelace" in one call. Then "go", "api/v1/users", and — the important one — "a--b", where the inner dashes survive because Trim only works inward from the ends. The last line strips digits and dashes off the right to leave "report". A cutset is interpreted as UTF-8 runes, not bytes, so multi-byte characters work fine in it.

5Which should you use?

6Removing or collapsing inner whitespace

No Trim* function touches the middle of a string, so "remove the double spaces" is a different job. The idiom is strings.Join(strings.Fields(s), " "): Fields splits on any run of whitespace and drops the empties, so re-joining with a single space normalises the ends and the middle in one pass. Join with "" instead and every space disappears.

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	s := " \t Go   makes\n concurrency\t\teasy  "

	// Collapse every run of whitespace to one space, ends trimmed too.
	fmt.Printf("%q\n", strings.Join(strings.Fields(s), " "))

	// Same split, empty separator: all whitespace gone.
	fmt.Printf("%q\n", strings.Join(strings.Fields(s), ""))

	// ReplaceAll removes only the exact substring you name.
	fmt.Printf("%q\n", strings.ReplaceAll(s, " ", ""))

	// strings.Map is the general form: return -1 to drop a rune.
	dropped := strings.Map(func(r rune) rune {
		if unicode.IsSpace(r) {
			return -1
		}
		return r
	}, s)
	fmt.Printf("%q\n", dropped)
}

You get "Go makes concurrency easy", then "Gomakesconcurrencyeasy". The third line is the warning: strings.ReplaceAll(s, " ", "") only matches the literal ASCII space, so it leaves "\tGomakes\nconcurrency\t\teasy" — tabs and newlines fully intact. strings.Map with a -1 return is the general escape hatch and matches Fields. For a similar splitting trick, see reversing the words in a sentence.