Golang Regexp.ReplaceAllFunc
last modified April 20, 2025
This tutorial explains how to use the Regexp.ReplaceAllFunc method in Go.
We'll cover regex replacement with custom functions and provide practical examples.
A regular expression is a sequence of characters that defines a search pattern. It's used for pattern matching within strings.
The Regexp.ReplaceAllFunc method replaces all matches of a regex pattern using a custom function to generate replacement strings. This provides flexible string manipulation capabilities.
Basic ReplaceAllFunc Example
The simplest use of ReplaceAllFunc converts matched text to uppercase.
This demonstrates the basic pattern of defining a replacement function.
package main
import (
"fmt"
"regexp"
"strings"
)
func main() {
re := regexp.MustCompile(`\b\w+\b`)
text := "hello world from go"
result := re.ReplaceAllFunc([]byte(text), func(match []byte) []byte {
return []byte(strings.ToUpper(string(match)))
})
fmt.Println(string(result)) // HELLO WORLD FROM GO
}
We match word boundaries and convert each word to uppercase. The replacement function receives each match and returns the transformed version.
Conditional Replacement
ReplaceAllFunc allows conditional replacement based on match content.
Here we replace numbers with their word equivalents only if they're less than 5.
package main
import (
"fmt"
"regexp"
"strconv"
)
func main() {
re := regexp.MustCompile(`\d+`)
text := "I have 3 apples and 10 oranges"
result := re.ReplaceAllFunc([]byte(text), func(match []byte) []byte {
num, _ := strconv.Atoi(string(match))
if num < 5 {
words := []string{"zero", "one", "two", "three", "four"}
return []byte(words[num])
}
return match
})
fmt.Println(string(result)) // I have three apples and 10 oranges
}
The function checks each number match and converts small numbers to words while leaving larger numbers unchanged. This shows dynamic replacement logic.
Complex Transformation
We can perform complex transformations on matches. This example converts date formats from MM/DD/YYYY to YYYY-MM-DD.
package main
import (
"fmt"
"regexp"
"strings"
)
func main() {
re := regexp.MustCompile(`(\d{2})/(\d{2})/(\d{4})`)
text := "Start date: 04/20/2025, End date: 12/31/2025"
result := re.ReplaceAllFunc([]byte(text), func(match []byte) []byte {
parts := strings.Split(string(match), "/")
return []byte(parts[2] + "-" + parts[0] + "-" + parts[1])
})
fmt.Println(string(result)) // Start date: 2025-04-20, End date: 2025-12-31
}
The replacement function splits the matched date and rearranges the components. This demonstrates parsing and reconstructing matched text.
Incrementing Numbers
ReplaceAllFunc can modify numeric values in text. Here we increment
all numbers found in a string by 1.
package main
import (
"fmt"
"regexp"
"strconv"
)
func main() {
re := regexp.MustCompile(`\d+`)
text := "Version 1, Revision 3, Page 42"
result := re.ReplaceAllFunc([]byte(text), func(match []byte) []byte {
num, _ := strconv.Atoi(string(match))
return []byte(strconv.Itoa(num + 1))
})
fmt.Println(string(result)) // Version 2, Revision 4, Page 43
}
Each matched number is converted to an integer, incremented, and converted back to a string. This shows numeric manipulation during replacement.
Markdown to HTML Conversion
We can use ReplaceAllFunc for simple text markup conversion. This
example converts Markdown bold syntax to HTML strong tags.
package main
import (
"fmt"
"regexp"
)
func main() {
re := regexp.MustCompile(`\*\*(.*?)\*\*`)
text := "This is **important** and **urgent**"
result := re.ReplaceAllFunc([]byte(text), func(match []byte) []byte {
content := match[2 : len(match)-2] // Remove ** markers
return []byte("" + string(content) + "")
})
fmt.Println(string(result)) // This is important and urgent
}
The function extracts text between ** markers and wraps it in HTML strong tags. This demonstrates content extraction during replacement.
Password Obfuscation
ReplaceAllFunc can be used for sensitive data obfuscation. This
example masks passwords in a configuration string.
package main
import (
"fmt"
"regexp"
"strings"
)
func main() {
re := regexp.MustCompile(`password=["'](.*?)["']`)
text := `user="admin" password="secret123" role="admin"`
result := re.ReplaceAllFunc([]byte(text), func(match []byte) []byte {
parts := strings.Split(string(match), "=")
return []byte(parts[0] + `="*******"`)
})
fmt.Println(string(result)) // user="admin" password="*******" role="admin"
}
Password values are replaced with asterisks while preserving the configuration structure. This shows how to handle sensitive data safely.
Template Variable Expansion
We can use ReplaceAllFunc for template variable expansion. This
example replaces ${var} patterns with values from a map.
package main
import (
"fmt"
"regexp"
)
func main() {
re := regexp.MustCompile(`\$\{(\w+)\}`)
text := "Hello ${name}, your balance is ${amount}"
vars := map[string]string{
"name": "John",
"amount": "$100",
}
result := re.ReplaceAllFunc([]byte(text), func(match []byte) []byte {
key := string(match[2 : len(match)-1]) // Extract variable name
return []byte(vars[key])
})
fmt.Println(string(result)) // Hello John, your balance is $100
}
The function looks up each variable name in a map and replaces the template pattern with the corresponding value. This demonstrates dynamic content insertion.
Source
Go regexp.ReplaceAllFunc documentation
This tutorial covered the Regexp.ReplaceAllFunc method in Go with
practical examples of flexible string replacement using custom functions.
Author
List all Go tutorials.