本篇文章给大家谈谈Mysql语法、特殊符号及正则表达式的使用详解，以及mysql语法,特殊符号及正则表达式的使用详解的知识点，同时本文还将给你拓展day17特殊符号与正则表达式、Go语言正则表达式的使
本篇文章给大家谈谈Mysql语法、特殊符号及正则表达式的使用详解，以及mysql语法,特殊符号及正则表达式的使用详解的知识点，同时本文还将给你拓展day 17 特殊符号与正则表达式、Go语言正则表达式的使用详解、grep命令及正则表达式的使用和介绍、iOS 正则表达式去除特殊符号等相关知识，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：- Mysql语法、特殊符号及正则表达式的使用详解（mysql语法,特殊符号及正则表达式的使用详解）
- day 17 特殊符号与正则表达式
- Go语言正则表达式的使用详解
- grep命令及正则表达式的使用和介绍
- iOS 正则表达式去除特殊符号
Mysql语法、特殊符号及正则表达式的使用详解（mysql语法,特殊符号及正则表达式的使用详解）
MysqL常用显示命令
1、显示当前数据库服务器中的数据库列表：
MysqL> SHOW DATABASES;
注意：MysqL库里面有MysqL的系统信息，我们改密码和新增用户，实际上就是用这个库进行操作。
2、进入数据库：
MysqL> USE 库名；
2、显示数据库中的数据表：
MysqL> SHOW TABLES;
3、显示数据表的结构：
MysqL> DESCRIBE 表名;
4、建立数据库：
MysqL> CREATE DATABASE 库名;
5、建立数据表：
MysqL> USE 库名; MysqL> CREATE TABLE 表名 (字段名 VARCHAR(20),字段名 CHAR(1));
6、删除数据库：
MysqL> DROP DATABASE 库名;
7、删除多个数据表：
MysqL> DROP TABLE 表名,表名；
8、将表中记录清空：
MysqL> DELETE FROM 表名;
9、显示表中的记录：
MysqL> SELECT * FROM 表名;
10、往表中插入新的字段：
MysqL> alter tabel 表名 add column 字段名 varchar(10);
10、往表中插入记录：
MysqL> INSERT INTO 表名 VALUES (”hyq”,”M”);
语法：
INSERT [INTO] tbl_name [(col_name,...)] VALUES (PRession,...),… INSERT [INTO] tbl_name SET col_name=expression,...
Note:在django中插入时要多加一个id字段:INSERT INTO 表名 VALUES (1,'aaa','bbb');
11、修改字段类型：
MysqL> alter table 表名 modify column 字段名 varchar(12);
11、更新表中数据：
MysqL-> UPDATE 表名 SET 字段名1='a',字段名2='b' WHERE 字段名3='c';
12、用文本方式将数据装入数据表中：
MysqL> LOAD DATA LOCAL INFILE “D:/MysqL.txt” INTO TABLE 表名;
13、导入.sql文件命令：
MysqL> USE 数据库名; MysqL> SOURCE d:/MysqL.sql;
14、命令行修改root密码：
MysqL> UPDATE MysqL.user SET password=PASSWORD('新密码') WHERE User='root';
MysqL> FLUSH PRIVILEGES;
15、显示use的数据库名：
MysqL> SELECT DATABASE();
16、显示当前的user：
MysqL> SELECT USER();
Note:
1. 操作都是在MysqL的提示符下进行的，而且每个命令以分号结束。
2. sql语句对大小写不敏感
MysqL索引使用规则
用于索引的最好的备选数据列是那些出现在WHERE子句、join子句、ORDER BY或GROUP BY子句中的列。
什么情况下应不建或少建索引？
a. 表记录太少
b. 经常插入、删除、修改的表
c. 经常和主字段一块查询但主字段索引值比较多的表字段
复合索引的创建：
比如有一条语句是这样的：
select * from users where area='beijing' and age=22;
如果我们是在area和age上分别创建单个索引的话，由于mySQL查询每次只能使用一个索引，所以虽然这样已经相对不做索引时全表扫描提高了很多效率，但是如果在area、age两列上创建复合索引的话将带来更高的效率。
如果我们创建了(area,age,salary)的复合索引，那么其实相当于创建了(area,salary)、(area,age)、(area)三个索引，这被称为最佳左前缀
复合索引的建立以及最左前缀原则：
如果你需要索引一个字符串数据列，那么最好在任何适当的情况下都应该指定前缀长度。你可以索引CHAR、VARCHAR、BINARY、VARBINARY、BLOB和TEXT数据列的前缀。
假设你在表的state、city和zip数据列上建立了复合索引。索引中的数据行按照state/city/zip次序排列，因此它们也会自动地按照state/city/zip次序排列。这意味着，即使你在查询中只指定了state值，或者指定state和city值，MysqL也可以使用这个索引。因此，这个索引可以被用于搜索如下所示的数据列组合：（state,city,zip）（state,city）（state）
索引不会包含有NULL值的列
只要列中包含有NULL值都将不会被包含在索引中，复合索引中只要有一列含有NULL值，那么这一列对于此复合索引就是无效的。所以我们在数据库设计时不要让字段的默认值为NULL。
mySQL查询只使用一个索引.
因此如果where子句中已经使用了索引的话，那么order by中的列是不会使用索引的。因此数据库默认排序可以符合要求的情况下不要使用排序操作；尽量不要包含多个列的排序，如果需要最好给这些列创建复合索引。
一般情况下不鼓励使用like操作.
如果非使用不可，如何使用也是一个问题。like “%a%” 不会使用索引而like “aaa%”可以使用索引。
不要在列上进行运算，select * from users where YEAR(adddate)
不使用NOT IN操作：
NOT IN操作不会使用索引将进行全表扫描。NOT IN可以用NOT EXISTS代替.
MysqL特殊符号
% (百分号) :
代表任意长度（长度可以为0）的字符串 例：a%b表示以a开头，以b结尾的任意长度的字符串。如acb，addgb，ab等都满足该匹配串 _ (下横线):
代表任意单个字符 例：a_b表示以a开头，以b结尾的长度为3的任意字符串。如acb，afb等都满足该匹配串
字符串引号:
在sql中，表示字符串引号强烈建议使用单引号（'）。虽然MysqL(和PHP搭配之最佳组合)也可以使用双引号（"），但是为了和sql server(WINDOWS平台上强大的数据库平台)和Oracle(大型网站数据库平台)统一，建议都使用单引号。如果在字符串中也有单引号出现的话，在sql中需要将其替换为两个单引号（''），DBMS会将其解释为一个单引号的。
sql的换行符和字符串连接符:
在MysqL(和PHP搭配之最佳组合)、sql server(WINDOWS平台上强大的数据库平台)和Oracle(大型网站数据库平台)中均有不同，下面以列表显示。 MysqL(和PHP搭配之最佳组合)sql server(WINDOWS平台上强大的数据库平台)Oracle(大型网站数据库平台)换行符\n或\r\n或CHAR(10)CHAR(13)CHR(10)字符串连接符CONCAT()+||或CONCAT()
宏变量标识符（&） :
在Oracle(大型网站数据库平台)里有特殊含义，是一个宏变量标识符，在sqlPLUS里执行SELECT 'AAA BBB' AS STR FROM DUAL,它会提示你输入宏变量值，所有如果sql里有（&），建议用单引号括起来，如SELECT 'AAA'||'&'||'nbsp;BBB' AS STR FROM DUAL它就不会提示了。
MysqL正则表达式
replace、regexp的用法
0 Comments | This entry was posted on Apr 08 2010
MysqL replace用法
1.replace into
replace into table (id,name) values('1′,'aa'),('2′,'bb')
此语句的作用是向表table中插入两条记录。如果主键id为1或2不存在
就相当于
insert into table (id,'bb')
如果存在相同的值则不会插入数据
2.replace(object,search,replace)
把object中出现search的全部替换为replace
select replace('www.163.com','w','Ww')―>WwWwWw.163.com
例：把表table中的name字段中的aa替换为bb
update table set name=replace(name,'aa','bb')
――――――――――――――――――――――――――C
扩展正则表达式
由MysqL提供的模式匹配的其它类型是使用扩展正则表达式。当你对这类模式进行匹配测试时，使用REGEXP和NOT REGEXP操作符(或RLIKE和NOT RLIKE，它们是同义词)。
扩展正则表达式的一些字符是：
・ ‘.'匹配任何单个的字符。
・ 字符类“[...]”匹配在方括号内的任何字符。例如，“[abc]”匹配“a”、“b”或“c”。为了命名字符的范围，使用一个“-”。“[a-z]”匹配任何字母，而“[0-9]”匹配任何数字。
・ “ * ”匹配零个或多个在它前面的字符。例如，“x*”匹配任何数量的“x”字符，“[0-9]*”匹配任何数量的数字，而“.*”匹配任何数量的任何字符。
如果REGEXP模式与被测试值的任何地方匹配，模式就匹配(这不同于LIKE模式匹配，只有与整个值匹配，模式才匹配)。
为了定位一个模式以便它必须匹配被测试值的开始或结尾，在模式开始处使用“^”或在模式的结尾用“$”。
为了说明扩展正则表达式如何工作，下面使用REGEXP重写上面所示的LIKE查询：
为了找出以“b”开头的名字，使用“^”匹配名字的开始：
MysqL> SELECT * FROM pet WHERE name REGEXP ‘^b';
[MysqL 正则表达式]
[删除MysqL数据库中所有不以JP开头的表]
总结
以上所述是小编给大家介绍的MysqL语法、特殊符号及正则表达式的使用，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对编程小技巧网站的支持！
day 17 特殊符号与正则表达式
磁盘空间不足系列：
原因 排查过程 解决
1.block du –h; du –sh /data/* 确认之后删除
2.block（硬链接数为0，进程调用数不为0） lsof|grep delete 重启对应的服务
3.inode df -i；找出系统中大于1M的目录 删除大量小文件
时间：
mtime modify time 修改时间
ctime change time 文件属性变化时间
atime access time 访问时间（cat）
第1章 正则表达式
1.1 引号系列
1. 单引号
所见即所得，单引号里面的内容会原封不动的输出
2. 双引号
与单引号类似，里面的特殊符号会被解析
3. 反引号
优先执行命令
4. 不加引号
与双引号类似，可以使用{}
1.2 特殊符号
1.2.1 重定向系列
>标准输出重定向（先把文件内容清空追加）
>>标准输出 追加重定向
2>标准错误输出重定向
2>>错误追加重定向（错误信息被追加到文件内容）
< 标准输入重定向 （xargs tr）
<< 标准输入追加重定向（与cat配合追加多行内容）
Cat >>oldboy.txt <<EOF
Oldboyedu.com
EOF
2>&1 把错误的内容和正确的内容纪录到文件中
echo oldboy >/tmp/log 2>&1
1.2.2 位置系列
~ 当前用户的家目录
. 当前目录
.. 上一级目录
cd – 返回你上次的所在位置
su -
扩展：
在启动服务器ntpd服务时遇到一个问题
使用 su root 切换到root用户后，不可以使用service命令；
使用 su - 后，就可以使用service命令了。
原因：
su命令和su -命令区别就是：
su只是切换了root身份，但Shell环境仍然是普通用户的Shell；而su -连用户和Shell环境一起切换成root身份了。只有切换了Shell环境才不会出现PATH环境变量错误，报command not found的错误。
su切换成root用户以后，pwd一下，发现工作目录仍然是普通用户的工作目录；而用su -命令切换以后，工作目录变成root的工作目录了。
用echo $PATH命令看一下su和su - 后的环境变量已经变了。
以此类推，要从当前用户切换到其它用户也一样，应该使用su -命令。
1.2.3 判断系列
&& 并且
（前一个命令执行成功之后再执行后面的命令）
Ifdown eth0 && ifup eth0
|| (前一个命令执行失败之后再执行后面的命令)
ifdown eth0 #关闭eth0
ifup eth0 #启动eth0
1.2.4 无分类系列
# 注释 解释说明
root用户的命令提示符
$:
$ echo $LANG $PATH $PS1
awk取出某一列
$1 $2 (取出第一列 第二列)
$0 一行
$NF 最后一列
普通用户的命令提示符
！：
Vi /vim强制
：q!
：wq!
Find/awk取反
!ls
找出最近一次以ls开头的命令并运行
History |grep “ls”
!!
运行上一个的命令
| 管道符号
；在同一行中分割多条命令
1.3 通配符
1.3.1 *
匹配任何字符串/文本，包括空字符串
*代表任意字符（0个或多个）
ls *.txt
find –name “*.txt”
[[email protected] ~]# find -type f -name "stu*"
(找出以stu开头的文件)
[[email protected] ~]# find -type f -name "*.txt" （找出以.txt 结尾的文件）
./2.txt
./6.txt
./4.txt
./etc/pki/nssdb/pkcs11.txt
./7.txt
./3.txt
./oldboy.txt
./1.txt
./5.txt
[[email protected] ~]# find / -type f -name "stu*.txt" （找出以stu开头，并且以.txt结尾的文档）
[[email protected] ~]# find / -type f -name "*oldboy*" (找出文件名中包含（只要有就行）oldboy的文件)
过滤出所有含有ifconfig的文件
[[email protected] ~]# find / -type f |grep ifconfig
/usr/sbin/pifconfig
/usr/share/man/de/man8/ifconfig.8.gz
/usr/share/man/pt/man8/ifconfig.8.gz
/usr/share/man/man8/pifconfig.8.gz
/usr/share/man/man8/ifconfig.8.gz
/usr/share/man/fr/man8/ifconfig.8.gz
/sbin/ifconfig
1.3.2 {} 生成序列
生成stu 01----stu05
[[email protected] ~]# echo stu{01..5}
stu01 stu02 stu03 stu04 stu05
显示单个：
（用逗号隔开）
[[email protected] ~]# echo {1,5,100}
1 5 100
从1开始到10结束，每次加2
[[email protected] ~]# echo stu{01..10..2}
stu01 stu03 stu05 stu07 stu09
1.3.3 #通过 {} 进行备份
[[email protected] ~]# cp oldboy.txt{,.bak}
[[email protected] ~]# echo oldboy.txt{,.bak} （对上一条cp进行反向推导，输入这条命令）
oldboy.txt oldboy.txt.bak （会输出oldboy.txt和oldboy.txt.bak）
[[email protected] ~]# echo A{,C} (对上一条再进行简化解释，输入这一条)
A AC （会输出A和AC）
[[email protected] ~]# echo A{B,C} （花括号外的会和括号内的分别组合）
AB AC
小结：
1.特殊符号
2.* {} 通配符 查找文件 大多数命令都可以使用
ls *.txt
第2章 正则表达式配合三剑客进行过滤
2.1 给grep egrep配置别名并永久生效
1.[[email protected] ~]# vim /etc/profile （编辑/etc/profile）
2.输入 alias grep='grep --color'
alias egrep='egrep --color'
3. :wq (保存并退出)
4.永久生效
[[email protected] ~]#source /etc/profile
5. 进行验证
[[email protected] ~]# grep 3306 /etc/services
2.2 基础正则表达式
2.2.1 环境准备：
I am oldboy teacher!
I teach linux.
I like badminton ball,billiard ball and chinese chess!
my blog is http://oldboy.blog.51cto.com
our size is http://blog.oldboyedu.com
my qq is 49000448
not 4900000448.
my god,i am not oldbey,but OLDBOY!
2.2.2 查看环境
[[email protected] /oldboy]# cat oldboy.txt
I am oldboy teacher!
I teach linux.
I like badminton ball,but OLDBOY!
2.2.3 过滤出oldboy.txt中的oldboy
[[email protected] /oldboy]# grep oldboy oldboy.txt
I am oldboy teacher!
my blog is http://oldboy.blog.51cto.com
our size is http://blog.oldboyedu.com
[[email protected] /oldboy]#
2.3 第1个符号 ^
2.3.1 以....开头的行 ^
实例2-1 过滤出oldboy.txt中以m开头的行
[[email protected] /oldboy]# grep '^m' oldboy.txt
my blog is http://oldboy.blog.51cto.com
my qq is 49000448
my god,but OLDBOY!
2.3.2 第二个符号 $ 以…结尾
过滤出以m结尾的行
[[email protected] oldboy]# grep “m$” oldboy.txt
（我们发现有m结尾的行，但是使用egrep无法过滤）
cat -A 显示文件中所有符号 每行结尾都会有个$ 可以看出$和m之间有个空格，所以，是以空格结尾。
过滤出以(空格)$结尾的行
[[email protected] /oldboy]# grep ' $' oldboy.txt
my blog is http://oldboy.blog.51cto.com
our size is http://blog.oldboyedu.com
2.3.3 第三个符号 ^$ 空行 什么符号都没有
过滤空行，由于查看不明显 所以使用grep –n 显示行号
2.3.4 第4个符号 .
任意一个字符 不会匹配空行
[[email protected] /oldboy]# grep '.' oldboy.txt
#grep 命令每一次找出了什么 grep命令执行过程
[[email protected] /oldboy]# grep -o '.' oldboy.txt
2.3.5 第5个符号 \
显示文件中以.(点)结尾的行
[[email protected] /oldboy]# grep '\.$' oldboy.txt
I teach linux.
not 4900000448.
把文件中所有的回车换行替换为tab
[[email protected] /oldboy]# tr '\n' '\t' <oldboy.txt
I am oldboy teacher! I teach linux. I like badminton ball,billiard ball and chinese chess! my blog is http://oldboy.blog.51cto.com our size is http://blog.oldboyedu.com my qq is 49000448 not 4900000448. my god,but OLDBOY!
2.3.6 正则表达式-坑1-grep '0*' 会把文件内容都显示出来
#0* 0次 没有 grep '' 会把文件内容都显示出来
# 0次以上 0 00000000000
[[email protected] /oldboy]# grep '.*' oldboy.txt
I am oldboy teacher!
I teach linux.
I like badminton ball,billiard ball and chinese chess!
my blog is http://oldboy.blog.51cto.com
our size is http://blog.oldboyedu.com
my qq is 49000448
not 4900000448.
my god,but OLDBOY!
2.3.7 正则表达式的贪婪性
替你寻找的文字符号 有多少吃多少 有多少匹配多少
正则中表示 连续出现或所有的时候
[[email protected] /oldboy]# grep '^.*o' oldboy.txt
I am oldboy teacher!
I like badminton ball,billiard ball and chinese chess!
my blog is http://oldboy.blog.51cto.com
our size is http://blog.oldboyedu.com
not 4900000448.
my god,but OLDBOY!
grep '[a-z]' oldboy.txt
grep '[A-Z]' oldboy.txt
@H_993_1301@
grep '[0-9]' oldboy.txt
grep '[a-zA-Z]' oldboy.txt
grep '[a-Z]' oldboy.txt
grep -i '[a-z]' oldboy.txt
-i 不区分大小写 ignore case
总结：
1.正则表达式与通配符区别
2.基础正则表达式
3.linux三种时间
Go语言正则表达式的使用详解
正则表达式是一种进行模式匹配和文本操纵的功能强大的工具。正则表达式灵活、易用，按照它的语法规则，随需构造出的匹配模式就能够从原始文本中筛选出几乎任何你想要得到的字符组合。
准则
- 默认是最短匹配，只要字符串满足条件就返回。
- 如果没有匹配到，都是返回为nil。
- 如果需要做最长匹配，调用Longest()函数。
- 正则表达式功能：匹配(macth)，查找(find)和替换(replace)。
- 存在长度选择的函数，传入<0的数字表示匹配全部。
使用regexp调用
Match，MatchReader和 MatchString
// 判断b中是够包含pattern能够组成的任意字符串 func Match(pattern string, b []byte) (matched bool, err error) // 判断reader r中返回的字符串是否包含pattern能够组成的任意字符串 func MatchReader(pattern string, r io.RuneReader) (matched bool, err error) // 判断字符串s中是否包含pattern能够组成的任意字符串 func MatchString(pattern string, s string) (matched bool, err error)
Compile 和 MushCompile
func Compile(expr string) (*Regexp, error)
func MustCompile(str string) *Regexp
Compile ：返回 Regexp 对象，方便调用指针函数。
MustCompile ：同Compile，解析表达式失败，会panic。
在匹配文本时，该正则表达式会尽可能早的开始匹配，并且在匹配过程中选择回溯搜索到的第一个匹配结果。这种模式被称为 leftmost-first ，另外一般情况下使用 MustCompile 即可。
使用regexp.Regexp对象来调用
Find 和 FindAll
- func (re *Regexp) Find(b []byte) []byte
- func (re *Regexp) FindAll(b []byte, n int) [][]byte
Find返回保管正则表达式re在b中的最左侧的一个匹配结果的[]byte切片。如果没有匹配到，会返回nil，最多匹配一个。
re := regexp.MustCompile(`foo.?`)
fmt.Printf("%q\n", re.Find([]byte(`seafood fool`)))
re := regexp.MustCompile(`foo.?`)
fmt.Printf("%q\n", re.FindAll([]byte(`seafood fool`), -1))
FindAll 功能与 Find 一样，只是返回全部满足条件的数据。
FindString 和 FindAllString
- func (re *Regexp) FindString(s string) string
- func (re *Regexp) FindAllString(s string, n int) []string
与 Find 和 FindAll 一样，只是针对字符串string操作。
FindIndex 和 FindAllIndex
- func (re *Regexp) FindIndex(b []byte) (loc []int)
- func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
FindIndex ， 返回 b 中满足匹配字符串部分的起始位置，同样是**“leftmost-first”**原则，loc包含起止位置。如果没有找到，直接返回 nil 。
FindAllIndex ，功能和 FindIndex 保持一致，只是匹配多个， n 决定了匹配的位置。
FindStringIndex 和 FindAllStringIndex
- func (re *Regexp) FindStringIndex(s string) (loc []int)
- func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
与 FindIndex 和 FindAllIndex 使用方式类似，只是针对的是字符串string。
FindStringSubmatch 和 FindAllStringSubmatch
- func (re *Regexp) FindStringSubmatch(s string) []string
FindStringSubmatch ：采用左匹配原则，最多匹配一个，如果没有的话，返回 nil 。对于返回的 []string ,分别标示匹配的字符串，子串。
re := regexp.MustCompile(`a(x*)b(y|z)c`)
fmt.Printf("%q\n", re.FindStringSubmatch("-axxxbyc-"))
fmt.Printf("%q\n", re.FindStringSubmatch("-abzc-"))
输出结果：
["axxxbyc" "xxx" "y"]
["abzc" "" "z"]
- func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
和 FindStringSubmatch 使用类似，只是能顾选择匹配的长度， -1 表示匹配到末尾。
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))
输出结果：
[["ab" ""]]
[["axxb" "xx"]]
[["ab" ""] ["axb" "x"]]
[["axxb" "xx"] ["ab" ""]]
FindSubmatchIndex 和 FindAllSubmatchIndex
- func (re *Regexp) FindSubmatchIndex(b []byte) []int
- func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int 计算子串在源串中的位置，已经存在 (x*) 等返回结果处理，如果没有返回 nil 。
另外， index 返回为 左闭右开 的模式，示例中的 2,2 表示空字符串的意思。 并且，不会存在重合匹配的，比如说"-axxb-ab-"去匹配 a(x*)b ，不会存在第一个 a 和最后一个 b 结合的情况，如果使用 Longest 就会匹配最长的。
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))
输出结果：
[[1 3 2 2]] // 2 2 表示为空
[[1 5 2 4]]
[[1 3 2 2] [4 7 5 6]]
[[1 5 2 4] [6 8 7 7]]
[]
FindStringSubmatchIndex 和 FindAllStringSubmatchIndex
func (re *Regexp) FindStringSubmatchIndex(s string) []int
func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
和 FindSubmatchIndex ， FindAllSubmatchIndex 保持一致。
Longest
func (re *Regexp) Longest() 获取最长匹配的满足条件的内容。
re := regexp.MustCompile(`a(|b)`)
fmt.Println(re.FindString("ab"))
re.Longest()
fmt.Println(re.FindString("ab"))
输出结果：
a
ab
下面这种情况不会最长匹配。
re := regexp.MustCompile(`a(x*)b`)
re.Longest()
fmt.Println(re.FindString("-axxb-ab-")) // axxb，不会存在第一个a和最后一个b组合的过程。
Match，MatchString和MatchReader
- func (re *Regexp) Match(b []byte) bool
- func (re *Regexp) MatchString(s string) bool
- func (re *Regexp) MatchReader(r io.RuneReader) bool
判断 b ， s 和 r 返回的数据是否满足正则表达式，返回 true 或者 false 。
NumSubexp
- func (re *Regexp) NumSubexp() int
返回分组的数量。
re0 := regexp.MustCompile(`a.`)
fmt.Printf("%d\n", re0.NumSubexp())
re := regexp.MustCompile(`(.*)((a)b)(.*)a`)
fmt.Println(re.NumSubexp())
输出结果：
0
4
ReplaceAll 和 ReplaceAllString
func (re *Regexp) ReplaceAll(src, repl []byte) []byte
func (re *Regexp) ReplaceAllString(src, repl string) string
ReplaceAllString 与 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"))) // $1表示匹配的第一个子串，这是ab的中间无字符串，所以$1为空，然后使用空去替换满足正则表达式的部分。
fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("$1W"))) // "$1W"等价与"$(1W)"，值为空，将满足条件的部分完全替换为空。
fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("${1}W"))) // ${1}匹配(x*)，保留。输出-W-xxW-
输出结果：
-T-T-
--xx-
---
-W-xxW-
s := "Hello World, 123 Go!"
//定义一个正则表达式reg，匹配Hello或者Go
reg := regexp.MustCompile(`(Hell|G)o`)
s2 := "2019-12-01,test"
//定义一个正则表达式reg2,匹配 YYYY-MM-DD 的日期格式
reg2 := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
//最简单的情况，用“T替换”"-ab-axxb-"中符合正则"a(x*)b"的部分
reg3 := regexp.MustCompile("a(x*)b")
fmt.Println(re.ReplaceAllString("-ab-axxb-", "T")) // -T-T-
//${1}匹配"Hello World, 123 Go!"中符合正则`(Hell|G)`的部分并保留，去掉"Hello"与"Go"中的''o''并用"ddd"追加
rep1 := "${1}ddd"
fmt.Printf("%q\n", reg.ReplaceAllString(s, rep1)) // Hellddd World, 123 Gddd!
//首先，"2019-12-01,test"中符合正则表达式`(\d{4})-(\d{2})-(\d{2})`的部分是"2019-12-01",将该部分匹配''(\d{4})''的''2019''保留，去掉剩余部分
rep2 := "${1}"
fmt.Printf("%q\n", reg2.ReplaceAllString(s2,rep2)) // 2019,test
//首先，"2019-12-01,test"中符合正则表达式`(\d{4})-(\d{2})-(\d{2})`的部分是"2019-12-01",将该部分匹配''(\d{2})''的''12''保留，去掉剩余部分
rep3 := "${2}"
fmt.Printf("%q\n", reg2.ReplaceAllString(s2,rep3)) // 12,test
//首先，"2019-12-01,test"中符合正则表达式`(\d{4})-(\d{2})-(\d{2})`的部分是"2019-12-01",将该部分匹配''(\d{2})''的''01''保留，去掉剩余部分,并追加"13:30:12"
rep4 := "${3}:13:30:12"
fmt.Printf("%q\n", reg2.ReplaceAllString(s2,rep4)) // 01:13:30:12,test
}
ReplaceAllFunc 和 ReplaceAllStringFunc
- func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
- func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
将匹配出来满足条件的 []byte 作为参数传入函数中。
re := regexp.MustCompile(`[^aeiou]`)
fmt.Println(re.ReplaceAllStringFunc("seafood fool", strings.ToUpper))
两者使用方式类似。
ReplaceAllLiteral 和 ReplaceAllLiteralString
- func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte
- func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
匹配字面常量，不转换。
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}"))
输出结果：
-T-T-
-$1-$1-
-${1}-${1}-
关于 $1 说明：
Expand 和 ExpandString
- func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
- func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
Expand返回新生成的将template添加到dst后面的切片。在添加时，Expand会将template中的变量替换为从src匹配的结果。match应该是被FindSubmatchIndex返回的匹配结果起止位置索引。（通常就是匹配src，除非你要将匹配得到的位置用于另一个[]byte）
在template参数里，一个变量表示为格式如： $name 或 ${name} 的字符串，其中name是长度>0的字母、数字和下划线的序列。一个单纯的数字字符名如$1会作为捕获分组的数字索引；其他的名字对应(?P...)语法产生的命名捕获分组的名字。超出范围的数字索引、索引对应的分组未匹配到文本、正则表达式中未出现的分组名，都会被替换为空切片。
$name格式的变量名，name会尽可能取最长序列： $1x 等价于 ${1x} 而非 ${1}x ， $10 等价于 ${10} 而非 ${1}0 。因此 $name 适用在后跟空格/换行等字符的情况， ${name} 适用所有情况。
如果要在输出中插入一个字面值 ''$'' ，在template里可以使用 $$ 。
其他示例
解析网址
flysnowRegexp := regexp.MustCompile(`^http://www.flysnow.org/([\d]{4})/([\d]{2})/([\d]{2})/([\w-]+).html$`)
params := flysnowRegexp.FindStringSubmatch("http://www.flysnow.org/2018/01/20/golang-goquery-examples-selector.html")
// 返回[]string{}数据类型
for _, param := range params {
fmt.Println(param)
}
输出结果:
http://www.flysnow.org/2018/01/20/golang-goquery-examples-selector.html
2018
01
20
golang-goquery-examples-selector
总结
到此这篇关于Go语言正则表达式的使用详解的文章就介绍到这了,更多相关Go正则表达式使用内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
- Go语言正则表达式用法实例小结【查找、匹配、替换等】
- Django框架教程之正则表达式URL误区详解
- 解决新django中的path不能使用正则表达式的问题
- 在Django中URL正则表达式匹配的方法
- 浅析golang 正则表达式
- Golang爬虫及正则表达式的实现示例
- Go 语言入门学习之正则表达式
grep命令及正则表达式的使用和介绍
grep是Linux系统中的一个文本流处理工具（单位为行），用于在文件中搜寻所需要的内容。grep、awk、sed被称为文本处理三剑客。
接下来我们看一下grep的使用格式及常用选项：
grep[options]PATTERN[FILE...] -v#过滤匹配到的行 -o#仅显示匹配到的字符 -i#匹配字符时候忽略大小写 -n#显示行号 -An#显示匹配到的行及上面的n行 -Bn#显示匹配到的行及下面的n行 -Cn#显示匹配到的行及上下各n行 -E#扩展的正则表达式；=egep --color=auto：匹配到的字符串显示颜色
了解了grep的使用格式和常用选项后，我们就可以是试试了：
1.复制/etc/passwd到/tmp目录； [root@localhosttmp]#cp/etc/passwd/tmp/ 2.找到包含root字符的行并将匹配到的字符串显示颜色； [root@localhosttmp]#grep--color=auto"root"/tmp/passwd root:x:0:0:root:/root:/bin/bash operator:x:11:0:operator:/root:/sbin/nologin [root@localhosttmp]# 3.找到除了bash字符的行并显示行号； [root@localhosttmp]#grep-vn"bash"/tmp/passwd 2:bin:x:1:1:bin:/bin:/sbin/nologin 3:daemon:x:2:2:daemon:/sbin:/sbin/nologin .....还有很多，以你的为准..... [root@localhosttmp]# 4.找到包含ntp字符的行及其上面的2行； [root@localhosttmp]#grep-B2"ntp"/tmp/passwd vcsa:x:69:69:virtualconsolememoryowner:/dev:/sbin/nologin pcap:x:77:77::/var/arpwatch:/sbin/nologin ntp:x:38:38::/etc/ntp:/sbin/nologin [root@localhosttmp]# 5.找到xfs字符的行及其上下的各1行； [root@localhosttmp]#grep-C1"xfs"/tmp/passwd nfsnobody:x:65534:65534:AnonymousNFSUser:/var/lib/nfs:/sbin/nologin xfs:x:43:43:XFontServer:/etc/X11/fs:/sbin/nologin haldaemon:x:68:68:HALdaemon:/:/sbin/nologin
好，如果没有问题的话我们继续。
grep除了能使用以上的基本选项外，还可以使用正则表达式进行更加高级的模式匹配。这个正则表达式很简单，比grep还要简单，只需要背背就能记住了！
正则表达式是由元字符组成的一种模式，可以完成更高级、更复杂的模式匹配。正则表达式分为基本的正则表达式和扩展的正则表达式，正则表达式是一个必须掌握的玩意儿，如果不会那你该脸红咯。
正则表达式的元字符并不代表其字符意义，而是另有其他意义，我们看一下都有哪些，以及这些元字符的解释：
一、基本的正则表达式
根据功能的不同，基本正则表达式的元字符大概可以分为四个个类型：
1.字符匹配：
.#匹配任意单个字符
[]#匹配集合内的任意单个字符
[0-9]：代表0-9
[^]#匹配集合外的任意单个字符
2.次数匹配
*#匹配前面字符任意次
\?#匹配前面字符0次或1次
.*#匹配任意字符任意次
\{m,n\}#匹配前面字符最少m次，最多n次
\{m,\}#匹配前面字符最少m次
\{0,n}#匹配前面字符最多n次
3.位置铆钉
^#锚定行首
$#锚定行尾
^$#锚定空白行
\<#锚定词首
\>#锚定词尾
\b#锚定词首和词尾例如：\b单词\b
4.分组及引用
\(\)#扩住字符并给后面的引用
\1#引用第一个括号中的内容
\2#引用第二个括号中的内容
二、扩展的正则表达式
#扩展的正则表达式只比正则表达式多了"{m}、+、|"而且有些地方不需要\转义
1.字符匹配：
.#匹配任意单个字符
[]#匹配集合内的任意单个字符
[^]#匹配集合外的任意单个字符
2.次数匹配
*#匹配前面字符任意次
?#匹配前面字符0次或1次
.*#匹配任意字符任意次
+#匹配前面字符至少一次
{m,n}#匹配前面字符最少m次，最多n次
{0,n}#匹配前面字符最多n次
{m,}#匹配前面字符最少m次
{m}#匹配前面字符m次
3.位置铆钉
^#锚定行首
$#锚定行尾
^$#锚定空白行
\<#锚定词首
\>#锚定词尾
\b#锚定词首和词尾例如：\b单词\b
4.分组及引用
()#扩住字符并给后面的引用
\1#引用第一个括号中的内容
\2#引用第二个括号中的内容
|#代表或者的意思，例如a|b代表a或者b
需要说明一下关于[]的集合： []内可以是任意字符，如果是连续的，可以用-连接，例如0到9就是[0-9]、A到Z就是[a-z]，匹配的时候只匹配其内部包含的任意单个字符。除了可以自己定义内部的匹配字符外，bash事前已经提供了一些字符集合： [:upper:]#匹配任意单个大写字母； [:lower:]#匹配任意单个小写字母； [:alpha:]#匹配任意单个大小写字母； [:digit:]#匹配任意单个数字； [:space:]#匹配任意单个空格 [:punct:]#匹配任意单个标点符号 #以上的字符集合需要放到[]内，如[[:upper:]]
稍后添加使用实例。
iOS 正则表达式去除特殊符号
1、众所周知，正则表达式如果利用得当的话，其实用性还是相当强大的 ，基本上目前所有的预研都是支持正则表达式的 ，无非是对语法的支持不同。
2、在实际应用中 ，我们可能需要去截取遇到第一个特殊字符之前的文字 ，此时就需要用到正则表达式 ，毕竟特殊符号那么多 ，如果真有人用多个if去操作的话，只能说刷新了我的认知！
话不多说，附上代码
- (NSString *)getNewSubStoreNameByRegularExpression:(NSString *)storeName{
NSError *error = NULL;
NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"[-()（）—”“$&@%^*?+?=|{}?【】？??￥!！.<>/:;：；、,，。]" options:NSRegularExpressionCaseInsensitive | NSRegularExpressionDotMatchesLineSeparators | NSRegularExpressionAnchorsMatchLines | NSRegularExpressionAllowCommentsAndWhitespace error:&error];
NSString *result = [regex stringByReplacingMatchesInString:storeName options:0 range:NSMakeRange(0, [storeName length]) withTemplate:@"pk"];
return [result componentsSeparatedByString:@"pk"].firstObject;
}
上述代码的意思是先将特殊字符换成pk，然后以pk为关键字进行分割，并取第一个元素。
细心的小伙伴会发现特殊字符中并没有包含“#”字符，“#” 作为字符包含在正则表达式中，将导致整个正则表达式验证失败，此结论还是我通过二分法找出来的。故将“#”从表达式中移除
我们今天的关于Mysql语法、特殊符号及正则表达式的使用详解和mysql语法,特殊符号及正则表达式的使用详解的分享已经告一段落，感谢您的关注，如果您想了解更多关于day 17 特殊符号与正则表达式、Go语言正则表达式的使用详解、grep命令及正则表达式的使用和介绍、iOS 正则表达式去除特殊符号的相关信息，请在本站查询。
本文标签：
