Regular Expressions

Go offers built-in support for regular expressions. Here are some examples of common regexp-related tasks in Go.

package main

import (
    "bytes"
    "fmt"
    "regexp"
)

func main() {

    // This tests whether a pattern matches a string.
    match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
    fmt.Println(match)

    // Above we used a string pattern directly
    // but for other regexp tasks you’ll need to Compile an optimized Regexp struct.
    r, _ := regexp.Compile("p([a-z]+)ch")

    // Many methods are available on these structs.
    // Here’s a match test like we saw earlier.
    fmt.Println(r.MatchString("peach"))

    // This finds the match for the regexp.
    fmt.Println(r.FindString("peach punch"))

    // This also finds the first match but returns the start 
    // and end indexes for the match instead of the matching text.
    fmt.Println("idx:", r.FindStringIndex("peach punch"))

    // The Submatch variants include information about both 
    // the whole-pattern matches and the submatches within those matches.
    // For example this will return information for both p([a-z]+)ch and ([a-z]+).
    fmt.Println(r.FindStringSubmatch("peach punch"))

    // Similarly this will return information 
    // about the indexes of matches and submatches.
    fmt.Println(r.FindStringSubmatchIndex("peach punch"))

    // The All variants of these functions apply to all 
    // matches in the input, not just the first.
    // For example to find all matches for a regexp.
    fmt.Println(r.FindAllString("peach punch pinch", -1))

    // These All variants are available for the other functions we saw above as well.
    fmt.Println("all:", r.FindAllStringSubmatchIndex(
        "peach punch pinch", -1))

    // Providing a non-negative integer as the second argument
    // to these functions will limit the number of matches.
    fmt.Println(r.FindAllString("peach punch pinch", 2))

    // Our examples above had string arguments and used names like MatchString.
    // We can also provide []byte arguments and drop String from the function name.
    fmt.Println(r.Match([]byte("peach")))

    // When creating global variables with regular expressions
    // you can use the MustCompile variation of Compile.
    // MustCompile panics instead of returning an error
    // which makes it safer to use for global variables.
    r = regexp.MustCompile("p([a-z]+)ch")
    fmt.Println("regexp:", r)

    // The regexp package can also be used to replace
    // subsets of strings with other values.
    fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))

    // The Func variant allows you to transform matched text with a given function.
    in := []byte("a peach")
    out := r.ReplaceAllFunc(in, bytes.ToUpper)
    fmt.Println(string(out))
}

$ go run regular-expressions.go
true
true
peach
idx: [0 5]
[peach ea]
[0 5 1 3]
[peach punch pinch]
all: [[0 5 1 3] [6 11 7 9] [12 17 13 15]]
[peach punch]
true
regexp: p([a-z]+)ch
a <fruit>
a PEACH

For a complete reference on Go regular expressions check the regexp package docs.