正则表达式全解

分类：正则表达式作者：编程之家用户
package cn.itcast.exp;

/*
  正则表达式：其实一种规则，有自己特殊的应用,其作用就是针对于字符串进行操作。
  正则：就是用于操作字符串的规则,其中这些规则使用了一些字符表示。
  
  预定义字符类 
	. 	任何字符（与行结束符可能匹配也可能不匹配） 
	\d 	数字：[0-9] 
	\D 	非数字： [^0-9] 
	\s 	空白字符：[ \t\n\x0B\f\r] 
	\S 	非空白字符：[^\s] 
	\w 	单词字符：[a-zA-Z_0-9] 
	\W 	非单词字符：[^\w]
	注意:任何预定义字符没有加上数量词之前都只能匹配一个字符
	
 Greedy 数量词   X代表预定义字符
	X? 一次或一次也没有
	X*	 零次或多次
	X+	 一次或多次
	X{n}	X，恰好n次
	X{n,}	X，至少n次
	X{n,m}	X，至少n次，但是不超过m次
	
	. 一个字符
	* 匹配0次或多个字符,a*  就是匹配一个或多个a,匹配串必须都是a
	+ 匹配一个或多个字符
	?匹配0个或一个
	{}-->表示范围
	[]表示某一个字符的范围
	
范围词
	[abc]	a、b 或 c（简单类） 
	[^abc]	任何字符，除了 a、b 或 c（否定） 
	[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围） 
	[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集） 
	[a-z&&[def]]	d、e 或 f（交集） 
	[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去） 
	[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）	
          注意:范围词里面不管内容有多长，没有数量词的匹配都只能匹配一个字符

	  范围
	   []表示某一个字符的范围
	    ^ 代表非或除了什么以外的意思
	   -  范围
	   |  或
	   && 并
 */

public class Demo {
	
	public static void main(String[] args) {
		//简单认识正则表达式
		System.out.println("a&f".matches("..."));
		System.out.println("2".matches("\\d"));  //\\d代表一个占位符，字符串只能有一个数字才能返回true
		System.out.println("非数字："+"d".matches("\\D"));  //true
		System.out.println("空白字符:" + " ".matches("\\s"));  //true
		System.out.println("非空白字符:" + " ".matches("\\S"));  //  false
		System.out.println("单词字符:" + "a".matches("\\w"));    //true
		System.out.println("非单词字符:" + "a".matches("\\W"));   //false
		p(" \n\r\t".matches("\\s{4}"));
		p(" ".matches("\\S"));
		p("a_8".matches("\\w{3}"));
		p("abd888&^%".matches("[a-z]{1,3}\\d+[&^%#]+"));
		p("\\".matches("\\\\"));//匹配一个反斜杠
		
		//POSIX Style   unix的统一  用的不是太多
		p("a".matches("\\p{Lower}"));//英文的小写字母
		
		
		
		
		System.out.println("？表示一次或一次也没有:"+"1".matches("\\d?"));
		System.out.println("*表示零次或多次:"+"13243243534".matches("\\d*"));
		System.out.println("+表示一次或多次:"+"13243243534".matches("\\d+"));
		System.out.println("{次数} 恰好出现n次:"+"132432".matches("\\d{6}"));
		System.out.println("{次数,} 至少出现指定的位数:"+"13243243534".matches("\\d{3,}"));
		System.out.println("{次数1,次数2} 指定出现次数的范围:"+"13243".matches("\\d{3,5}"));
		
		System.out.println("abc".matches("[abc]")); //false
		System.out.println("abc".matches("[abc]{3}"));  //true
		System.out.println("@".matches("[^abc]"));  //true
		System.out.println( "一个字符出现在a-z之间"+"a".matches("[a-z]"));
		System.out.println( "一个所有字母"+"A".matches("[a-zA-Z]"));
		"aaaa".matches("a."); // false
		"aaaa".matches("a*"); // true
		"aaaa".matches("a+"); //true
		"aaaa".matches("a?"); // false
		p("a".matches("."));
		p("aa".matches("aa"));
		p("aaaa".matches("a*"));
		p("aaaa".matches("a+"));
		p("".matches("a*"));
		p("aaaa".matches("a?"));
		p("".matches("a?"));
		p("a".matches("[abc]"));//取出中括号abc其中的一个与a进行匹配
		p("a".matches("[^abc]"));//除了a,b,c以外的字符与a进行匹配
		p("a".matches("[a-zA-Z]"));//所有的大小写字母与a进行匹配
		p("a".matches("[a-z]|[A-Z]"));//a-z或A-Z与a进行匹配
		p("a".matches("[A-Z]&&[RFG]"));
		p("2321432456789765432".matches("\\d{3,100}"));//数字的长度在3到100之间
		p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}"));
		p("192".matches("[0-2][0-9][0-9]"));
		
		//\d代表0-9的任何一个数组
		//replaceAll把所有的数字替换成-
		//在java中一个反斜杠(\)代表转义,//"\\"-->输出为\  规定\d才代表0-9的任何一个数组
		//一定要注意\d在java中是\\d
		System.out.println("adsa3432fdsfs".replaceAll("\\d","-"));
		
	}

	public  static void p(boolean matches) {
		 System.out.println(matches);
	}
	
}


package cn.itcast.exp;

import java.util.Arrays;

/*
 	正则表达式的方法:
 	
 	
 	匹配:
 		matches()
 	
 	切割:
 		split() 
 	
 	替换:
 		String replaceAll(String regex,String replacement) 
                    使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。 
 	
 	查找:
  
 */

public class Demo2 {
	public static void main(String[] args) {
		
		matchsPhone("15224816289");
		matchsTel("0394-7410747");
		
		testSplit1();
		
		repalceAll1();
		repalceAll2();
	}
	
	
	//匹配手机号   第一位只能是1   第二位 3 5 4 7 8 长度11位
	public static void matchsPhone(String phone){
		String reg = "1[35478]\\d{9}";
		System.out.println(phone.matches(reg)?"合法手机号":"非法");
	}
	
	//固定电话     区号-主机号   区号:首位0  长度3~4位  主机号  首位不能为0  长度7~8
	public static void matchsTel(String tel){
		System.out.println(tel.matches("0\\d{3,4}-[1-9]\\d{6,7}")?"合法固话":"非法");
	}
	
	//切割
	public static void testSplit1(){
		String str = "大     话                西      游";
		String[] datas = str.split(" +");
		System.out.println(Arrays.toString(datas));
	}
	//根据重叠词进行切割
	public static void testSplit2(){
		String str = "大话话西游游222222222222你猜";  
		String[] s = str.split("(.)\\1+");  //如果正则的内容需要被复用，那么需要对正则的内容进行分组。分组的目的就是为了提高正则的复用性。
		//组号不能指定，组号是从1开始。
		System.out.println(Arrays.toString(s));
		/*
		 ( ) 分组: 分组的目的就是为了提高正则的复用性。 组号不能指定，组号是从1开始。
		  
		  ((A)(B(C)))
		       第一组:((A)(B(C)))
		       第二组:(A)
		       第三组:(B(C))
		      第四组:(C)
		 \1：   引用第一组所匹配到的内容
		 \2：   引用第二组所匹配到的内容
		 \3：   引用第三组所匹配到的内容
		 。。。。。。。。
		 */
	}
	
	//替换
	public static void repalceAll1(){
		String str = "如有需求请联系：15224816289 	如有需求请联系：15224816289 	";
		String reg = "1[34578]\\d{9}"; 	
		str = str.replaceAll(reg,"****");
		System.out.println(str);
	}
	//变成  把重叠词换成一个词
	public static void repalceAll2(){
		String str = "大大大话话西西游游游2222222";
		str = str.replaceAll("(.)\\1+","$1");
		//如果需要再replaceAll()方法正则的外部引用组的内容，那么使用"$组号"
		System.out.println(str);
	}
	
}



package cn.itcast.exp;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
  	查找:  使用Pattern类
	  指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，
	  依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，
	  所以多个匹配器可以共享同一模式。因此，典型的调用顺序是 

	 Pattern p = Pattern.compile("a*b");
	 Matcher m = p.matcher("aaaaab");
	 boolean b = m.matches();
	 
	 查找需要使用的对象:
	 1.Pattern（正则对象）
	 2.Matcher（匹配器对象）
	 
             匹配器使用的方法:
             1.find（） 通知匹配器去匹配字符串，查找符合规则的字符串。
             2.group（） 获取符合规则的子串。
	 注意:  使用group()的时候一定要先调用find()让匹配器去查找符合规则的字符串，否则报错。
	 
	 Matcher类的方法:
 	metches  永远匹配整个字符串
 	find   找子串
 	lookingAt 每次从头上找子串
 	
 	注意:
 	  在metches与find一起用的时间,metches在匹配的时候,如果匹配不成功,会把光标停在不匹配的哪里,你在调用find,会接着上一次的光标进行匹配,如果你想从头开始,需要用reset方法重置一下
	 
	 
	 
 */
public class Demo3 {
	
	public static void main(String[] args) {
		
		//public static Pattern compile(String regex)
		//将给定的正则表达式编译到模式中。
		//把regex这个正则表达式编译下,放到Pattern这个模式中,编译好了,当你再拿这个字符串匹配的时候,速度回快一些
		Pattern pattern = Pattern.compile("[a-z]{3}");
		//[a-z]{3}-->代表三个字母,都是a-z范围
		Matcher matcher = pattern.matcher("dfg");
		//pattern这个模式匹配dfg这个字符串   
		//matcher  匹配方法   
		//Matcher  匹配器
		 matcher.matches(); //匹配是否成功
		
		//27--33行的代码执行的速度快  36行慢些  没有编译
		"dfg".matches("[a-z]{3}");
		
		System.out.println("---------------------");
		Pattern pat = Pattern.compile("\\d{3,5}");
		String s = "123-34354-123-00";
		Matcher m = pat.matcher(s);
		p(m.matches());//模式串与s全部进行匹配
		m.reset();//注意此方法,重置匹配器
		p(m.find());//模式串在s找一个子串进行匹配
		p(m.start()+"-"+m.end());
		p(m.find());
		p(m.start()+"-"+m.end());
		p(m.find());
		p(m.start()+"-"+m.end());
		p(m.find());
		//p(m.start()+"-"+m.end());//根据模式串进行匹配的时候,只有找到子串才可以使用start与end方法
		System.out.println("---------------------");
		p(m.lookingAt());
		
		testGroup1();

		//查找长度不定的子串
		
		/*testGroup();
		
		test();
		test1();
		test2();*/
	}

	public static void testGroup1() {
		//\\d{3,5}[a-z]{2}-->这组正则表达式,用小括号,把他们分开,分成两组,再加上子串本身,共三组,//group默认数组子串的全部  
		// -->(\\d{3,5})([a-z]{2})-->分组,在多个()时候,只数左小括号,按照1,2,3,4,5...进行编号,在grounp中,直接grounp(n)   n代表你想调用的子串
		Pattern p5 = Pattern.compile("(\\d{3,5})([a-z]{2})");
		String  s5 = "132aa-1235bb-132zz-00";
		Matcher m5 = p5.matcher(s5);
		while(m5.find()){//查找子串
			p(m5.group(0));
		}
	}

	//查找长度不定的子串
	public static void testGroup() {
		Pattern p2 = Pattern.compile("\\d{3,5}[a-z]{2}");
		String  s1 = "132aa-1235bb-132zz-00";
		Matcher m1 = p2.matcher(s1);
		while(m1.find()){//查找子串
			p(m1.group());
		}
	}




	public  static void p(Object o) {
		System.out.println(o);
	}

	//找到固定三个字母组成的单词
	public static void test() {
		String content = "da jia computer fly";
		String reg = "\\b[a-zA-Z]{3}\\b";
		//先把字符串的正则编译成Patter对象。
		Pattern p = Pattern.compile(reg);
		//使用正则对象匹配字符串用于产生一个Matcher对象
		Matcher m = p.matcher(content);
		
		/*
		    System.out.println("有符合规则的字符串吗?"+m.find());
			System.out.println("结果:"+m.group());
	    */	
		while(m.find()){
			System.out.println(m.group());
		}
	}
	
	//查找字符串中的java，区分大小写
	public static void test1() {
		Pattern p = Pattern.compile("java");
		Matcher ma = p.matcher("java Java JAVA JaVa IloveJAVA you hateJava");
		while(ma.find()){
			System.out.println(ma.group());;//输出匹配到的子串  分组
		}
	}
	
	//不区分大小写的使用
	public static void test2() {
		Pattern p1 = Pattern.compile("java",Pattern.CASE_INSENSITIVE);// Pattern.CASE_INSENSITIVE   启用不区分大小写的匹配。
		Matcher ma1= p1.matcher("java dsfs  Java JAVA JaVa IloveJAVA you hateJava dsfds");
						//匹配的时候把dsfs  Java看成一个串
		StringBuffer buf = new StringBuffer();
		int i=0;
		while(ma1.find()){
			i++;
			if(i%2==0){
				ma1.appendReplacement(buf,"java");
			}else{
				ma1.appendReplacement(buf,"JAVA");
			}
		}
		ma1.appendTail(buf);

	}

	
}


package cn.itcast.exp;
/*
  单词边界匹配器
  \b   单词边界匹配器只是代表了单词的开始或者结束部分，不匹配任何的字符。
   ^(开头) 在[]内代表非  在模式串的开头代表第一个字母是什么 
   $ 末尾
 */
public class Demo4 {
	 
	
	public static void main(String[] args) {
		System.out.println("hello world".matches("hello\\bworld"));  //false
		System.out.println("hello world".matches("hello\\b world")); 
		
		p("hello sir".matches("^h.*"));//开头必须是h后面匹配多个0次或多个字符
		p("adasdasd".matches("a.*")); //a后面匹配多个0次或多个字符
		p("adasdasd".matches(".*")); //这是任意的0个或多个字符
		p("adasdasd".matches("a*"));//a后面是0个或多个a  flase
		p("hello sir".matches(".*ir$"));
		p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));
		p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
		
		//空白行
		p(" \n".matches("^[\\s&&[^\\n]]*\\n$"));
		//第一个事空格,一个或多个,末尾是\n
		
		//练习
		p("aaa 8888c".matches(".*\\d{4}.")); //true
		p("aaa 8888c".matches(".*\\b\\d{4}."));//true
		p("aaa 8888c".matches(".*\\d{4}."));//true
		p("aaa8888c".matches(".*\\b\\d{4}."));//false
		
		//邮箱的匹配
		p("nianxiongdi321@163.com".matches("[a-zA-Z|[0-9]]+@[a-zA-Z|[0-9]]+.[a-zA-Z]{1,6}"));
		p("nianxiongdi321@163.com".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+"));  //[]中的-代表字符
		
	}

	private static void p(boolean matches) {
		System.out.println(matches);
	}
	
	
	

}


package cn.itcast.exp;


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

	//统计某网站的email地址,可以发垃圾邮件
//Spider--   这种程序蜘蛛程序
public class Demo5{
	
	public static void main(String[] args) {
		try {
			BufferedReader br = new BufferedReader(new FileReader("E:\\myeclipes\\RegExp\\src\\file\\回复：【坐等更新。。。。谁要1__464 。 留Email 】_王爷要休妃吧_百度贴吧.html"));
			String line = "";
			while((line=br.readLine())!=null){
				parse(line);
			}
		
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	
	}

	private static void parse(String line) {
		Pattern p = Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
		Matcher m = p.matcher(line);
		while(m.find()){
			System.out.println(m.group());
		}
	}
}




package cn.itcast.exp;


import java.util.regex.Matcher;
import java.util.regex.Pattern;

//Greedy  Reluctant   Possessive区别
public class Demo6 {
	
	public static void main(String[] args) {
		/*//Greedy   (.{3,10})[0-9]  -->一般使用这个
		//先把s吞取10个字符再说,与模式串进行匹配,匹配失败,把最后一个吐出来,吐出来的正好是数字,正好匹配,所以输出0-10
		Pattern p = Pattern.compile("(.{3,10})[0-9]");
		String  s = "aaaa3bbbb6";
		Matcher m = p.matcher(s);
		if(m.find()){
			p(m.start()+ "-" + m.end());
		}else{
			p("not match");
		}*/
		
		/*//Reluctant	(.{3,10}?)[0-9]
		//这个与Greedy正好相反 吞最少的  正好结果为0-5
		Pattern p = Pattern.compile("(.{3,10}?)[0-9]");
		String  s = "aaaa3bbbb6";
		Matcher m = p.matcher(s);
		if(m.find()){
			p(m.start()+ "-" + m.end());
		}else{
			p("not match");
		}*/
		
		// Possessive  与Greedy 不同的是,它不吐字符,这个匹配不上
		Pattern p = Pattern.compile("(.{3,10}+)[0-9]");
		String  s = "aaaa3bbbb6";
		Matcher m = p.matcher(s);
		if(m.find()){
			p(m.start()+ "-" + m.end());
		}else{
			p("not match");
		}
		
		
		
	}

	private static void p(Object o) {
		System.out.println(o);
	}
}


package cn.itcast.exp;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

//代码统计小程序
public class CodeCounter {
	
	static long normaLines = 0;//正常的行数
	static 	long commentLines = 0;//注释行数
	static long whiteLines = 0;//空白行
	
	public static void main(String[] args) {
		File f = new File("E:\\SQF\\BaiduYunDownload\\尚学堂\\马士兵Java\\尚学堂科技_马士兵_JAVASE_坦克大战网络版\\尚学堂科技_马士兵_JAVA_坦克大战网络版视频教程\\source\\TankWar1.9.11\\src");
		File[] codeFiles = f.listFiles();//获取文件呢
		//.java结尾的文件检索
		for(File code:codeFiles){
			if(code.getName().matches(".*\\.java$")){//后缀.java文件
				parse(code);
			}
		}
		
		System.out.println("normaLines：" +normaLines );
		System.out.println("commentLines：" + commentLines);
		System.out.println("whiteLines：" +whiteLines );
		
	
	
	}

	private static void parse(File f) {
		BufferedReader br = null;
		boolean comment = false;
		
		try {
			  br = new BufferedReader(new FileReader(f));
			  String line = "";
			  while((line=br.readLine())!=null){
				  line = line.trim();//注意去空格,不要在36行去空格,空行时候
				  					 //readLine在读取数据的时候,会把每一行的\n去掉
				  if(line.matches("[\\s&&[^\\n]]*$")){//空行的处理   在不用readLine处理空行-----> [\\s&&[^\\n]]*\n$
					  whiteLines++;
				  }else if(line.startsWith("/*")&&line.endsWith("*/")){ //当多行注释在一行的时候
					  commentLines++;
				  }else if(line.startsWith("/*")&&!line.endsWith("*/")){//当多行注释不再一行的时候
					  commentLines++;
					  comment = true;
				  }else if(true == comment){ //多行注释的中间的进行统计
					  commentLines++;
					  if(line.startsWith("*/")){//当统计到多行注释的最后一行把comment置为false
						  comment = false;
					  }
				  }else if(line.startsWith("//")){ //单行注释
					  commentLines++;
				  }else{//代码行统计
					  normaLines++;
				  }
			  }
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(br != null){
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

jquery.validate使用攻略（表单校验）
jquery.validate使用攻略（表单校验） 目录 jquery.validate使用攻略1 第一章 jquery.validate使用攻略1 第二章 jQuery.validate.js API7 Custom selectors7 Utilities8 Validato
清空字符串的空格（正则表达式）
/\s+/g和/\s/g的区别 正则表达式/\s+/g和/\s/g，目的均是找出目标字符串中的所有空白字符，但两者到底有什么区别呢？ 我们先来看下面一个例子： let name = 'ye wen jun';let ans = name.replace(/\s/g, '&#3
自整理几个jquery.Validate验证正则
自整理几个jquery.Validate验证正则： 1. 只能输入数字和字母 /^[0-9a-zA-Z]*$/g jQuery.validator.addMethod("letters", function (value, element) { return this.optio
this.optional(element)的用法
this.optional(element)的用法 this.optional(element)是jquery.validator.js表单验证框架中的一个函数，用于表单控件的值不为空时才触发验证。 简单来说，就是当表单控件值为空的时候不会进行表单校验，此函数会返回true，表示校验通过，当表单控件
jQuery.validate 表单动态验证
jQuery.validate 表单动态验证 实际上jQuery.validate提供了动态校验的方法。而动态拼JSON串的方式是不支持动态校验的。牺牲jQuery.validate的性能优化可以实现(jQuery.validate的性能优化见图1.2 jQuery.validate源码 )。 也可
自定义验证之这能输入数字(包括小数 负数 )
自定义验证之这能输入数字(包括小数 负数 ) <script type="text/javascript"> function onlyNumber(obj){ //得到第一个字符是否为负号 var t = obj.value.charAt(0); //先把非数字的都
validator.js——引入外部验证规则
// 引入了外部的验证规则 import { validateAccountNumber } from "@/utils/validate"; validator.js /*是否合法IP地址*/ export function validateIP(rule, value,cal
VUE开发--表单验证——正则
VUE开发--表单验证(六十三) 一、常用验证方式 vue 中表单字段验证的写法和方式有多种，常用的验证方式有3种： data 中验证 表单内容： <!-- 表单 --> <el-form ref="rulesForm" :rules="formRul
正则表达式—含座机的
正则表达式 座机的： 例子： 座机有效写法: 0316-8418331 (010)-67433539 (010)67433539 010-67433539 (0316)-8418331 (0316)8418331 正则表达式写法 0\d{2,3}-\d{7,8}|\(?0\d{2,3}[)-]?\d
js校验输入0-1之间的小数,最多保留小数点后两位
var reg = /^0\.[1-9]{0,2}$/;var linka = 0.1;console.log (reg.test (linka)); 0到1两位小数正则 ^(0\.(0[1-9]|[1-9]{1,2}|[1-9]0)$)|^1$ 不含0、0.0、0.00 // 验证是否是[1-10
input最大长度限制问题
input最大长度限制问题 <input type="text" maxlength="5" /> //可以 <input type="number" maxlength="5" /> //没有效
js输入验证是否为空、是否为null、是否都是空格—去掉所有空格
js输入验证是否为空、是否为null、是否都是空格 目录 1.截头去尾 trim 2.截头去尾 会去掉开始和结束的空格，类似于trim 3.会去掉所有的空格，包括开始，结束，中间 1.截头去尾 trim str=str.trim(); // 强烈推荐 最常用、最实用 or $.trim(str);
正则表达式语法大全以及match、search、replace、test的各自作用
正则表达式语法大全 字符串.match(正则)：返回符合的字符串，若不满足返回null 字符串.search(正则)：返回搜索到的位置，若非一个字符，则返回第一个字母的下标，若不匹配则返回-1 字符串.replace(正则,新的字符串)：找到符合正则的内容并替换 正则.test(字符串)：在字符串中
正整数正则表达式
正整数正则表达式正数的正则表达式(包括0，小数保留两位)： ^((0{1}.\d{1,2})|([1-9]\d.{1}\d{1,2})|([1-9]+\d)|0)$正数的正则表达式(不包括0，小数保留两位)： ^((0{1}.\d{1,2})|([1-9]\d.{1}\d{1,2})|([1-9]+
JS 正则验证 test()
JS 正则验证 test() /*用途：检查输入手机号码是否正确输入：s：字符串返回：如果通过验证返回true,否则返回false /function checkMobile(s){var regu =/[1][3][0-9]{9}$/;var re = new RegExp(regu);if (r
常用正则
请输入保留两位小数的销售价的正则： /(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9]\.[0-9]([0-9])?$)/ 1.只能输入英文 <input type="text" onkeyup="value
判断价格的正则表达式
判断价格的正则表达式 价格的正则表达式 /(^[1-9]\d*(\.\d{1,2})?$)|(^0(\.\d{1,2})?$)/; 1 解析：价格符合两种格式 ^ [1-9]\d*(.\d{1,2})?$ ： 1-9 开头，后跟是 0-9，可以跟小数点，但小数点后要带上 1-2 位小数，类似 2,2
最实用的正则表达式整理
文章浏览阅读106次。这篇文章主要介绍了最实用的正则表达式整理,比如校验邮箱的正则，号码相关，数字相关等等，本文给大家列举的比较多，需要的朋友可以参考下。_/^(?:[1-9]d*)$/ 手机号
正则表达式总结，正则表达式匹配不包含某个字符串
文章浏览阅读1.2k次。4、匹配中的==、an==、== an9、i9 == "9i"和99p==请注意下面这部分的作用，它在匹配中间内容的时候排除了说明：当html字符串如下时，可以匹配到两处，表示匹配的字符串不包含and且不包含空白字符。说明：在上面的正则表达式中，_gvim正则表达式匹配不包含某个字符串
正则表达式匹配a标签的href
文章浏览阅读897次。【代码】正则表达式匹配a标签的href。_auto.js 正则匹配herf
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot