Introduction
The standard Go library strings package provides many string related functions. This blog lists description of most frequently used function of strings package in Go, Since there are a lot of functions available and it's not easy to remember each one of those straight away, it worth bookmarking as it might be handy when needed. Below is a list of function with small example snippet code.
Note: I am amateur in Go if you are an experienced professional in Go and find anything wrong here don't be annoyed if you could point the mistake I will correct those accordingly.
1 .Compare
compares two string lexicographically Outcome of this function is an integer and could be either 0, -1 or 1
Function signature :
func Compare(a, b string) int
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Compare("gopher19", "gopher20"))
fmt.Println(strings.Compare("gopher19", "gopher19"))
fmt.Println(strings.Compare("gopher20", "gopher19"))
}
Output :
-1
0
1
2 .Contains
contains function returns an appropriate Boolean value if given substring present in the string being searched.
Function signature :
func Contains(s, substr string) bool
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Contains("gopher-20", "20"))
fmt.Println(strings.Contains("gopher-20", "30"))
fmt.Println(strings.Contains("gopher-20", ""))
fmt.Println(strings.Contains("", ""))
}
output:
true
false
true
true
3 .Count
I find this most useful especially in coding challenges where they ask you to find number of times a character repeated in a string.
This function takes two strings as input and checks number of times second string argument appears in first string argument and returns count as an integer.
Function signature :
func Count(s, substr string) int
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Count("gopher-gopher-gopher", "g"))
fmt.Println(strings.Count("gopher", "g"))
}
output:
3
1
4 .Fields
If you ever wanted to split a string into string array by white space characters
This function takes a string as input and splits into an array by white space characters in the string and returns a string array.
Function signature :
func Fields(s string) []string
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Printf("Fields are: %q", strings.Fields("gopher is sleeping."))
}
output:
Fields are: ["gopher" "is" "sleeping."]
5 .HasPrefix
This function takes two strings as input and checks if the second argument string is present in starting characters of the first argument string.
.HasPrefix has his brother called .HasSuffix does exactly same but this time it checks at the ending part of the string.
Function signature :
func HasPrefix(s, prefix string) bool
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.HasPrefix("gopher", "go"))
fmt.Println(strings.HasPrefix("gopher", "java"))
fmt.Println(strings.HasPrefix("gopher", ""))
}
output:
true
false
true
6 .Replace
This function takes four parameters as input
- culprit string
- old string
- new string
- number of times new string will replace old string in culprit string
if n < 0 there is no limit on a number of replacements.
Function signature :
func Replace(s, old, new string, n int) string
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Replace("no-banana no-banana no-banana", "no", "yes", 2))
fmt.Println(strings.Replace("no-banana no-banana no-banana", "no", "yes", -1))
}
output:
yes-banana yes-banana no-banana
yes-banana yes-banana yes-banana
another version of .Replace is .ReplaceAll which basically replace all.
7 .Split
This function takes two strings as input and returns a slice of the substrings based on the second argument string.
Function signature :
func Split(s, sep string) []string
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Printf("%q\n", strings.Split("gopher,19,gopher", ","))
}
output:
["gopher" "19" "gopher"]
There are few more variations of .Split exists which are .SplitAfter .SplitAfterN .SplitN
8 .TrimSpace
One of the most used feature to remove white spaces, this function takes a string as input and returns a string with trailing and leading spaces removed.
Function signature :
func TrimSpace(s string) string
Example:
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.TrimSpace(" \t\n Covid-19's vaccine will be invented and out soon to rescue us all from this insane. \n\t\r\n"))
}
output:
Covid-19's vaccine will be invented and out soon to rescue us all from this insane.
This is the end of the most-used strings functions I think are, but if you think there is something which you think must go into this list please drop me a message and I will include it in here.
Top comments (2)
Good summary! Between golang's string and strconv package, the standard library covers a lot of ground (not even considering the fmt package!). Anytime I need to do work on strings I double-check the package docs to make sure I'm not missing out on something helpful.
It's true @ryantenorio , I absolutely love the idea of "there should be only one way of doing a thing" and Go reflects it most of the times.