Regular expressions are a key feature of every programming language in software development. It comes in handy when you need to create data validation logic that compares input values to a pattern. Golang comes with an inbuilt regexp package that allows you to write regular expressions of any complexity.
In this article, we’ll cover the following:
- Basic matches with the regex function
- Compiling and reusing regular expression patterns
- Using a regular expression to split strings
- Subexpressions
- Using a regular expression to replace substrings
- Using a function to replace matched content
Basic matches with regex function
The regexp package provides a number of functions for handling pattern matches.
For this article, we’ll experiment on the basic and the most useful functions for handling pattern matches.
MatchString
The MatchString function checks if the input string contains any match of the regular expression pattern. It accepts a regular expression pattern and a string as parameters and returns true if there is a match. If the pattern fails to compile, errors are returned.
Here is a snippet for the above explanation:
package main
import (
"fmt"
"regexp"
)
func main() {
inputText := "I love new york city"
match, err := regexp.MatchString("[A-z]ork", inputText)
if err == nil {
fmt.Println("Match:", match)
} else {
fmt.Println("Error:", err)
}
}
Compile and execute the above code, and you will receive the following result:
Match: true
FindStringIndex
FindStringIndex method returns only the first match, progressing from left to right. The match is expressed as an int slice, with the first value indicating the start of the match in the string and the second number indicating the number of characters that were matched. A nil result means no matches were found.
Here is a sample use case for the FindStringIndex method:
package main
import (
"fmt"
"regexp"
)
func getSubstring(s string, indices []int) string {
return string(s[indices[0]:indices[1]])
}
func main() {
pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
welcomeMessage := "Hello guys, welcome to new york city"
firstMatchIndex := pattern.FindStringIndex(welcomeMessage)
fmt.Println("First matched index", firstMatchIndex[0], "-", firstMatchIndex[1],
"=", getSubstring(welcomeMessage, firstMatchIndex))
}
Here, we wrote a custom getSubstring function that returns a substring composed with the values from the int slice and the input string. The regexp package has the inbuilt FindString function that achieves the same result.
Compile and execute the above code, and you will receive the following result:
First matched index 0 - 5 = Hello
FindString
This method returns only the first matched string, progressing from left to right made by the compiled pattern.
An empty string will be returned if no match is made. If there is no match, the return value is an empty string, but it will also be empty if the regular expression successfully matches an empty string. If you need to distinguish between these cases, use the FindStringIndex or FindStringSubmatch methods.
Here is a sample use case for the FindString method:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
welcomeMessage := "Hello guys, welcome to new york city"
firstMatchSubstring := pattern.FindString(welcomeMessage)
fmt.Println("First matched substring:", firstMatchSubstring)
}
Compile and execute the above code, and you will receive the following result:
First matched substring: Hello
FindAllString(s string, n int)
This method takes a string and int arguments and returns a string slice containing all the matches found in the input string by the compiled pattern in the input string. The maximum number of matches is specified by the int argument max, with -1 indicating no limit. If there are no matches, a nil result is returned.
Here is a sample use case for the FindAllString method:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
welcomeMessage := "Hello guys, welcome to new york city"
allSubstringMatches := pattern.FindAllString(welcomeMessage, -1)
fmt.Println(allSubstringMatches)
}
Compile and execute the above code, and you will receive the following result:
[Hello york]
FindAllStringIndex(s string, n int)
The FindAllStringIndex method is the All version of FindStringIndex. It takes a string and int arguments and returns a slice of int slices of all successive matches of the pattern. If there are no matches, a nil result is returned.
Calling a FindAll method with the int parameter of 0 will return no results, and calling with the int parameter of 1 will return a slice of int slice of the first matched string from the left. The int parameter of -1 returns a slice of int slices of all successive matches of the pattern.
The returned slice contains two int values, with the first value indicating the start of the match in the string and the second number indicating the number of characters that were matched.
Learn more →Here is a sample use case for the FindAllStringIndex method:
package main
import (
"fmt"
"regexp"
)
func getSubstring(s string, indices []int) string {
return string(s[indices[0]:indices[1]])
}
func main() {
pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
welcomeMessage := "Hello guys, welcome to new york city"
allIndices := pattern.FindAllStringIndex(welcomeMessage, -1)
fmt.Println(allIndices)
for i, idx := range allIndices {
fmt.Println("Index", i, "=", idx[0], "-",
idx[1], "=", getSubstring(welcomeMessage, idx))
}
}
Here, we wrote a basic for loop that calls our custom getSubstring function that returns a substring composed with the values from the int slice and the input string.
Compile and execute the above code, and you will receive the following result:
\[[0 5\] [27 31]] Index 0 = 0 - 5 = Hello Index 1 = 27 - 31 = york
Compiling and reusing regular expression patterns
Compile method compiles a regular expression pattern so it can be reused in more complex queries.
attern, compileErr := regexp.Compile("[A-z]ork")
Here is how to write a compile pattern in Golang:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern, compileErr := regexp.Compile("[A-z]ork")
correctAnswer := "Yes, I love new york city"
question := "Do you love new york city?"
wrongAnswer := "I love dogs"
if compileErr == nil {
fmt.Println("Question:", pattern.MatchString(question))
fmt.Println("Correct Answer:", pattern.MatchString(correctAnswer))
fmt.Println("Wrong Answer:", pattern.MatchString(wrongAnswer))
} else {
fmt.Println("Error:", compileErr)
}
}
Because the pattern only needs to be compiled once, this is more efficient. The MatchString function is defined by an instance of the RegExp type, which is returned by the Compile function.
Compiling a pattern also gives you access to regular expression features and techniques.
Compile and execute the above code, and you will receive the following result:
Question: true Correct Answer: true Wrong Answer: false
Using a regular expression to split strings
The Split method splits a string using the matches made by a regular expression. It takes a string and int arguments and returns a slice of the split substrings. The int parameter of -1 returns a slice of substrings of all successive matches of the pattern.
Split(s string, n int)
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("guys|york")
welcomeMessage := "Hello guys, welcome to new york city"
split := pattern.Split(welcomeMessage, -1)
for _, s := range split {
if s != "" {
fmt.Println("Substring:", s)
}
}
}
Here, we wrote a basic for loop to print each split substring.
You can experiment more by replacing -1 with other numbers.
More great articles from LogRocket:
- Don't miss a moment with The Replay, a curated newsletter from LogRocket
- Learn how LogRocket's Galileo cuts through the noise to proactively resolve issues in your app
- Use React's useEffect to optimize your application's performance
- Switch between multiple versions of Node
- Discover how to animate your React app with AnimXYZ
- Explore Tauri, a new framework for building binaries
- Compare NestJS vs. Express.js
Compile and execute the above code, and you will receive the following result:
[Hello , welcome to new city] Substring: Hello Substring: , welcome to new Substring: city
Subexpressions
Subexpressions make it easier to retrieve substrings from within a matched region by allowing sections of a regular expression to be accessed. Subexpressions are denoted with parentheses. It can be used to identify the regions of content that are important within the pattern:
pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")
FindStringSubmatch
The FindStringSubmatch method is a subexpression method that does the same thing as the FindString method but additionally returns the substrings matched by the expressions:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")
welcomeMessage := "Hello guys, welcome to new york city"
subStr := pattern.FindStringSubmatch(welcomeMessage)
fmt.Println(subStr)
for _, s := range subStr {
fmt.Println("Match:", s)
}
}
Here, we’ve defined two subexpressions, one for each variable component of the pattern.
Compile and execute the above code, and you will receive the following result:
[welcome to new york city to york] Match: welcome to new york city Match: to Match: york
Naming subexpressions
Subexpressions can also be named to ease processing of the resulting outputs.
Here is how to name a subexpression: within parentheses, add a question mark, followed by an uppercase P, followed by the name within angle brackets.
Here is a snippet for the above explanation:
pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
Here, the subexpressions are given the names val1 and val2.
The regexp methods for subexpressions
SubexpNames()
This method returns a slice containing the names of the subexpressions, expressed in the order in which they are defined:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
replaced := pattern.SubexpNames()
fmt.Println(replaced)
}
Compile and execute the above code, and you will receive the following result:
[ val1 val2]
NumSubexp()
This method returns the number of subexpressions:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
replaced := pattern.NumSubexp()
fmt.Println(replaced)
}
Compile and execute the above code, and you will receive the following result:
2
Check out Golang documentation for more regexp methods for subexpressions.
Using a Regular Expression to Replace Substrings
The regexp package provides a number of methods for replacing substrings.
ReplaceAllString(src, repl string)
This method takes in the string and a template parameter and substitutes the matched portion of the string (s) with the specified template, which is expanded before it is included in the result to accommodate subexpressions:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
welcomeMessage := "Hello guys, welcome to new york city"
template := "(value 1: ${val1}, value 2: ${val2})"
replaced := pattern.ReplaceAllString(welcomeMessage, template)
fmt.Println(replaced)
}
Compile and execute the above code, and you will receive the following result:
Hello guys, (value 1: to, value 2: york)
ReplaceAllLiteralString(src, repl string)
This method takes in the string and a template parameter and substitutes the matched piece of the string (s) with the specified template, which is included in the result without being expanded for subexpressions:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
welcomeMessage := "Hello guys, welcome to new york city"
template := "(value 1: ${val1}, value 2: ${val2})"
replaced := pattern.ReplaceAllLiteralString(welcomeMessage, template)
fmt.Println(replaced)
}
Compile and execute the above code, and you will receive the following result:
Hello guys, (value 1: ${val1}, value 2: ${val2})
Using a function to replace matched content
The ReplaceAllStringFunc method substitutes content generated by a function for the matched portion of the input string:
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")
welcomeMessage := "Hello guys, welcome to new york city"
replaced := pattern.ReplaceAllStringFunc(welcomeMessage, func(s string) string {
return "here is the replacement content for the matched string."
})
fmt.Println(replaced)
}
Compile and execute the above code, and you will receive the following result:
Hello guys, here is the replacement content for the matched string
Conclusion
In this article, we’ve explored the go regexp package, alongside its inbuilt methods for handling basic to complex matches with regex and compiling and reusing regular expression patterns.
You can check out the go regexp documentation for more information on regular expressions with Golang.
Cut through the noise of traditional error reporting with LogRocket
LogRocket is a digital experience analytics solution that shields you from the hundreds of false-positive errors alerts to just a few truly important items. LogRocket tells you the most impactful bugs and UX issues actually impacting users in your applications.
Then, use session replay with deep technical telemetry to see exactly what the user saw and what caused the problem, as if you were looking over their shoulder.
LogRocket automatically aggregates client side errors, JS exceptions, frontend performance metrics, and user interactions. Then LogRocket uses machine learning to tell you which problems are affecting the most users and provides the context you need to fix it.
Focus on the bugs that matter — try LogRocket today.
