How do I use Go's regular expressions for data extraction?

In Go, the regexp package provides regular expressions functionality, which you can use to extract data from text. Here is how you can use Go's regular expressions for data extraction:

• Import the regexp package: First, you need to import the regexp package into your Go program.

import "regexp"

• Compile a regular expression: Use regexp.Compile to compile a regular expression string into a Regexp object. If you're sure that your regular expression is correct and won't fail, you can use regexp.MustCompile which panics if the expression cannot be parsed.

re, err := regexp.Compile(`\w+`)
if err != nil {
    // handle error
}

Or using MustCompile:

re := regexp.MustCompile(`\w+`)

• Find a single match: To find the first occurrence that matches the regular expression, you can use the FindString method.

match := re.FindString("extract this data")
// match now contains the first word from the string "extract this data"

• Find all matches: To find all occurrences that match the regular expression, use the FindAllString method. The second argument is the maximum number of matches to return; use -1 to return all.

matches := re.FindAllString("extract this data, and this too", -1)
// matches now contains all words from the string

• Find submatches (capture groups): If your regular expression contains subexpressions enclosed in parentheses, you can use the FindStringSubmatch method to get a slice of submatches.

re = regexp.MustCompile(`(\w+) (\w+)`)
submatches := re.FindStringSubmatch("extract data")
// submatches now contains: ["extract data", "extract", "data"]

• Find all submatches: Similarly, you can use FindAllStringSubmatch to find all occurrences of submatches.

re = regexp.MustCompile(`(\w+) (\w+)`)
allSubmatches := re.FindAllStringSubmatch("extract data, parse code", -1)
// allSubmatches now contains slices for each pair of words

• Iterate over matches: You can iterate over all matches using a loop.

re = regexp.MustCompile(`\w+`)
text := "extract this data"
matches = re.FindAllString(text, -1)
for _, match := range matches {
    // Do something with each match
    fmt.Println(match)
}

Here's a complete code example that extracts email addresses from a string:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    const text = "Contact us at support@example.com or sales@example.com."
    emailPattern := `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`
    re := regexp.MustCompile(emailPattern)
    emails := re.FindAllString(text, -1)

    for _, email := range emails {
        fmt.Println(email)
    }
}

When running this program, it will print each email address found in the text string:

support@example.com
sales@example.com

Remember to always handle errors when compiling regular expressions and consider the performance implications of using regular expressions in a tight loop or on very large text. Compiled regular expressions are safe for concurrent use by multiple goroutines.