> For the complete documentation index, see [llms.txt](https://docs.atom.codes/sprout/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.atom.codes/sprout/registries/regex.md).
# Regex
{% hint style="info" %}
You can easily import all the functions from the `regex` registry by including the following import statement in your code
```go
import "github.com/go-sprout/sprout/registry/regex"
```
{% endhint %}
{% hint style="warning" %}
The `regex` registry replaces the deprecated [`regexp`](/sprout/registries/regexp.md) registry, which keeps the historical sprig signatures. Both registries expose the same function names, so they are **mutually exclusive**: register one or the other, never both.
Only four functions change their signature, the string to work on moves to the last position:
All the other functions keep the exact same signature, only the import changes. The `must` prefixed versions are not carried over, use the standard functions instead.
{% endhint %}
| `regexp` (deprecated) | `regex` |
| ----------------------------------------------------- | ----------------------------------------------------- |
| `regexFindAll ` | `regexFindAll ` |
| `regexSplit ` | `regexSplit ` |
| `regexReplaceAll ` | `regexReplaceAll ` |
| `regexReplaceAllLiteral ` | `regexReplaceAllLiteral ` |
### regexFind
The function returns the first match found in the string that corresponds to the specified regular expression pattern.
Name
Value
Signature
RegexFind(regex string, value string) (string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "hello world" | regexFind "hello" }} // Output: "hello"
{{ "hello world" | regexFind "\\invalid$^///" }} // Error
```
{% endtab %}
{% endtabs %}
### regexFindAll
The function returns all matches of the regex pattern in the string, up to a specified maximum number of matches (`n`).
Name
Value
Signature
RegexFindAll(regex string, n int, value string) ([]string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "aba acada afa" | regexFindAll "a." 3 }} // Output: [ab a ac]
{{ "aba acada afa" | regexFindAll "\\invalid$^///" 3 }} // Error
```
{% endtab %}
{% endtabs %}
### regexMatch
The function checks if the entire string matches the given regular expression pattern.
Name
Value
Signature
RegexMatch(regex string, value string) (bool, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "Hello" | regexMatch "^[a-zA-Z]+$" }} // Output: true
{{ "Hello" | regexMatch "\\invalid$^///" }} // Error
```
{% endtab %}
{% endtabs %}
### regexSplit
The function splits the string into substrings based on matches of the regex pattern, performing the split up to `n` times.
Name
Value
Signature
RegexSplit(regex string, n int, value string) ([]string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "hello world from Go" | regexSplit "\\s+" 2 }} // Output: [hello world from Go]
{{ "hello world from Go" | regexSplit "\\invalid$^///" 2 }} // Error
```
{% endtab %}
{% endtabs %}
{% hint style="info" %}
The output above is a slice of two elements, `hello` and `world from Go`, rendered by the template engine.
{% endhint %}
### regexReplaceAll
The function replaces all occurrences of the regex pattern in the string with the specified replacement string.
Name
Value
Signature
RegexReplaceAll(regex string, replacedBy string, value string) (string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "R2D2 C3PO" | regexReplaceAll "\\d" "X" }} // Output: "RXDX CXPO"
{{ "R2D2 C3PO" | regexReplaceAll "\\invalid$^///" "X" }} // Error
```
{% endtab %}
{% endtabs %}
### regexReplaceAllLiteral
The function replaces all occurrences of the regex pattern in the string with the specified literal replacement string, without interpreting any special characters in the replacement.
Name
Value
Signature
RegexReplaceAllLiteral(regex string, replacedBy string, value string) (string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "hello world" | regexReplaceAllLiteral "world" "$1" }} // Output: "hello $1"
{{ "hello world" | regexReplaceAllLiteral "none" "all" }} // Output: "hello world"
{{ "hello world" | regexReplaceAllLiteral "\\invalid$^///" "all" }} // Error
```
{% endtab %}
{% endtabs %}
### regexQuoteMeta
The function returns a version of the provided string that can be used as a literal pattern in a regular expression, escaping any special characters.
Name
Value
Signature
RegexQuoteMeta(value string) string
{% tabs %}
{% tab title="Template Example" %}
```go
{{ regexQuoteMeta ".+*?^$()[]{}|" }}
// Output: \\.\\+\\*\\?\\^\\$\\(\\)\\[\\]\\{\\}\\|
```
{% endtab %}
{% endtabs %}
### regexFindGroups
The function finds the first match of a regex pattern in a string and returns the matched groups, with error handling.
Name
Value
Signature
RegexFindGroups(regex string, value string) ([]string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "aaabbb" | regexFindGroups "(a+)(b+)" }} // Output: [aaabbb aaa bbb]
{{ "aaabbb" | regexFindGroups "\\invalid$^///" }} // Error
```
{% endtab %}
{% endtabs %}
### regexFindAllGroups
The function finds all matches of a regex pattern in a string up to a specified limit and returns the matched groups, with error handling.
Name
Value
Signature
RegexFindAllGroups(regex string, n int, value string) ([][]string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "aaabbb aab aaabbb" | regexFindAllGroups "(a+)(b+)" -1 }} // Output: [[aaabbb aaa bbb] [aab aa b] [aaabbb aaa bbb]]
{{ "aaabbb aab aaabbb" | regexFindAllGroups "(a+)(b+)" 1 }} // Output: [[aaabbb aaa bbb]]
{{ "aaabbb" | regexFindAllGroups "\\invalid$^///" -1 }} // Error
```
{% endtab %}
{% endtabs %}
### regexFindNamed
The function finds the first match of a regex pattern with named capturing groups in a string and returns a map of group names to matched strings, with error handling.
Name
Value
Signature
RegexFindNamed(regex string, value string) (map[string]string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ "aaabbb" | regexFindNamed "(?Pa+)(?Pb+)" }} // Output: map[first:aaa second:bbb]
{{ "aaabbb" | regexFindNamed "(?Pa+)(b+)" }} // Output: map[first:aaa]
{{ "bbb" | regexFindNamed "(?Pa+)" }} // Output: map[]
{{ "aaabbb" | regexFindNamed "\\invalid$^///" }} // Error
```
{% endtab %}
{% endtabs %}
### regexFindAllNamed
The function finds all matches of a regex pattern with named capturing groups in a string up to a specified limit and returns a slice of maps of group names to matched strings, with error handling.
Name
Value
Signature
RegexFindAllNamed(regex string, n int, value string) ([]map[string]string, error)