7 Ways to Compare Strings in Golang for Performance

Optimizing Golang String Comparisons for Peak Performance

Welcome to this deep dive into comparing strings using Go (Golang). If you're working with Go, you know string comparisons are fundamental. But did you know that the method you choose can have a significant impact on your application's performance? It's not just about getting the right result; it's about getting it efficiently.

Thinking about string comparison might seem basic. Pick a method, any method, right? Well, not exactly. Some built-in Golang functions for string comparison have performance characteristics that aren't immediately obvious, and some are downright discouraged by the Go team itself.

Understanding these nuances is key to writing Go code that runs as fast as possible. We'll dissect various methods, look at practical code snippets, and highlight the best tool for each specific comparison task.

A Quick Rundown of Golang String Comparison Methods

There are definite winners and losers when it comes to performance in Golang string comparisons, plus specialized tools for different needs. Before we get into the nitty-gritty, here’s a summary of the techniques we'll cover:

• Equality Operators (==, !=): Your go-to for fast, case-sensitive equality checks. Highly recommended.

• strings.EqualFold(): The champion for case-insensitive string comparison. Generally preferred over manual lowercasing.

• strings.Compare(): The one to avoid for general comparisons due to performance concerns highlighted by the Go team.

• len(): Primarily for comparing string lengths (in bytes), but also a handy optimization tool for other comparisons.

• strings.Contains(): The standard for checking if a string contains a specific case-sensitive substring.

• strings.Contains() + strings.ToLower(): A common pattern for case-insensitive substring checks.

• Inequality Operators (>, <, >=, <=): Used for comparing strings based on their lexicographical (dictionary) order.

Let's explore each method in more detail.

Comparing String Size with len()

Let's kick things off with the fundamental len() function. In Go, applying len() to a string gives you its length in bytes, not necessarily the number of characters (due to multi-byte UTF-8 characters). However, for quickly determining if one string occupies more memory than another, or simply checking if they *could* be equal based on byte count, len() is perfect.

Here’s a basic usage example:

package main

import "fmt"

func main() {
	var textOne = "Apple"
	var textTwo = "Banana"
	if len(textOne) == len(textTwo) {
		fmt.Println("Both strings have the same byte length.")
	} else {
		fmt.Println("The strings have different byte lengths.")
	}
	// Result: The strings have different byte lengths.

	textOne = "Cherry"
	textTwo = "Orange" // Both 6 bytes
	if len(textOne) == len(textTwo) {
		fmt.Println("Both strings have the same byte length.")
	}

	if len(textOne) < len(textTwo) {
		fmt.Println("Text One is shorter (in bytes) than Text Two.")
	} else if len(textOne) > len(textTwo) {
		fmt.Println("Text One is longer (in bytes) than Text Two.")
	} else {
		fmt.Println("Text One and Text Two have equal byte lengths.")
	}
	// Result: Both strings have the same byte length.
	// Result: Text One and Text Two have equal byte lengths.

Beyond direct size comparison, len() is a valuable performance enhancer. When Go compares two strings for equality using operators like ==, it checks them byte by byte. This can be slow for long strings.

Checking the length with len() is extremely fast. Therefore, a common optimization is to check if the lengths are equal *before* performing a full byte-by-byte comparison. If the lengths differ, the strings cannot be equal, saving you the more expensive comparison.

We'll see how this applies shortly.

Case-Sensitive Equality: == and !=

The standard equality operators, == (equal to) and != (not equal to), are the bread and butter of string comparison in Go. They perform an exact, byte-for-byte comparison, making them case-sensitive. For checking if two strings are identical, == is the most performant and idiomatic choice, explicitly recommended by the Go developers.

You can boost performance, especially when strings often differ, by combining this with the len() check we just discussed: First, check if the lengths match. If they do, then proceed with the == comparison.

While you *could* achieve case-insensitive comparison by converting both strings to lowercase using strings.ToLower() before using ==, there's a better tool for that job: strings.EqualFold(), which we'll cover next.

Here’s how to use the equality operators:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var str1 = "Hello World"
	var str2 = "Goodbye World"
	if str1 == str2 {
		fmt.Println("Strings are identical.")
	} else {
		fmt.Println("Strings are different.")
	}
	// Result: Strings are different.

	str1 = "GoLang"
	str2 = "golang"
	if str1 == str2 {
		fmt.Println("Strings match exactly.")
	} else {
		fmt.Println("Strings differ (case matters!).")
	}
	// Result: Strings differ (case matters!).

	// Case-insensitive comparison (less ideal way)
	if strings.ToLower(str1) == strings.ToLower(str2) {
		fmt.Println("Strings match ignoring case (using ToLower).")
	} else {
		fmt.Println("Strings differ even ignoring case (using ToLower).")
	}
	// Result: Strings match ignoring case (using ToLower).

	// Performance optimization with len()
	str1 = "A very long string..." // Imagine this is much longer
	str2 = "A completely different very long string..."
	if len(str1) == len(str2) {
		if str1 == str2 {
			fmt.Println("Optimized: Strings are identical.")
		} else {
			fmt.Println("Optimized: Lengths match, but content differs.")
		}
	} else {
		fmt.Println("Optimized: Lengths differ, no need for full compare.")
	}
	// Result: Optimized: Lengths differ, no need for full compare.

Case-Insensitive Equality: strings.EqualFold()

When you need to check if two strings are the same regardless of case, strings.EqualFold() is the function you should reach for. It's specifically designed for case-insensitive comparisons and is generally more efficient and correct than manually converting strings to lowercase with strings.ToLower() before using ==.

Why is it better? EqualFold uses Unicode case-folding rules, which handle a wider range of characters and edge cases more accurately than simple lowercasing. It often avoids unnecessary memory allocations that ToLower might introduce.

Here's how to use it:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var name1 = "EvomiProxies"
	var name2 = "evomiproxies"
	var name3 = "Evomi Proxies" // Different string

	if strings.EqualFold(name1, name2) {
		fmt.Println("name1 and name2 are equal, ignoring case.")
	} else {
		fmt.Println("name1 and name2 are different, ignoring case.")
	}
	// Result: name1 and name2 are equal, ignoring case.

	if strings.EqualFold(name1, name3) {
		fmt.Println("name1 and name3 are equal, ignoring case.")
	} else {
		fmt.Println("name1 and name3 are different, ignoring case.")
	}
	// Result: name1 and name3 are different, ignoring case.

	// Comparing with an empty string
	var emptyStr = ""
	if strings.EqualFold(name1, emptyStr) {
		fmt.Println("name1 and empty string are equal, ignoring case.")
	} else {
		fmt.Println("name1 and empty string are different, ignoring case.")
	}
	// Result: name1 and empty string are different, ignoring case.

For case-insensitive equality checks, make strings.EqualFold() your default choice.

Dictionary Order Comparison: >, <, >=, <=

These operators might look familiar from comparing numbers, but they take on a specific meaning with strings. In Go, using inequality operators on strings performs a lexicographical comparison, which is essentially comparing them based on dictionary order.

The comparison proceeds byte by byte based on their values. It's important to remember that this means uppercase letters come *before* lowercase letters (e.g., "Z" comes before "a"), and digits come before letters. This can sometimes lead to counter-intuitive results if you're expecting purely alphabetical or numerical sorting.

Let's see it in action:

package main

import (
	"fmt"
)

func main() {
	var wordA = "Apple"
	var wordB = "apple"
	if wordA < wordB {
		fmt.Println(`"Apple" comes before "apple" lexicographically.`)
	} else {
		fmt.Println(`"Apple" does not come before "apple" lexicographically.`)
	}
	// Result: "Apple" comes before "apple" lexicographically. (Uppercase 'A' < lowercase 'a')

	wordA = "Banana"
	wordB = "Orange"
	if wordA < wordB {
		fmt.Println(`"Banana" comes before "Orange" lexicographically.`)
	} else {
		fmt.Println(`"Banana" does not come before "Orange" lexicographically.`)
	}
	// Result: "Banana" comes before "Orange" lexicographically.

	wordA = "Test10"
	wordB = "Test2"
	if wordA < wordB {
		fmt.Println(`"Test10" comes before "Test2" lexicographically.`)
	} else {
		fmt.Println(`"Test10" does not come before "Test2" lexicographically.`)
	}
	// Result: "Test10" comes before "Test2" lexicographically. (Character '1' < character '2')

The One to Avoid: strings.Compare()

Let's address strings.Compare(). The official Go documentation strongly advises against using this function for performance reasons. Their own source code comment is quite explicit:

// NOTE(rsc): This function does NOT call the runtime cmpstring function,
// because we do not want to provide any performance justification for
// using strings.Compare. Basically no one should use strings.Compare.
// [...]
// If performance is important, the compiler should be changed to recognize
// the pattern so that all code doing three-way comparisons, not just code
// using strings.Compare, can benefit.

So, the verdict from the creators of Go is clear: avoid strings.Compare(). It exists mainly for symmetry with the `bytes` package.

If you encounter it in older code or are curious, it performs a case-sensitive, lexicographical comparison similar to the inequality operators, but returns an integer instead of a boolean:

• Returns 0 if stringA == stringB

• Returns 1 if stringA > stringB (stringA comes after stringB lexicographically)

• Returns -1 if stringA < stringB (stringA comes before stringB lexicographically)

Here’s an example demonstrating its behavior (though remember, you generally shouldn't use it):

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s1 = "Go"
	var s2 = "Go"
	fmt.Println(strings.Compare(s1, s2)) // Result: 0 (equal)

	s1 = "Go"
	s2 = "go"
	fmt.Println(strings.Compare(s1, s2)) // Result: -1 ("Go" comes before "go")

	s1 = "golang"
	s2 = "Go"
	fmt.Println(strings.Compare(s1, s2)) // Result: 1 ("golang" comes after "Go")

	s1 = "Alpha100"
	s2 = "Alpha20"
	fmt.Println(strings.Compare(s1, s2)) // Result: -1 ("Alpha100" comes before "Alpha20")

Stick to the equality (==, !=) and inequality (>, <, etc.) operators for better performance and idiomatic Go code.

Checking for Substrings: strings.Contains()

Need to know if a smaller string exists within a larger one? strings.Contains() is the standard library function for this task. It performs a case-sensitive search.

The function signature is strings.Contains(s, substr string) bool. It returns true if the string s contains the substring substr, and false otherwise. Think of it as asking, "Does the haystack (s) contain the needle (substr)?".

Example usage:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var mainText = "Evomi offers residential and datacenter proxies."
	var searchText = "datacenter"
	if strings.Contains(mainText, searchText) {
		fmt.Printf("'%s' contains '%s'\n", mainText, searchText)
	} else {
		fmt.Printf("'%s' does not contain '%s'\n", mainText, searchText)
	}
	// Result: 'Evomi offers residential and datacenter proxies.' contains 'datacenter'

	searchText = "mobile"
	if strings.Contains(mainText, searchText) {
		fmt.Printf("'%s' contains '%s'\n", mainText, searchText)
	} else {
		fmt.Printf("'%s' does not contain '%s'\n", mainText, searchText)
	}
	// Result: 'Evomi offers residential and datacenter proxies.' does not contain 'mobile'

	searchText = "Residential" // Note the different case
	if strings.Contains(mainText, searchText) {
		fmt.Printf("'%s' contains '%s'\n", mainText, searchText)
	} else {
		fmt.Printf("'%s' does not contain '%s' (case-sensitive)\n", mainText, searchText)
	}
	// Result: 'Evomi offers residential and datacenter proxies.' does not contain 'Residential' (case-sensitive)

Case-Insensitive Substring Checks: Contains() + ToLower()

The standard strings.Contains() function is case-sensitive. If you need to check for a substring while ignoring case, the common approach is to convert both the main string and the substring to lowercase (or uppercase) before performing the check.

While not as elegant as `strings.EqualFold` for full string comparison, this combination is the standard way to achieve case-insensitive substring detection in Go.

Let's adapt the previous example:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var mainText = "Evomi offers Residential and Datacenter Proxies."
	var searchText = "residential" // Lowercase search term
	lowerMainText := strings.ToLower(mainText)
	lowerSearchText := strings.ToLower(searchText)

	if strings.Contains(lowerMainText, lowerSearchText) {
		fmt.Printf("'%s' contains '%s' (case-insensitive)\n", mainText, searchText)
	} else {
		fmt.Printf("'%s' does not contain '%s' (case-insensitive)\n", mainText, searchText)
	}
	// Result: 'Evomi offers Residential and Datacenter Proxies.' contains 'residential' (case-insensitive)

	searchText = "DATACENTER" // Uppercase search term
	lowerSearchText = strings.ToLower(searchText) // Convert search term only
	if strings.Contains(lowerMainText, lowerSearchText) {
		fmt.Printf("'%s' contains '%s' (case-insensitive)\n", mainText, searchText)
	} else {
		fmt.Printf("'%s' does not contain '%s' (case-insensitive)\n", mainText, searchText)
	}
	// Result: 'Evomi offers Residential and Datacenter Proxies.' contains 'DATACENTER' (case-insensitive)

	searchText = "Mobile" // Term not present
	lowerSearchText = strings.ToLower(searchText)
	if strings.Contains(lowerMainText, lowerSearchText) {
		fmt.Printf("'%s' contains '%s' (case-insensitive)\n", mainText, searchText)
	} else {
		fmt.Printf("'%s' does not contain '%s' (case-insensitive)\n", mainText, searchText)
	}
	// Result: 'Evomi offers Residential and Datacenter Proxies.' does not contain 'Mobile' (case-insensitive)

Conclusion: Choosing the Right Tool for the Job

We've navigated the various ways to compare strings in Golang, highlighting the performance characteristics and ideal use cases for each method. You now know the fastest ways to check for equality (==, strings.EqualFold()), how to compare based on dictionary order (>, <), check lengths (len()), find substrings (strings.Contains()), and importantly, which function to avoid (strings.Compare()).

By applying these techniques, particularly the performance optimization of checking lengths first when appropriate, you can ensure your Go applications handle string comparisons efficiently.

Hopefully, this breakdown helps you write cleaner, faster Go code. If you're working with Go for network-related tasks, you might also find our guide on building a Golang web scraper useful. Happy coding!