Strip all whitespace from a string

What is the fastest way to strip all whitespace from some arbitrary string in Go.

I am chaining two function from the string package:

response = strings.Join(strings.Fields(response),"")

Anyone have a better way to do this?

Here is some benchmarks on a few different methods for stripping all whitespace characters from a string: (source data):

<pre>
BenchmarkSpaceMap-8 2000 1100084 ns/op 221187 B/op 2 allocs/op
BenchmarkSpaceFieldsJoin-8 1000 2235073 ns/op 2299520 B/op 20 allocs/op
BenchmarkSpaceStringsBuilder-8 2000 932298 ns/op 122880 B/op 1 allocs/op
</pre>

• SpaceMap: uses strings.Map; gradually increases the amount of allocated space as more non-whitespace characters are encountered
• SpaceFieldsJoin: strings.Fields and strings.Join; generates a lot of intermediate data
• SpaceStringsBuilder uses strings.Builder; performs a single allocation, but may grossly overallocate if the source string is mainly whitespace.

<!-- -->

package main_test

import (
	"strings"
	"unicode"
	"testing"
)

func SpaceMap(str string) string {
	return strings.Map(func(r rune) rune {
		if unicode.IsSpace(r) {
			return -1
		}
		return r
	}, str)
}

func SpaceFieldsJoin(str string) string {
	return strings.Join(strings.Fields(str), "")
}

func SpaceStringsBuilder(str string) string {
	var b strings.Builder
	b.Grow(len(str))
	for _, ch := range str {
		if !unicode.IsSpace(ch) {
			b.WriteRune(ch)
		}
	}
	return b.String()
}

func BenchmarkSpaceMap(b *testing.B) {
	for n := 0; n < b.N; n++ {
		SpaceMap(data)
	}
}

func BenchmarkSpaceFieldsJoin(b *testing.B) {
	for n := 0; n < b.N; n++ {
		SpaceFieldsJoin(data)
	}
}

func BenchmarkSpaceStringsBuilder(b *testing.B) {
    for n := 0; n < b.N; n++ {
        SpaceStringsBuilder(data)
    }
}

I found the simplest way would be to use strings.ReplaceAll like so:

randomString := "  hello      this is a test"
fmt.Println(strings.ReplaceAll(randomString, " ", ""))

>hellothisisatest

Playground

Note: This does NOT remove all types of whitespace and this approach is limited to removing a single character type with each call.

From rosettacode.org :

You can find this kind of function :

func stripChars(str, chr string) string {
    return strings.Map(func(r rune) rune {
        if strings.IndexRune(chr, r) < 0 {
            return r
        }
        return -1
    }, str)
}

So, simply replacing chr by " " here should be enough to do the trick and remove the whitespaces.

Beware that there are other kind of whitespaces defined by unicode (like line break, nbsp, ...), and you might also want to get rid of those (especially if you're working with external data you don't really have control over)

This would be done that way:

func stripSpaces(str string) string {
    return strings.Map(func(r rune) rune {
        if unicode.IsSpace(r) {
            // if the character is a space, drop it
            return -1
        }
        // else keep it in the string
        return r
    }, str)
}

Then simply apply to your string. Hope it works, didn't test.

I assume this was added since the question was asked years ago:

strings.TrimSpace(moo)

"TrimSpace returns a slice of the string s, with all leading and trailing white space removed, as defined by Unicode."

See https://pkg.go.dev/strings#TrimSpace