434 lines
11 KiB
Go
434 lines
11 KiB
Go
|
// Copyright 2013 The Go Authors. All rights reserved.
|
||
|
|
// Use of this source code is governed by a BSD-style
|
||
|
|
// license that can be found in the LICENSE file.
|
||
|
|
|
||
|
|
package regexp_test
|
||
|
|
|
||
|
|
import (
|
||
|
|
"fmt"
|
||
|
|
"regexp"
|
||
|
|
"strings"
|
||
|
|
)
|
||
|
|
|
||
|
|
func Example() {
|
||
|
|
// Compile the expression once, usually at init time.
|
||
|
|
// Use raw strings to avoid having to quote the backslashes.
|
||
|
|
var validID = regexp.MustCompile(`^[a-z]+\[[0-9]+\]$`)
|
||
|
|
|
||
|
|
fmt.Println(validID.MatchString("adam[23]"))
|
||
|
|
fmt.Println(validID.MatchString("eve[7]"))
|
||
|
|
fmt.Println(validID.MatchString("Job[48]"))
|
||
|
|
fmt.Println(validID.MatchString("snakey"))
|
||
|
|
// Output:
|
||
|
|
// true
|
||
|
|
// true
|
||
|
|
// false
|
||
|
|
// false
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleMatch() {
|
||
|
|
matched, err := regexp.Match(`foo.*`, []byte(`seafood`))
|
||
|
|
fmt.Println(matched, err)
|
||
|
|
matched, err = regexp.Match(`bar.*`, []byte(`seafood`))
|
||
|
|
fmt.Println(matched, err)
|
||
|
|
matched, err = regexp.Match(`a(b`, []byte(`seafood`))
|
||
|
|
fmt.Println(matched, err)
|
||
|
|
|
||
|
|
// Output:
|
||
|
|
// true <nil>
|
||
|
|
// false <nil>
|
||
|
|
// false error parsing regexp: missing closing ): `a(b`
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleMatchString() {
|
||
|
|
matched, err := regexp.MatchString(`foo.*`, "seafood")
|
||
|
|
fmt.Println(matched, err)
|
||
|
|
matched, err = regexp.MatchString(`bar.*`, "seafood")
|
||
|
|
fmt.Println(matched, err)
|
||
|
|
matched, err = regexp.MatchString(`a(b`, "seafood")
|
||
|
|
fmt.Println(matched, err)
|
||
|
|
// Output:
|
||
|
|
// true <nil>
|
||
|
|
// false <nil>
|
||
|
|
// false error parsing regexp: missing closing ): `a(b`
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleQuoteMeta() {
|
||
|
|
fmt.Println(regexp.QuoteMeta(`Escaping symbols like: .+*?()|[]{}^$`))
|
||
|
|
// Output:
|
||
|
|
// Escaping symbols like: \.\+\*\?\(\)\|\[\]\{\}\^\$
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_Find() {
|
||
|
|
re := regexp.MustCompile(`foo.?`)
|
||
|
|
fmt.Printf("%q\n", re.Find([]byte(`seafood fool`)))
|
||
|
|
|
||
|
|
// Output:
|
||
|
|
// "food"
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindAll() {
|
||
|
|
re := regexp.MustCompile(`foo.?`)
|
||
|
|
fmt.Printf("%q\n", re.FindAll([]byte(`seafood fool`), -1))
|
||
|
|
|
||
|
|
// Output:
|
||
|
|
// ["food" "fool"]
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindAllSubmatch() {
|
||
|
|
re := regexp.MustCompile(`foo(.?)`)
|
||
|
|
fmt.Printf("%q\n", re.FindAllSubmatch([]byte(`seafood fool`), -1))
|
||
|
|
|
||
|
|
// Output:
|
||
|
|
// [["food" "d"] ["fool" "l"]]
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindSubmatch() {
|
||
|
|
re := regexp.MustCompile(`foo(.?)`)
|
||
|
|
fmt.Printf("%q\n", re.FindSubmatch([]byte(`seafood fool`)))
|
||
|
|
|
||
|
|
// Output:
|
||
|
|
// ["food" "d"]
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_Match() {
|
||
|
|
re := regexp.MustCompile(`foo.?`)
|
||
|
|
fmt.Println(re.Match([]byte(`seafood fool`)))
|
||
|
|
fmt.Println(re.Match([]byte(`something else`)))
|
||
|
|
|
||
|
|
// Output:
|
||
|
|
// true
|
||
|
|
// false
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindString() {
|
||
|
|
re := regexp.MustCompile(`foo.?`)
|
||
|
|
fmt.Printf("%q\n", re.FindString("seafood fool"))
|
||
|
|
fmt.Printf("%q\n", re.FindString("meat"))
|
||
|
|
// Output:
|
||
|
|
// "food"
|
||
|
|
// ""
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindStringIndex() {
|
||
|
|
re := regexp.MustCompile(`ab?`)
|
||
|
|
fmt.Println(re.FindStringIndex("tablett"))
|
||
|
|
fmt.Println(re.FindStringIndex("foo") == nil)
|
||
|
|
// Output:
|
||
|
|
// [1 3]
|
||
|
|
// true
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindStringSubmatch() {
|
||
|
|
re := regexp.MustCompile(`a(x*)b(y|z)c`)
|
||
|
|
fmt.Printf("%q\n", re.FindStringSubmatch("-axxxbyc-"))
|
||
|
|
fmt.Printf("%q\n", re.FindStringSubmatch("-abzc-"))
|
||
|
|
// Output:
|
||
|
|
// ["axxxbyc" "xxx" "y"]
|
||
|
|
// ["abzc" "" "z"]
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindAllString() {
|
||
|
|
re := regexp.MustCompile(`a.`)
|
||
|
|
fmt.Println(re.FindAllString("paranormal", -1))
|
||
|
|
fmt.Println(re.FindAllString("paranormal", 2))
|
||
|
|
fmt.Println(re.FindAllString("graal", -1))
|
||
|
|
fmt.Println(re.FindAllString("none", -1))
|
||
|
|
// Output:
|
||
|
|
// [ar an al]
|
||
|
|
// [ar an]
|
||
|
|
// [aa]
|
||
|
|
// []
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindAllStringSubmatch() {
|
||
|
|
re := regexp.MustCompile(`a(x*)b`)
|
||
|
|
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-", -1))
|
||
|
|
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-", -1))
|
||
|
|
fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-axb-", -1))
|
||
|
|
fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-ab-", -1))
|
||
|
|
// Output:
|
||
|
|
// [["ab" ""]]
|
||
|
|
// [["axxb" "xx"]]
|
||
|
|
// [["ab" ""] ["axb" "x"]]
|
||
|
|
// [["axxb" "xx"] ["ab" ""]]
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindAllStringSubmatchIndex() {
|
||
|
|
re := regexp.MustCompile(`a(x*)b`)
|
||
|
|
// Indices:
|
||
|
|
// 01234567 012345678
|
||
|
|
// -ab-axb- -axxb-ab-
|
||
|
|
fmt.Println(re.FindAllStringSubmatchIndex("-ab-", -1))
|
||
|
|
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-", -1))
|
||
|
|
fmt.Println(re.FindAllStringSubmatchIndex("-ab-axb-", -1))
|
||
|
|
fmt.Println(re.FindAllStringSubmatchIndex("-axxb-ab-", -1))
|
||
|
|
fmt.Println(re.FindAllStringSubmatchIndex("-foo-", -1))
|
||
|
|
// Output:
|
||
|
|
// [[1 3 2 2]]
|
||
|
|
// [[1 5 2 4]]
|
||
|
|
// [[1 3 2 2] [4 7 5 6]]
|
||
|
|
// [[1 5 2 4] [6 8 7 7]]
|
||
|
|
// []
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindSubmatchIndex() {
|
||
|
|
re := regexp.MustCompile(`a(x*)b`)
|
||
|
|
// Indices:
|
||
|
|
// 01234567 012345678
|
||
|
|
// -ab-axb- -axxb-ab-
|
||
|
|
fmt.Println(re.FindSubmatchIndex([]byte("-ab-")))
|
||
|
|
fmt.Println(re.FindSubmatchIndex([]byte("-axxb-")))
|
||
|
|
fmt.Println(re.FindSubmatchIndex([]byte("-ab-axb-")))
|
||
|
|
fmt.Println(re.FindSubmatchIndex([]byte("-axxb-ab-")))
|
||
|
|
fmt.Println(re.FindSubmatchIndex([]byte("-foo-")))
|
||
|
|
// Output:
|
||
|
|
// [1 3 2 2]
|
||
|
|
// [1 5 2 4]
|
||
|
|
// [1 3 2 2]
|
||
|
|
// [1 5 2 4]
|
||
|
|
// []
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_Longest() {
|
||
|
|
re := regexp.MustCompile(`a(|b)`)
|
||
|
|
fmt.Println(re.FindString("ab"))
|
||
|
|
re.Longest()
|
||
|
|
fmt.Println(re.FindString("ab"))
|
||
|
|
// Output:
|
||
|
|
// a
|
||
|
|
// ab
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_MatchString() {
|
||
|
|
re := regexp.MustCompile(`(gopher){2}`)
|
||
|
|
fmt.Println(re.MatchString("gopher"))
|
||
|
|
fmt.Println(re.MatchString("gophergopher"))
|
||
|
|
fmt.Println(re.MatchString("gophergophergopher"))
|
||
|
|
// Output:
|
||
|
|
// false
|
||
|
|
// true
|
||
|
|
// true
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_NumSubexp() {
|
||
|
|
re0 := regexp.MustCompile(`a.`)
|
||
|
|
fmt.Printf("%d\n", re0.NumSubexp())
|
||
|
|
|
||
|
|
re := regexp.MustCompile(`(.*)((a)b)(.*)a`)
|
||
|
|
fmt.Println(re.NumSubexp())
|
||
|
|
// Output:
|
||
|
|
// 0
|
||
|
|
// 4
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_ReplaceAll() {
|
||
|
|
re := regexp.MustCompile(`a(x*)b`)
|
||
|
|
fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("T")))
|
||
|
|
fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("$1")))
|
||
|
|
fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("$1W")))
|
||
|
|
fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("${1}W")))
|
||
|
|
// Output:
|
||
|
|
// -T-T-
|
||
|
|
// --xx-
|
||
|
|
// ---
|
||
|
|
// -W-xxW-
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_ReplaceAllLiteralString() {
|
||
|
|
re := regexp.MustCompile(`a(x*)b`)
|
||
|
|
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "T"))
|
||
|
|
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "$1"))
|
||
|
|
fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "${1}"))
|
||
|
|
// Output:
|
||
|
|
// -T-T-
|
||
|
|
// -$1-$1-
|
||
|
|
// -${1}-${1}-
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_ReplaceAllString() {
|
||
|
|
re := regexp.MustCompile(`a(x*)b`)
|
||
|
|
fmt.Println(re.ReplaceAllString("-ab-axxb-", "T"))
|
||
|
|
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1"))
|
||
|
|
fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1W"))
|
||
|
|
fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))
|
||
|
|
// Output:
|
||
|
|
// -T-T-
|
||
|
|
// --xx-
|
||
|
|
// ---
|
||
|
|
// -W-xxW-
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_ReplaceAllStringFunc() {
|
||
|
|
re := regexp.MustCompile(`[^aeiou]`)
|
||
|
|
fmt.Println(re.ReplaceAllStringFunc("seafood fool", strings.ToUpper))
|
||
|
|
// Output:
|
||
|
|
// SeaFooD FooL
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_SubexpNames() {
|
||
|
|
re := regexp.MustCompile(`(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)`)
|
||
|
|
fmt.Println(re.MatchString("Alan Turing"))
|
||
|
|
fmt.Printf("%q\n", re.SubexpNames())
|
||
|
|
reversed := fmt.Sprintf("${%s} ${%s}", re.SubexpNames()[2], re.SubexpNames()[1])
|
||
|
|
fmt.Println(reversed)
|
||
|
|
fmt.Println(re.ReplaceAllString("Alan Turing", reversed))
|
||
|
|
// Output:
|
||
|
|
// true
|
||
|
|
// ["" "first" "last"]
|
||
|
|
// ${last} ${first}
|
||
|
|
// Turing Alan
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_SubexpIndex() {
|
||
|
|
re := regexp.MustCompile(`(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)`)
|
||
|
|
fmt.Println(re.MatchString("Alan Turing"))
|
||
|
|
matches := re.FindStringSubmatch("Alan Turing")
|
||
|
|
lastIndex := re.SubexpIndex("last")
|
||
|
|
fmt.Printf("last => %d\n", lastIndex)
|
||
|
|
fmt.Println(matches[lastIndex])
|
||
|
|
// Output:
|
||
|
|
// true
|
||
|
|
// last => 2
|
||
|
|
// Turing
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_Split() {
|
||
|
|
a := regexp.MustCompile(`a`)
|
||
|
|
fmt.Println(a.Split("banana", -1))
|
||
|
|
fmt.Println(a.Split("banana", 0))
|
||
|
|
fmt.Println(a.Split("banana", 1))
|
||
|
|
fmt.Println(a.Split("banana", 2))
|
||
|
|
zp := regexp.MustCompile(`z+`)
|
||
|
|
fmt.Println(zp.Split("pizza", -1))
|
||
|
|
fmt.Println(zp.Split("pizza", 0))
|
||
|
|
fmt.Println(zp.Split("pizza", 1))
|
||
|
|
fmt.Println(zp.Split("pizza", 2))
|
||
|
|
// Output:
|
||
|
|
// [b n n ]
|
||
|
|
// []
|
||
|
|
// [banana]
|
||
|
|
// [b nana]
|
||
|
|
// [pi a]
|
||
|
|
// []
|
||
|
|
// [pizza]
|
||
|
|
// [pi a]
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_Expand() {
|
||
|
|
content := []byte(`
|
||
|
|
# comment line
|
||
|
|
option1: value1
|
||
|
|
option2: value2
|
||
|
|
|
||
|
|
# another comment line
|
||
|
|
option3: value3
|
||
|
|
`)
|
||
|
|
|
||
|
|
// Regex pattern captures "key: value" pair from the content.
|
||
|
|
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
|
||
|
|
|
||
|
|
// Template to convert "key: value" to "key=value" by
|
||
|
|
// referencing the values captured by the regex pattern.
|
||
|
|
template := []byte("$key=$value\n")
|
||
|
|
|
||
|
|
result := []byte{}
|
||
|
|
|
||
|
|
// For each match of the regex in the content.
|
||
|
|
for _, submatches := range pattern.FindAllSubmatchIndex(content, -1) {
|
||
|
|
// Apply the captured submatches to the template and append the output
|
||
|
|
// to the result.
|
||
|
|
result = pattern.Expand(result, template, content, submatches)
|
||
|
|
}
|
||
|
|
fmt.Println(string(result))
|
||
|
|
// Output:
|
||
|
|
// option1=value1
|
||
|
|
// option2=value2
|
||
|
|
// option3=value3
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_ExpandString() {
|
||
|
|
content := `
|
||
|
|
# comment line
|
||
|
|
option1: value1
|
||
|
|
option2: value2
|
||
|
|
|
||
|
|
# another comment line
|
||
|
|
option3: value3
|
||
|
|
`
|
||
|
|
|
||
|
|
// Regex pattern captures "key: value" pair from the content.
|
||
|
|
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
|
||
|
|
|
||
|
|
// Template to convert "key: value" to "key=value" by
|
||
|
|
// referencing the values captured by the regex pattern.
|
||
|
|
template := "$key=$value\n"
|
||
|
|
|
||
|
|
result := []byte{}
|
||
|
|
|
||
|
|
// For each match of the regex in the content.
|
||
|
|
for _, submatches := range pattern.FindAllStringSubmatchIndex(content, -1) {
|
||
|
|
// Apply the captured submatches to the template and append the output
|
||
|
|
// to the result.
|
||
|
|
result = pattern.ExpandString(result, template, content, submatches)
|
||
|
|
}
|
||
|
|
fmt.Println(string(result))
|
||
|
|
// Output:
|
||
|
|
// option1=value1
|
||
|
|
// option2=value2
|
||
|
|
// option3=value3
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindIndex() {
|
||
|
|
content := []byte(`
|
||
|
|
# comment line
|
||
|
|
option1: value1
|
||
|
|
option2: value2
|
||
|
|
`)
|
||
|
|
// Regex pattern captures "key: value" pair from the content.
|
||
|
|
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
|
||
|
|
|
||
|
|
loc := pattern.FindIndex(content)
|
||
|
|
fmt.Println(loc)
|
||
|
|
fmt.Println(string(content[loc[0]:loc[1]]))
|
||
|
|
// Output:
|
||
|
|
// [18 33]
|
||
|
|
// option1: value1
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindAllSubmatchIndex() {
|
||
|
|
content := []byte(`
|
||
|
|
# comment line
|
||
|
|
option1: value1
|
||
|
|
option2: value2
|
||
|
|
`)
|
||
|
|
// Regex pattern captures "key: value" pair from the content.
|
||
|
|
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)
|
||
|
|
allIndexes := pattern.FindAllSubmatchIndex(content, -1)
|
||
|
|
for _, loc := range allIndexes {
|
||
|
|
fmt.Println(loc)
|
||
|
|
fmt.Println(string(content[loc[0]:loc[1]]))
|
||
|
|
fmt.Println(string(content[loc[2]:loc[3]]))
|
||
|
|
fmt.Println(string(content[loc[4]:loc[5]]))
|
||
|
|
}
|
||
|
|
// Output:
|
||
|
|
// [18 33 18 25 27 33]
|
||
|
|
// option1: value1
|
||
|
|
// option1
|
||
|
|
// value1
|
||
|
|
// [35 50 35 42 44 50]
|
||
|
|
// option2: value2
|
||
|
|
// option2
|
||
|
|
// value2
|
||
|
|
}
|
||
|
|
|
||
|
|
func ExampleRegexp_FindAllIndex() {
|
||
|
|
content := []byte("London")
|
||
|
|
re := regexp.MustCompile(`o.`)
|
||
|
|
fmt.Println(re.FindAllIndex(content, 1))
|
||
|
|
fmt.Println(re.FindAllIndex(content, -1))
|
||
|
|
// Output:
|
||
|
|
// [[1 3]]
|
||
|
|
// [[1 3] [4 6]]
|
||
|
|
}
|