知识点 正则

标签：detail   def   mod   函数   nan   Once   import   stderr   NPU   

https://blog.csdn.net/dhd040805/article/details/80259993
https://www.cnblogs.com/nulige/p/10260149.html
先查看以上两篇文章

package main

import (

    "fmt"

    "regexp"

)

func main() {

    reg, err := regexp.Compile("[a-z0-9#$%&]+")

    if err != nil {

        fmt.Println(err)

    }

    fmt.Println(reg.MatchString("AIh"))

    fmt.Println(reg.MatchString("an82&#"))

}

运行结果：

false

true

第一个字符串AIh不匹配，第二个an82&#匹配。传入函数(re *Regexp) MatchString(s string) bool的字符串的每一个字符都会被检验是否属于[a-z0-9#$%&]其中的一个，

a-z表示从小写a到小写z的26个英文字母，0-9表示从0到9的10个数字，#$%&是四个特殊字符，AIh中有两个大写字母，一个小写字母，h属于a-z，但字母A和I都不属于a-z，

也不属于0-9，也不属于特殊字符，所以第一个不匹配，只要一段内容中有一个字符不匹配[a-z0-9#$%&]+，就表示该段内容不匹配，中括号外面的加号+表示多个匹配，

即要求每一个字符都属于小写字母或数字，或四个特殊字符中的一个；

[a-z0-7#$%&]去掉加号，表示某个字符串中只要有一个字符匹配，就表示匹配，每一个字符都不匹配，才表示不匹配。

reg, err := regexp.Compile("[a-z0-7#$%&]")

    if err != nil {

        fmt.Println(err)

    }

    fmt.Println(reg.MatchString("AI"))

    fmt.Println(reg.MatchString("an82&#"))

    fmt.Println(reg.MatchString("A!+"))

    fmt.Println(reg.MatchString("aA!+"))

    fmt.Println(reg.MatchString(strconv.Itoa(8)))

    fmt.Println(reg.MatchString(strconv.Itoa(789)))

运行结果：

false

true

false

true

false

true

regexp.MustCompile函数的用法

该函数比regexp.Compile少一个返回值error，除此之外用法一样

package main

import (

    "fmt"

    "regexp"

    "strconv"

)

func main() {

    s := "日本"

    s2 := "中国"

    s3 := "ad"

    s4 := "G"

    s5 := 9

    s6 := 708

    s7 := "@"

    s8 := "国8h+¥œ"

    s9 := "%"

    s10 := "^"

    ss := make([]string, 0)

    ss = append(ss, s, s2, s3, s4, strconv.Itoa(s5), strconv.Itoa(s6), s7, s8, s9, s10)

    reg := regexp.MustCompile("^[a-zA-Z0-8中国!@#&*+_¥œø]+$")

    for k, v := range ss {

        fmt.Println(k, v, reg.MatchString(v))

    }

}

运行结果：

0 日本 false

1 中国 true

2 ad true

3 G true

4 9 false

5 708 true

6 @ true

7 国8h+¥œ true

8 % false

9 ^ false

函数Compile(expr string) (*Regexp, error)和MustCompile(str string) *Regexp的参数是正则表达式；

函数(re *Regexp) MatchString(s string) bool的参数是需要检验的内容，

匹配中文

正则表达式"^[a-zA-Z0-9\u4e00-\u9fa5]{3,8}$"，匹配小写字母、大写字母、数字、或中文，长度3到8位。

package main

import (

    "fmt"

    "regexp"

)

func main() {

    reg, err := regexp.Compile("^[a-zA-Z0-9\u4e00-\u9fa5]{3,8}$")

    if err != nil {

        fmt.Println(err)

    }

    fmt.Println(reg.MatchString("春暖花开"))

    fmt.Println(reg.MatchString("春暖"))

    fmt.Println(reg.MatchString("568"))

    fmt.Println(reg.MatchString("aingege"))

    fmt.Println(reg.MatchString("EIOGNE"))

    fmt.Println(reg.MatchString("DIfin梅6"))

}

运行结果：

true

false

true

true

true

true

函数Compile和MustCompile传入参数时要写在英文双引号里面，不可以是单引号，也不可以是特殊字符 ` //待验证

package main 

import "bytes"

import "fmt"

import "regexp"

func main() {

    // 1. 这个测试一个字符串是否符合一个表达式。

    match, _ := regexp.MatchString("p([a-z]+)ch", "peach")

    fmt.Println("1.", match)

    // 上面我们是直接使用字符串，但是对于一些其他的正则任务，你需要使用 Compile 一个优化的 Regexp 结构体。

    r, _ := regexp.Compile("p([a-z]+)ch")

    // 2. 这个结构体有很多方法，这里是类似我们前面看到的一个匹配测试。

    fmt.Println("2.", r.MatchString("peach"))

    // 3. 这是查找匹配字符串的。

    fmt.Println("3.", r.FindString("peach punch"))

    // 4. 这个也是查找第一次匹配的字符串的，但是返回的匹配开始和结束位置索引，而不是匹配的内容。

    fmt.Println("4.", r.FindStringIndex("peach punch"))

    // 5. Submatch 返回 完全匹配 和 局部匹配 的字符串。例如，这里会返回 p([a-z]+)ch 和 ([a-z]+) 的信息。

    fmt.Println("5.", r.FindStringSubmatch("peach punch"))

    // 6. 类似的，这个会返回 完全匹配 和 局部匹配 的索引位置。

    fmt.Println("6.", r.FindStringSubmatchIndex("peach punch"))

    // 7. 带 All 的这个函数返回所有的匹配项，而不仅仅是首次匹配项。例如查找匹配表达式的所有项。

    fmt.Println("7.", r.FindAllString("peach punch pinch", -1))

    // 8. All 同样可以对应到上面的所有函数。

    fmt.Println("8.", r.FindAllStringSubmatchIndex("peach punch pinch", -1))

    // 9. 这个函数提供一个正整数来限制匹配次数。

    fmt.Println("9.", r.FindAllString("peach punch pinch", 2))

    // 10. 上面的例子中，我们使用了字符串作为参数，并使用了如 MatchString 这样的方法。我们也可以提供 []byte参数并将 String 从函数命中去掉。

    fmt.Println("10.", r.Match([]byte("peach")))

    // 11. 创建正则表示式常量时，可以使用 Compile 的变体MustCompile 。因为 Compile 返回两个值，不能用语常量。

    r = regexp.MustCompile("p([a-z]+)ch")

    fmt.Println("11.", r)

    // 12. regexp 包也可以用来替换部分字符串为其他值。

    fmt.Println("12.", r.ReplaceAllString("a peach", "<fruit>"))

    // 13. Func 变量允许传递匹配内容到一个给定的函数中，

    in := []byte("a peach")

    out := r.ReplaceAllFunc(in, bytes.ToUpper)

    fmt.Println("13.", string(out))

}

运行结果：

1. true

2. true

3. peach

4. [0 5]

5. [peach ea]

6. [0 5 1 3]

7. [peach punch pinch]

8. [[0 5 1 3] [6 11 7 9] [12 17 13 15]]

9. [peach punch]

10. true

11. p([a-z]+)ch

12. a <fruit>

13. a PEACH

我们期望在字符串  1000abcd123  中找出前后两个数字。

例子1：匹配到这个字符串的例子 

package main

import(

    "fmt"

    "regexp"

)

var digitsRegexp = regexp.MustCompile(`(\d+)\D+(\d+)`)

func main(){

    someString:="1000abcd123"

    fmt.Println(digitsRegexp.FindStringSubmatch(someString))

}

上面代码输出：

[1000abcd123 1000 123]

例子2：使用带命名的正则表达式

package main

import(

    "fmt"

    "regexp"

)

var myExp=regexp.MustCompile(`(?P<first>\d+)\.(\d+).(?P<second>\d+)`)

func main(){

    fmt.Printf("%+v",myExp.FindStringSubmatch("1234.5678.9"))

}

上面代码输出，所有匹配到的都输出了： 

[1234.5678.9 1234 5678 9] 

这里的Named capturing groups  (?P<name>) 方式命名正则表达式是 python、Go语言特有的， java、c# 是 (?<name>) 命名方式。

例子3：对正则表达式类扩展一个获得所有命名信息的方法，并使用它。

package main

import(

    "fmt"

    "regexp"

)

//embed regexp.Regexp in a new type so we can extend it

type myRegexp struct{ 

    *regexp.Regexp

}

//add a new method to our new regular expression type

func(r *myRegexp)FindStringSubmatchMap(s string) map[string]string{

    captures:=make(map[string]string)

    match:=r.FindStringSubmatch(s)

    if match==nil{

        return captures

    }

    for i,name:=range r.SubexpNames(){

        //Ignore the whole regexp match and unnamed groups

        if i==0||name==""{

            continue

        }

        captures[name]=match[i]

    }

    return captures

}

//an example regular expression

var myExp=myRegexp{regexp.MustCompile(`(?P<first>\d+)\.(\d+).(?P<second>\d+)`)}

func main(){

    mmap:=myExp.FindStringSubmatchMap("1234.5678.9")

    ww:=mmap["first"]

    fmt.Println(mmap)

    fmt.Println(ww)

}

上面代码的输出结果：

map[first:1234 second:9]

1234

例子4，抓取限号信息，并记录到一个Map中。 

package main

import(

    "fmt"

    iconv "github.com/djimenez/iconv-go"

    "io/ioutil"

    "net/http"

    "os"

    "regexp"

)

// embed regexp.Regexp in a new type so we can extend it

type myRegexp struct{

    *regexp.Regexp

}

// add a new method to our new regular expression type

func(r *myRegexp)FindStringSubmatchMap(s string)[](map[string]string){

    captures:=make([](map[string]string),0)

    matches:=r.FindAllStringSubmatch(s,-1)

    if matches==nil{

        return captures

    }

    names:=r.SubexpNames()

    for _,match:=range matches{

        cmap:=make(map[string]string)

        for pos,val:=range match{

            name:=names[pos]

            if name==""{

                continue

            }

            /*

                fmt.Println("+++++++++")

                fmt.Println(name)

                fmt.Println(val)

            */

            cmap[name]=val

        }

        captures=append(captures,cmap)

    }

    return captures

}

// 抓取限号信息的正则表达式

var myExp=myRegexp{regexp.MustCompile(`自(?P<byear>[\d]{4})年(?P<bmonth>[\d]{1,2})月(?P<bday>[\d]{1,2})日至(?P<eyear>[\d]{4})年(?P<emonth>[\d]{1,2})月(?P<eday>[\d]{1,2})日，星期一至星期五限行机动车车牌尾号分别为：(?P<n11>[\d])和(?P<n12>[\d])、(?P<n21>[\d])和(?P<n22>[\d])、(?P<n31>[\d])和(?P<n32>[\d])、(?P<n41>[\d])和(?P<n42>[\d])、(?P<n51>[\d])和(?P<n52>[\d])`)}

func ErrorAndExit(err error){

    fmt.Fprintln(os.Stderr,err)

    os.Exit(1)

}

func main(){

    response,err:=http.Get("http://www.bjjtgl.gov.cn/zhuanti/10weihao/index.html")

    defer response.Body.Close()

    if err!=nil{

        ErrorAndExit(err)

    }

    input,err:=ioutil.ReadAll(response.Body)

    if err!=nil{

        ErrorAndExit(err)

    }

    body :=make([]byte,len(input))

    iconv.Convert(input,body,"gb2312","utf-8")

    mmap:=myExp.FindStringSubmatchMap(string(body))

    fmt.Println(mmap)

}

上述代码输出：

[map[n32:0 n22:9 emonth:7 n11:3 n41:1 n21:4 n52:7 bmonth:4 n51:2 bday:9 n42:6 byear:2012 eday:7 eyear:2012 n12:8 n31:5] 

map[emonth:10 n41:5 n52:6 n31:4 byear:2012 n51:1 eyear:2012 n32:9 bmonth:7 n22:8 bday:8 n11:2 eday:6 n42:0 n21:3 n12:7] 

map[bday:7 n51:5 n22:7 n31:3 eday:5 n32:8 byear:2012 bmonth:10 emonth:1 eyear:2013 n11:1 n12:6 n52:0 n21:2 n42:9 n41:4] 

map[eyear:2013 byear:2013 n22:6 eday:10 bmonth:1 n41:3 n32:7 n31:2 n21:1 n11:5 bday:6 n12:0 n51:4 n42:8 emonth:4 n52:9]]

这段代码首先下载北京市交管局的网页；然后把这个gb2312的页面转换成utf-8编码，然后用正则表达式提取其中的限号信息。

func ExampleRegexp_Split() {
a := regexp.MustCompile(`a`)
fmt.Println(a.Split("banana", -1))// [b n n ]
fmt.Println(a.Split("banana", 0)) // []
fmt.Println(a.Split("banana", 1)) // [banana]
fmt.Println(a.Split("banana", 2)) // [b nana]
zp := regexp.MustCompile(`z+`)
fmt.Println(zp.Split("pizza", -1)) // [pi a]
fmt.Println(zp.Split("pizza", 0)) // []
fmt.Println(zp.Split("pizza", 1)) // [pizza]
fmt.Println(zp.Split("pizza", 2)) // [pi a]
}

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]")) //true
fmt.Println(validID.MatchString("eve[7]")) //true
fmt.Println(validID.MatchString("Job[48]")) //false
fmt.Println(validID.MatchString("snakey")) //false
}

// i : case insensitive
fmt.Println(regexp.MatchString(`abc`, "Abc")) //false
fmt.Println(regexp.MatchString(`(?i)abc`, "Abc")) //true

// m : multi-line mode: ^ and $ match begin/end line in addition to begin/end text
fmt.Println(regexp.MustCompile(`aaa$`).FindAllString("aaa\naaa", -1)) //[aaa]
fmt.Println(regexp.MustCompile(`(?m)aaa$`).FindAllString("aaa\naaa", -1)) //[aaa aaa]

// s : let . match \n
fmt.Println(regexp.MatchString(`^a.*b$`, "ab")) //true
fmt.Println(regexp.MatchString(`^a.*b$`, "a\nb")) //false
fmt.Println(regexp.MatchString(`(?s)^a.*b$`, "a\nb")) //true

greedy := regexp.MustCompile(`a.+`)
nonGreedy := regexp.MustCompile(`a.+?`)
fmt.Println(greedy.FindString("abcd")) //abcd
fmt.Println(nonGreedy.FindString("abcd")) //ab

greedy = regexp.MustCompile(`ab*`)
nonGreedy = regexp.MustCompile(`ab*?`)
fmt.Println(greedy.FindString("abbbb")) //abbbb
fmt.Println(nonGreedy.FindString("abbbb")) //a

greedy = regexp.MustCompile(`(?U)ab*`)
nonGreedy = regexp.MustCompile(`(?U)ab*?`)
fmt.Println(greedy.FindString("abbbb")) //a
fmt.Println(nonGreedy.FindString("abbbb")) //abbbb

//邮箱 最高30位

func (ic *RegexCheck) IsEmail(str ...string) bool {

    var b bool

    for _, s := range str {

        b, _ = regexp.MatchString("^([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})$", s)

        if false == b {

            return b

        }

    }

    return b

}

package main

import (

    "fmt"

    "regexp"

)

func main() {

    str := "880218end"

    match, _ := regexp.MatchString("\\d{6}", str) //六位连续的数字

    fmt.Println(match)    //输出true

    reg := regexp.MustCompile("\\d{6}")

    //返回str中第一个匹配reg的字符串

    data := reg.Find([]byte(str))

    fmt.Println(string(data))  //880218

    //go语言正则表达式判断是否为汉字

    matchChinese, _ := regexp.Match("[\u4e00-\u9fa5]", []byte("经度"))

    fmt.Println(matchChinese)       //输出true

    //go语言正则表达式判断是否含有字符（大小写）

    matchChar, _ := regexp.Match("[a-zA-Z]", []byte("av132"))

    fmt.Println(matchChar)         //输出false

    //go语言正则表达式判断是否含有以数字开头，不是为true

    matchDigit, _ := regexp.Match(`[^\d]`, []byte("as132"))

    fmt.Println(matchDigit)         //输出true

    //go语言正则表达式判断是否含有为IP地址

    ip := "10.32.12.01"

    pattern := "[\\d]+\\.[\\d]+\\.[\\d]+\\.[\\d]+"

    matchIp, _ := regexp.MatchString(pattern, ip)

    fmt.Println(matchIp)          //输出true

    //go语言正则表达式判断是否包含某些字段

    id := "id=123;dfg"

    reg := regexp.MustCompile("id=[\\d]+")

    MEId := reg.FindString(id)

    fmt.Println(MEId)         //输出id=123

    //go语言正则表达式找出字符串中包含的所有的某些字段

    ss:=`

    tt=4.9911%,UE1,Sym1

    tt=3.6543%,UE1,Sym2

    tt=3.6133%,UE1,Sym3

    tt=3.263%,UE1,Sym4

    tt=3.3032%,UE1,Sym5

    tt=3.597%,UE1,Sym6

    tt=4.0367%,UE1,Sym7

    tt=3.2444%,UE1,Sym8

    tt=3.5291%,UE1,Sym9

    tt=3.4419%,UE1,Sym10

    tt=3.1114%,UE1,Sym11

    tt=3.5851%,UE1,Sym12

    `

    reg := regexp.MustCompile("tt=[\\d.\\d]+")

    tt := reg.FindAllString(ss, -1)//填写-1，就可以全部找出来

    fmt.Println(tt)//打印结果[tt=4.9911 tt=3.6543 tt=3.6133 tt=3.263 tt=3.3032 tt=3.597 tt=4.0367 tt=3.2444 tt=3.5291 tt=3.4419 tt=3.1114 tt=3.5851 tt=3.6432]

    //提取字符串中特殊的子字符串

    s1:="<span class="title">肖申克的救赎</span>"

    reg := regexp.MustCompile(`<span class="title">(.*?)</span>`)

    items := reg.FindAllStringSubmatch(s1, -1)

    fmt.Println(items[0][1])//肖申克的救赎

}

知识点 正则

标签：detail   def   mod   函数   nan   Once   import   stderr   NPU   

原文地址：https://www.cnblogs.com/chu-12345/p/11378806.html