正则表达在go语言中的简单使用

最新推荐文章于 2025-01-08 00:31:30 发布

原创最新推荐文章于 2025-01-08 00:31:30 发布 · 413 阅读

1 ·

CC 4.0 BY-SA版权

萌新同时被 3 个专栏收录

45 篇文章

订阅专栏

笔记

43 篇文章

订阅专栏

学习总结

30 篇文章

订阅专栏

本文介绍了正则表达式的概念、常用规则及在Go语言中的应用。包括单字符、结合与重复等基本元素，以及如何在Go中使用正则进行匹配、查找、替换等操作。

1.1.正则表达式的含义

含义：正则表达式就是正则字符和普通字符组成字符串的规则

1.2.正则表达式的内容

内容如下：

单字符：
        .              任意字符（标志s==true时还包括换行符）
        [xyz]          字符族
        [^xyz]         反向字符族
        \d             Perl预定义字符族
        \D             反向Perl预定义字符族
        [:alpha:]      ASCII字符族
        [:^alpha:]     反向ASCII字符族
        \pN            Unicode字符族（单字符名），参见unicode包
        \PN            反向Unicode字符族（单字符名）
        \p{Greek}      Unicode字符族（完整字符名）
        \P{Greek}      反向Unicode字符族（完整字符名）
结合：
        xy             匹配x后接着匹配y
        x|y            匹配x或y（优先匹配x）
重复：
        x*             重复>=0次匹配x，越多越好（优先重复匹配x）
        x+             重复>=1次匹配x，越多越好（优先重复匹配x）
        x?             0或1次匹配x，优先1次
        x{n,m}         n到m次匹配x，越多越好（优先重复匹配x）
        x{n,}          重复>=n次匹配x，越多越好（优先重复匹配x）
        x{n}           重复n次匹配x
        x*?            重复>=0次匹配x，越少越好（优先跳出重复）
        x+?            重复>=1次匹配x，越少越好（优先跳出重复）
        x??            0或1次匹配x，优先0次
        x{n,m}?        n到m次匹配x，越少越好（优先跳出重复）
        x{n,}?         重复>=n次匹配x，越少越好（优先跳出重复）
        x{n}?          重复n次匹配x
分组:
        (re)           编号的捕获分组
        (?P<name>re)   命名并编号的捕获分组
        (?:re)         不捕获的分组
        (?flags)       设置当前所在分组的标志，不捕获也不匹配
        (?flags:re)    设置re段的标志，不捕获的分组
标志的语法为xyz（设置）、-xyz（清楚）、xy-z（设置xy，清楚z），标志如下：
        I              大小写敏感（默认关闭）
        m              ^和$在匹配文本开始和结尾之外，还可以匹配行首和行尾（默认开启）
        s              让.可以匹配\n（默认关闭）
        U              非贪婪的：交换x*和x*?、x+和x+?……的含义（默认关闭）
边界匹配：
        ^              匹配文本开始，标志m为真时，还匹配行首
        $              匹配文本结尾，标志m为真时，还匹配行尾
        \A             匹配文本开始
        \b             单词边界（一边字符属于\w，另一边为文首、文尾、行首、行尾或属于\W）
        \B             非单词边界
        \z             匹配文本结尾
转义序列：
        \a             响铃符（\007）
        \f             换纸符（\014）
        \t             水平制表符（\011）
        \n             换行符（\012）
        \r             回车符（\015）
        \v             垂直制表符（\013）
        \123           八进制表示的字符码（最多三个数字）
        \x7F           十六进制表示的字符码（必须两个数字）
        \x{10FFFF}     十六进制表示的字符码
        \*             字面值'*'
        \Q...\E        反斜线后面的字符的字面值
字符族（预定义字符族之外，方括号内部）的语法：
        x              单个字符
        A-Z            字符范围（方括号内部才可以用）
        \d             Perl字符族
        [:foo:]        ASCII字符族
        \pF            单字符名的Unicode字符族
        \p{Foo}        完整字符名的Unicode字符族
预定义字符族作为字符族的元素：
        [\d]           == \d
        [^\d]          == \D
        [\D]           == \D
        [^\D]          == \d
        [[:name:]]     == [:name:]
        [^[:name:]]    == [:^name:]
        [\p{Name}]     == \p{Name}
        [^\p{Name}]    == \P{Name}
Perl字符族：
        \d             == [0-9]
        \D             == [^0-9]
        \s             == [\t\n\f\r ]
        \S             == [^\t\n\f\r ]
        \w             == [0-9A-Za-z_]
        \W             == [^0-9A-Za-z_]
ASCII字符族：
        [:alnum:]      == [0-9A-Za-z]
        [:alpha:]      == [A-Za-z]
        [:ascii:]      == [\x00-\x7F]
        [:blank:]      == [\t ]
        [:cntrl:]      == [\x00-\x1F\x7F]
        [:digit:]      == [0-9]
        [:graph:]      == [!-~] == [A-Za-z0-9!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]
        [:lower:]      == [a-z]
        [:print:]      == [ -~] == [ [:graph:]]
        [:punct:]      == [!-/:-@[-`{-~]
        [:space:]      == [\t\n\v\f\r ]
        [:upper:]      == [A-Z]
        [:word:]       == [0-9A-Za-z_]
        [:xdigit:]     == [0-9A-Fa-f]

1.3.常用的正则规则


* `/+特殊字母` : 代表某个取值范围
* `[内容]`:代表一个字符,字符的取值范围就是内部的内容
* `{n,m}`个数,大于等于n小于等于m个
* `.`一个任意内容的字符
* `^`开始
* `$`结束
* `+`至少一个
* `*`任意个
* `?`最多一个

1.4.go语言对正则表达式的支持

go语言在regexp包中提供了对正则表达式的支持,并提供了RegExp结构体。

Regex的介绍如下：

regexp包实现了正则表达式搜索。
正则表达式采用RE2语法（除了\c、\C），和Perl、Python等语言的正则基本一致。

Regexp结构体的源码如下：

type Regexp struct {	
	// read-only after Compile
	regexpRO

	// cache of machines for running regexp
	mu      sync.Mutex
	machine []*machine
}

从源码中可以看出：里面有互斥锁,所以在并发下是安全的。

1.5Tegexp的简单使用

首先，判断字符串是否正则匹配时可以用到Tegexp：

判断方法如下：

result,_:=regexp.MatchString(`^\d\w$`,"5A")
	fmt.Println(result)

如果输出result的值为true，则该字符串正则匹配，反之不是。

如果需要更多的功能,也可以使用Regexp的方式实现,下面列举除了一些常用方法

package main

import (
	"regexp"
	"fmt"
)

func main() {
	//创建结构体变量
	r := regexp.MustCompile(`\d[a-zA-Z]`)
	//判断是否匹配
	fmt.Println(r.MatchString("5A1"))
	/*
	字符串中满足要求的片段,返回[]string
	第二个参数是[]string的长度,-1表示不限制长度
	 */
	fmt.Println(r.FindAllString("56A6B7C", -1))
	/*
	把正则表达式匹配的结果当作拆分符,拆分字符串
	n > 0 : 返回最多n个子字符串，最后一个子字符串是剩余未进行分割的部分。
	n == 0: 返回nil (zero substrings)
	n < 0 : 返回所有子字符串
	 */
	fmt.Println(r.Split("12345qwert", -1))
	//把满足正则要求内容替换成指定字符串
	fmt.Println(r.ReplaceAllString("12345qwert", "替换了"))
}

服务器端数据校验

数据校验可以有客户端数据校验和服务器端数据校验.双重保证是保证程序安全性的有效措施
客户端向服务端发送请求参数,服务器端接收到请求参数后使用正则验证,验证结果通过才能正确执行,例如注册时验证数据格式

使用正则表达式的相关内容可以制作一个网页用于判断用户注册信息，进行数据校验。

具体示例如下：

前端代码如下（html）：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
        "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <title></title>
</head>
<body>
<form action="register" method="post">
    用户名:<input type="text" name="username"/>用户名必须时6-12位,只能包含字符或数字<br/>
    <input type="submit" value="注册"/>
</form>
</body>
</html>

服务器端代码如下：

package main

import (
	"fmt"
	"net/http"
	"regexp"
)

func welcome(w http.ResponseWriter, r *http.Request) {
	t, _ := template.ParseFiles("view/index.html")
	t.Execute(w, nil)
}
func register(w http.ResponseWriter, r *http.Request) {
	{
		u := r.FormValue("username")
		r, _ := regexp.MatchString(`^[0-9a-zA-Z]{6,12}$`, u)
		if r {
			fmt.Fprintln(w, "注册成功")
		} else {
			fmt.Fprintln(w, "用户名格式不正确")
		}
	}
}
func main() {
	server := http.Server{Addr: ":8090"}
	http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
	http.HandleFunc("/", welcome)
	http.HandleFunc("/register", register)
	server.ListenAndServe()
}