Go Regex

Introduction

Regular expressions (regex) are used for pattern matching and text manipulation. In Go, the regexp package provides a way to work with regular expressions. In this chapter, you will learn the basics of using regular expressions in Go, including how to compile, match, and manipulate strings using regex.

Importing the Regexp Package

To use regular expressions in Go, you need to import the regexp package.

Example:

import "regexp"

Compiling Regular Expressions

Before using a regular expression, you need to compile it using the regexp.Compile or regexp.MustCompile function.

Compile

The regexp.Compile function returns a Regexp object and an error. You should check for errors to ensure the regex is valid.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re, err := regexp.Compile("a*b")
    if err != nil {
        fmt.Println("Error compiling regex:", err)
        return
    }
    fmt.Println("Compiled regex:", re)
}

MustCompile

The regexp.MustCompile function is similar to regexp.Compile, but it panics if the regex is invalid. It is useful for regex patterns that are known to be correct.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    fmt.Println("Compiled regex:", re)
}

Matching Strings

You can use the Regexp object to match strings using various methods.

MatchString

The MatchString method checks if a string matches the regex pattern.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    fmt.Println(re.MatchString("aaaab")) // Output: true
    fmt.Println(re.MatchString("ab"))    // Output: true
    fmt.Println(re.MatchString("b"))     // Output: true
    fmt.Println(re.MatchString("c"))     // Output: false
}

FindString

The FindString method returns the first occurrence of the pattern in the string.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    fmt.Println(re.FindString("aaaab ccc ab ddd")) // Output: aaaab
}

FindAllString

The FindAllString method returns all occurrences of the pattern in the string.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    fmt.Println(re.FindAllString("aaaab ccc ab ddd", -1)) // Output: [aaaab ab]
}

FindStringIndex

The FindStringIndex method returns the start and end index of the first match.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    fmt.Println(re.FindStringIndex("aaaab ccc ab ddd")) // Output: [0 5]
}

FindAllStringIndex

The FindAllStringIndex method returns the start and end index of all matches.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    fmt.Println(re.FindAllStringIndex("aaaab ccc ab ddd", -1)) // Output: [[0 5] [9 11]]
}

ReplaceAllString

The ReplaceAllString method replaces all matches with a specified replacement string.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    result := re.ReplaceAllString("aaaab ccc ab ddd", "X")
    fmt.Println(result) // Output: X ccc X ddd
}

Split

The Split method splits a string into substrings separated by the matches.

Example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("a*b")
    result := re.Split("aaaab ccc ab ddd", -1)
    fmt.Println(result) // Output: [ ccc  ddd]
}

Conclusion

Regular expressions in Go are used for pattern matching and text manipulation. By understanding how to compile regex patterns and use the various methods provided by the regexp package, you can effectively work with strings in your Go programs. Whether you need to match, find, replace, or split strings, regular expressions provide a flexible and efficient way to handle text processing tasks.