Hive Sql中六种面试题型总结

一.常用函数

• explode(col): 将一列array类型或者map类型的字段，分成多列

• lateral view:

  用法：lateral view udtf(expression) tableAlias as columAlias,tableAlias产生的虚拟表，columAlias是炸开的列名
  解释：用于和explode和split等UDFT一起使用，能将一列数据拆分成多行数据，在此基础上可以对拆分后的数据进行聚合。

• CONCAT(string A/col, string B/col…)：返回输入字符串连接后的结果，支持任意个输入字符串;

• CONCAT_WS(separator, str1, str2,...)：它是一个特殊形式的 CONCAT()。第一个参数剩余参数间的分隔符。分隔符可以是与剩余参数一样的字符串。如果分隔符是 NULL，返回值也将为 NULL。这个函数会跳过分隔符参数后的任何 NULL 和空字符串。分隔符将被加到被连接的字符串之间;

• COLLECT_SET(col)：函数只接受基本数据类型，它的主要作用是将某字段的值进行去重汇总，产生 array 类型字段。

• collect_list(col)：功能类似COLLECT_SET(col)但是不会去重。

• split(str, regex)- Splits str around occurances that match regex。将str按照regex切割。返回值为一个数组。split(str, regex)[index]返回分割后数组index处的值。如split('a,b,c',',')[0]得到a

• array_contains(array arr, element): Returns if the element is in the array。判断arr 是否包含element，如果包含返回true。

• get_json_object(string json_string, string path):第一个参数填写json对象变量，第二个参数使用$表示json变量标识，然后用 .或 []读取对象或数组；

二、N日留存

1.思路分析

按天留存率计算 就是指用户在首日新增后，在接下来的后推第N天活跃情况，用后推第N天活跃的用户 / 首日新增用户。就得到后推第N天的新增用户留存率。 留存率计算案例 1月1日，新增用户200人; 次日留存：第2天，1月2日，这200人里面有100人活跃，则次日留存率为： 100 / 200 = 50% 2日留存：第3天，1月3日;这200名新增用户里面有80人活跃， 第3日新增留存率为:80/200 = 40%; 7日留存：第8天，1月8日，这200名新增用户里面有25人活跃， 第7日新增留存率为:25/200 = 12.5%;

• ① 首先查询时间内 的 每天新增用户 (t_new)

  -- 为了简化问题，假设有一张new_users表记录了每天的新增用户
  select 
  	user_id,--用户id
  	dt as new_dt --新增日期
  from new_users
  where dt >= '2020-05-01' and dt<= '2020-06-01'; //t_new
  

• ② 查询时间范围的 每天活跃用户数 (t_active)

  --为了简化问题，假设有一张active_users表记录了每天的活跃用户数
  select
  	user_id, --用户id
  	dt as active_dt, --活跃日期
  from active_users
  where dt >= '2020-05-01' and dt<= '2020-06-01'; // t_active
  

• ③ 统计当天注册 且 第N日活跃的用户 (t3)： 以①为主表 left join ②

  select
  	t_new.new_dt, --用户注册时间
  	count(distinct t_new.user_id) as cnt_01, --当日注册且当日活跃的用户(当日注册肯定活跃)
  	count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 1,t_new.user_id,null)) as cnt_02,--当日注册 且 第二日活跃的用户
  	count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 2,t_new.user_id,null)) as cnt_03,--当日注册 且 第三日活跃的用户
  	count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 4,t_new.user_id,null)) as cnt_05,--当日注册 且 第五日活跃的用户
  	count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 6,t_new.user_id,null)) as cnt_07,--当日注册 且 第七日活跃的用户
  	count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 14,t_new.user_id,null)) as cnt_15,--当日注册 且 第十五日活跃的用户
  	
  from  t_new
  left join
  t_active on t_new.user_id = t_active.user_id
  group by t_new.new_dt; // t3
  

• ④统计留存: 用后推第N天活跃的用户 / 首日新增用户 即 cnt_0n / cnt_01

  select
  	t.new_dt,--注册时间
  	t.cnt_01,--当日注册用户
  	round(cnt_02/ cnt_01 * 100, 2) as keep_02, -- 次日留存
  	round(cnt_03/ cnt_01 * 100, 2) as keep_03, -- 3日留存
  	round(cnt_05/ cnt_01 * 100, 2) as keep_05, -- 5日留存
  	round(cnt_07/ cnt_01 * 100, 2) as keep_07, --7日留存
  	round(cnt_15/ cnt_01 * 100, 2) as keep_15, -- 15日留存
  from t3
  

  完整结果：

  select
  t.new_dt,--注册时间
  t.cnt_01,--当日注册用户
  round(cnt_02/ cnt_01 * 100, 2) as keep_02, -- 次日留存
  round(cnt_03/ cnt_01 * 100, 2) as keep_03, -- 3日留存
  round(cnt_05/ cnt_01 * 100, 2) as keep_05, -- 5日留存
  round(cnt_07/ cnt_01 * 100, 2) as keep_07, --7日留存
  round(cnt_15/ cnt_01 * 100, 2) as keep_15, -- 15日留存
  
  from
  (
  	select
  		t_new.new_dt, --用户注册时间
  		count(distinct t_new.user_id) as cnt_01, --当日注册且当日活跃的用户
  		count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 1,t_new.user_id,null)) as cnt_02,--当日注册 且 第二日活跃的用户
  		count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 2,t_new.user_id,null)) as cnt_03,--当日注册 且 第三日活跃的用户
  		count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 4,t_new.user_id,null)) as cnt_05,--当日注册 且 第五日活跃的用户
  		count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 6,t_new.user_id,null)) as cnt_07,--当日注册 且 第七日活跃的用户
  		count(distinct if(datediff(t_active.active_dt,t_new.new_dt) = 14,t_new.user_id,null)) as cnt_15,--当日注册 且 第十五日活跃的用户
  		
  	from
  	( -- 新增用户
  		select 
  			user_id,--用户id
  			dt as new_dt --新增日期
  		from new_users
  		where dt >= '2020-05-01' and dt<= '2020-06-01'
  	)t_new
  	left join
  	( --活跃用户
  		select
  			user_id, --用户id
  			dt as active_dt, --活跃日期
  		from active_users
  		where dt >= '2020-05-01' and dt<= '2020-06-01'
  	)t_active on t_new.user_id = t_active.user_id
  	group by t_new.new_dt
  )t	
  

  参考链接：关于用户留存率的计算

三、连续登陆

1.数据准备

1.表结构
	desc use_login

	user_id string comment '用户id'
	login_dt sting comment '登陆时间'	

2.数据格式
	user_id  login_dt
	1		 2020-05-01
	1		 2020-05-02
	1		 2020-05-04	

2.思路分析一

连续登陆一般有两种实现思路：① row_number() + date_sub、②lead/lag + datediff，其中的date_sub、date_add、datediff三者可以修改对应逻辑替换。

• row_number实现思路
  • ① 按照登陆时间给用户排序号 row_number() over(partition by user_id order by login_dt):

     user_id	login_dt		rn
    	1		2020-05-01  	1
    	1		2020-05-02		2
    	1 		2020-05-04 		3
    

  • ② 按照用户 、登陆时间与排序好的差值（date_sub(login_dt,rn)） 分组:

    得到两组：（1 2020-05-01 1  、 1 2020-05-02  2 ）和 （ 1  2020-05-04  3 ）
    分组条件是： user_id  和 date_sub(login_dt,rn) （如果是连续登陆，date_sub求出来是同一个值）
    
    	 user_id	login_dt		rn
    	---------------第一组---------------------
    	1		2020-05-01  	1
    	1		2020-05-02		2
    	---------------第二组----------------------
    	1 		2020-05-04 		3
    

  • ③最后按照需求取字段，如：用户连续登陆的起止时间、连续登陆的天数：

    select
    	user_id,
    	min(login_dt) as start_dt, --连续登陆开始时间
    	max(login_dt) as end_dt, --连续登陆结束时间
    	count(1) as continue_dt, --连续登陆的天数
    from
    (
    	select
    		user_id,
    		login_dt,
    		row_number()  over(partition by user_id order by login_dt) as rn
    	from user_login
    )user
    group by
    	user_id, 
    	date_sub(login_dt,rn); // t1
    

    查询结果：

    user_id	 	start_dt		 end_dt		continue_dt
    	1		2020-05-01		2020-05-02		2
    	1		2020-05-04		2020-05-04		1
    

  • ④： 如果还有其他需要，比如连续登陆大于5天的用户等等，还需要嵌套一层，限制条件查询即可,或者使用having子句限制：

    求连续登陆三天的用户
    
    select
    	user_id,
    	min(login_dt) as start_dt, --连续登陆开始时间
    	max(login_dt) as end_dt, --连续登陆结束时间
    	count(1) as continue_dt, --连续登陆的天数
    from t1
    having count(1) = 3 ;
    

3.思路分析二

• lead/lag实现思路
  • ① ⽐如求连续三天登陆，可以将当天上⼀条数据和下⼀条数据都拿到

    select 
    	user_id,
    	login_dt,
    	lag(login_dt,1) over(partition by uesr_id order by login_dt) as lag_dt_01,
    	lead(login_dt,1) over(partition by user_id order by login_dt) as lead_dt_01
    from user_login; // t1
    

  • ②然后保证now-lag=lead-now=1即可;

    select
     user_id
    from t1
    where datediff(login_dt,lag_dt_01) = 1 and datediff(lead_dt_01,login_dt) = 1 
    

  • ③ 如果是连续多天，可以取更多的数据，或者将数据全部更改为lag或者lead函数
  • 参考链接：Hive_连续N天登陆

四、Top N

1.数据准备

每个顾客访客访问任何一个店铺的任何一个商品时都会产生一条访问日志.
访问日志存储的表名为Visit，访客的用户id为user_id，被访问的店铺名称为shop.
请统计每个店铺访问次数top3的访客信息.输出店铺名称、访客id、访问次数

----------------Visit表结构 ------------------
uesr_id  shop
 1		  a
 1		  b
 2		  c
...		 ...
-----------------输出结果---------------------------
请统计每个店铺访问次数top3的访客信息

shop	user_id		pv
...		...			...

2.思路分析

• ① 先求出每个店铺每个用户的访问次数pv

  select 
  	shop,
  	user_id,
  	count(1) as cnt
  from visit
  group by
  	shop,
  	user_id // t1
  

• ② 求出每个店铺 按照用户访问次数的排名

  select
  	shop,
  	user_id,
  	cnt,
  	row_number() over(partition by shop order by cnt desc) as rn
  from t1; //t2 
  

• ③ 取出每个店铺用户访问次数top3的用户信息

  select
  	shop,
  	user_id,
  	cnt
  from t2 
  where t2.rn <= 3;
  

  完整的结果：

  select
  	shop,
  	user_id,
  	cnt
  from
  (
  	select
  		shop,
  		user_id,
  		cnt,
  		row_number() over(partition by shop order by cnt desc) as rn
  	from
  	(
  		select 
  		 	shop,
  		 	user_id,
  		 	count(1) as cnt
   		from visit
   		group by shop,user_id
  	)t1
  ) t2 
  where t2.rn <= 3;
  

五、行列互转

1.行转列

• ①数据准备

  -----------------------------------------------------
  原式数据movie表：
   movie   		 category
   
  《疑犯追踪》		 悬疑,动作,科幻,剧情
  《Lie to me》 	 悬疑,警匪,动作,心理,剧情
  《战狼 2》 		 战争,动作,灾难
  -----------------------------------------------------
  结果数据
   movie		category_name
  
  《疑犯追踪》 		悬疑
  《疑犯追踪》 		动作
  《疑犯追踪》 		科幻
  《疑犯追踪》 		剧情
  《Lie to me》   	悬疑
  《Lie to me》    警匪
  《Lie to me》    动作
  《Lie to me》    心理
  《Lie to me》    剧情
  《战狼 2》        战争
  《战狼 2》        动作
  《战狼 2》        灾难
  

• ②sql查询

  select
  	movie,
  	category_name
  from movie
  lateral view explode(split(category),',') tmp as category_name
  

2.列转行

• ①数据准备

  -----------------------------------------------------
  原始数据constellation表：
  
  name 	constellation 	blood_type
  孙悟空 	白羊座 			A
  大海 	射手座 			A
  宋宋 	白羊座 			B
  猪八戒 	白羊座 			A
  凤姐 	射手座 			A
  
  -----------------------------------------------------
  结果数据
  --把星座和血型一样的人归类到一起。结果如下：
  
  射手座,A 	大海|凤姐
  白羊座,A 	孙悟空|猪八戒
  白羊座,B 	宋宋
  

• ②sql查询

  select
  	t.base,
  	concat_ws('|',collect_set(name)) as name
  (
   select
   	name,
   	concat_ws(',',constellationblood_type,blood_type) as base
   from constellation
  ) t
  group by t.base
  

3.经典面试题一

• ① 需求：求学生的选课情况

  原式数据
  ----------------course表-----------------------------
  id course 
  1   a 
  1   b 
  1   c 
  1   e 
  2   a 
  2   c 
  2   d 
  2   f 
  3   a 
  3   b 
  3   c 
  3   e
  
  
  预期结果：表中的1表示选修，表中的0表示未选修
  ----------------结果展示-----------------------------
  
  id    a    b    c    d    e    f
  1     1    1    1    0    1    0
  2     1    0    1    1    0    1
  3     1    1    1    0    1    0
  

• ②将学生的选课情况 和 所有的课程放在一行。得到 t_course

  select
  	t1.id as id,
  	t1.id_course as id_course,
  	t2.course as course
  from
  (
  	select  -- 每个学生id 对应的选课集合
  		id,
  		collect_set(course) as id_course
  	from course
  	group by id 
  ) t1
  cross join
  (
  	select  -- 所有课程的集合
  		collect_set(course) as  course
  	from course		
  )
  
  ---------------- t_course 结果展示-----------------------
  id			id_course					course
  
  1		["a","b","c","e"]		["a","b","c","d","e","f"]
  2		["a","c","d","f"]		["a","b","c","d","e","f"]
  1		["a","b","c","e"]		["a","b","c","d","e","f"]
  
  

• ③通过case when + array_contains判断学生的选课情况

  select
  	id,
  	case when arry_contains(id_course,course[0]) then 1 else 0  end as a ,
  	case when arry_contains(id_course,course[1]) then 1 else 0 end as b,
  	case when arry_contains(id_course,course[2]) then 1 else 0 end as c,
  	case when arry_contains(id_course,course[3]) then 1 else 0 end as d,
  	case when arry_contains(id_course,course[4]) then 1 else 0 end as e,
  	case when arry_contains(id_course,course[5]) then 1 else 0 end as f,
  from t_course
  
  最终结果展示
  --------------------结果展示-------------------------------
  id	a	b	c	d	e	f
  1	1	1	1	1	0	0	
  2	1	0	1	0	1	1	
  3	1	1	1	0	0	0
  

• 参考链接：Hive的5个面试题

六、开窗函数

开窗函数的详细讲解参考：Hive开窗函数详解

1.经典面试题一

• ① 需求：求股票的波峰Crest 和 波谷trough

  波峰：当天的股票价格大于前一天和后一天
  波谷：当天的股票价格小于前一天和后一天
  
  数据准备： stock表有3个字段： id（股票id）、price（股票价格）、dt（日期）
  --------------------------原始数据 stock表--------------------------------
  id		price		dt
  1		20		2020-09-01
  1		21		2020-09-02
  1		19		2020-09-03
  2		98		2020-09-01
  ...		...		...
  
  查询结果：
  --------------------------预期结果-------------------------------
  id		price		dt			des
  1		20		2020-09-01		nothing
  1		21		2020-09-02		Crest
  1		19		2020-09-03		nothing
  ...		...		...
  

• ② 思路：通过lag和 lead函数 求出前一天和后一天的股票价格，在比较大小

  select
  	id,
  	price,
  	dt,
  	lag(price, 1) over(partition by id order by dt) as lag_price,
  	lead(price,1) over(partition by id order by dt) as lead_price
  from stock; //t1
  

• ③ case when + price大小比较求出波峰波谷

  select
  	id,
  	price,
  	dt,
  	case when t1.price > lag_price and t1.price > lead_price then 'Crest'
  		 when t1.price < lag_price and t1.price < lead_price then 'trough'
  		 else 'nothing'
  	end as des
  from t1
  

七、解析复杂数据类型

1.解析json数据

• get_json_object(string json_string, string path):第一个参数填写json对象变量，第二个参数使用$表示json变量标识，然后用 .或 []读取对象或数组；

• 参考链接：Hive复杂日志数据类型的存储与解析

• ①数据准备。

  //假设data 是test表里的字段
  data = 
  {
  	"store":
  		  	{
  		  		"fruit":[{"weight":8,"type":"apple"}, {"weight":9,"type":"pear"}],  
  		        "bicycle":{"price":19.95,"color":"red"}
  			},
  	"email":"amy@only_for_json_udf_test.net", 
   	"owner":"amy" 
  }
  

• ② 解析单层值：

  select 
  	get_json_object(data,'$.owner') 
  from test;  // 返回 amy
  
  
  select 
  	get_json_object(data,'$.store')
  from test; //返回 {"fruit":[{"weight":8,"type":"apple"},{"weight":9,"type":"pear"}],"bicycle":{"price":19.95,"color":"red"}}
  
  --使用[] 获取json的第一个数组对象值
  select
  	get_json_object(data,'$.[0]')
  from test;//返回 null值  因为 data本身不是一个数组，所以会返回null
  

• ③ 解析多层值
  如何获取 store字段里面的值呢？ 可以继续对变量使用点.或者[]

  -- 获取weight的值
  select 
  		get_json_object(data,'$.store.fruit.weight')
  from test; //返回 [8,9]
  
  -- 获取fruit的第一个数组值。fruit是数组，才能使用[]访问。
  select 
  		get_json_object(data,'$.store.fruit[0]')
  from test; //返回 {"weight":8,"type":"apple"}
  

  参考链接:解析json

• ④ 获取多个值

  我们可以多次使用get_json_object，获取想要的值：

  	select 
     		get_json_object(data,'$.store.fruit[0].weight') as weight,
     		get_json_object(data,'$.store.fruit[0].type') as `type`,
     from test; //返回 :  8   apple
  

  如果需要取的字段比较多，可以使用 json_tuple

  select 
     	json_tuple(data,'email','owner') 
  from test; //返回 :  amy@only_for_json_udf_test.net  amy
  
  注意：使用json_tuple不支持$. 所以也不支持 store.fruit[0].weight的调用。以下两种写法返回null
  select 
     	json_tuple(data,'$.email','$.owner') 
  from test; //返回 : null		null
  
  select 
     	json_tuple(data,'$.store.fruit[0].weight','$.store.fruit[0].type') 
  from test; //返回 : null		null
  

2.正则表达函数

• regexp_replace(string subject, string pattern, string str):

  • 参数说明：subject为被替换的字符串，pattern为正则表达式，str为替换正则表达式(匹配到的字符串)的字符串
  • 描述：将字符串subject中，符合正则表达式pattern的字符串，替换为字符串str，然后将替换后的整个字符串返回
  • 测试

    -- 将 abc 换成 ABC
    select  regexp_replace('abcd','abc','ABC') //结果 ABCd
    
    -- 将 abc以外的字符换成 x
    select regexp_replace('abcd','[^abc]','x')//结果abcx
    

• regexp_extract(string subject, string pattern, int index)

    todo
  

3.正则表达规则

• 参考链接：正则表达全集

  \	将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n”匹配字符“n”。“\n”匹配一个换行符。串行“\\”匹配“\”而“\(”则匹配“(”。
  ^	匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
  $	匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
  *	匹配前面的子表达式零次或多次。例如，zo*能匹配“z”以及“zoo”。*等价于{0,}。
  +	匹配前面的子表达式一次或多次。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
  ?	匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“does”或“does”中的“do”。?等价于{0,1}。
  {n}	n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
  {n,}	n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
  {n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
  ?	当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+?”将匹配单个“o”，而“o+”将匹配所有“o”。
  .	匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符，请使用像“(.|\n)”的模式。
  (pattern)	匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“\(”或“\)”。
  (?:pattern)	匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分是很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。
  (?=pattern)	正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
  (?!pattern)	正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
  (?<=pattern)	反向肯定预查，与正向肯定预查类拟，只是方向相反。例如，“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。
  (?<!pattern)	反向否定预查，与正向否定预查类拟，只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。
  x|y	匹配x或y。例如，“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。
  [xyz]	字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
  [^xyz]	负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“p”。
  [a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。
  [^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
  \b	匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。
  \B	匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
  \cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
  \d	匹配一个数字字符。等价于[0-9]。
  \D	匹配一个非数字字符。等价于[^0-9]。
  \f	匹配一个换页符。等价于\x0c和\cL。
  \n	匹配一个换行符。等价于\x0a和\cJ。
  \r	匹配一个回车符。等价于\x0d和\cM。
  \s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
  \S	匹配任何非空白字符。等价于[^ \f\n\r\t\v]。
  \t	匹配一个制表符。等价于\x09和\cI。
  \v	匹配一个垂直制表符。等价于\x0b和\cK。
  \w	匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。
  \W	匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
  \xn	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。.
  \num	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1”匹配两个连续的相同字符。
  \n	标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
  \nm	标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。
  \nml	如果n为八进制数字（0-3），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
  \un	匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（©）。
  
  常用正则表达式
  
  用户名	/^[a-z0-9_-]{3,16}$/
  密码		/^[a-z0-9_-]{6,18}$/
  十六进制值	/^#?([a-f0-9]{6}|[a-f0-9]{3})$/
  电子邮箱	/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/
  /^[a-z\d]+(\.[a-z\d]+)*@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/
  URL		/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/
  IP地址	/((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)/
  /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
  

5.