精华内容
下载资源
问答
  • 正则表达式

    2014-12-03 14:51:39
    由于某些字符类非常常用,所以JavaScript的正则表达式语法包含一些特殊字符和转义序列来表示这些常用的类.例如, \s 匹配的是空格符,制表符和其它空白符, \s 匹配的则是空白符之外的任何字符. 正则表灰式的字符类 ...
  • 正则表达式廖雪峰版

    2021-04-01 16:21:27
    对应的正则表达式就是:20\d\d,其中\d表示任意一个数字。 正则表达式转换为Java字符串就变成了20\d\d,注意Java字符串用\表示\。 最后,用正则表达式匹配一个字符串的代码如下: // regex public class Main { ...

    第一个例子-数字判断

    首先要导包
    import java.util.regex.*;
    举个例子:要判断用户输入的年份是否是20##年,我们先写出规则如下:
    一共有4个字符,分别是:2,0,09任意数字,09任意数字。
    对应的正则表达式就是:20\d\d,其中\d表示任意一个数字。
    把正则表达式转换为Java字符串就变成了20\d\d,注意Java字符串用\表示\。
    最后,用正则表达式匹配一个字符串的代码如下:

    // regex
    public class Main {
        public static void main(String[] args) {
            String regex = "20\\d\\d";
            System.out.println("2019".matches(regex)); // true
            System.out.println("2100".matches(regex)); // false
        }
    }
    

    基本匹配规则

    精准匹配-可以用equal

    正则表达式的匹配规则是从左到右按规则匹配。我们首先来看如何使用正则表达式来做精确匹配。
    对于正则表达式abc来说,它只能精确地匹配字符串"abc",不能匹配"ab",“Abc”,“abcd"等其他任何字符串。
    如果正则表达式有特殊字符,那就需要用\转义。例如,正则表达式a&c,其中&是用来匹配特殊字符&的,它能精确匹配字符串"a&c”,但不能匹配"ac"、“a-c”、“a&&c"等。
    要注意正则表达式在Java代码中也是一个字符串,所以,对于正则表达式a&c来说,对应的Java字符串是"a\&c”,因为\也是Java字符串的转义字符,两个\实际上表示的是一个\:

    // regex
    public class Main {
        public static void main(String[] args) {
            String re1 = "abc";
            System.out.println("abc".matches(re1));
            System.out.println("Abc".matches(re1));
            System.out.println("abcd".matches(re1));
    
            String re2 = "a\\&c"; // 对应的正则是a\&c
            System.out.println("a&c".matches(re2));
            System.out.println("a-c".matches(re2));
            System.out.println("a&&c".matches(re2));
        }
    }
    

    如果想匹配非ASCII字符,例如中文,那就用\u####的十六进制表示,例如:a\u548cc匹配字符串"a和c",中文字符和的Unicode编码是548c。

    匹配任意字符

    精确匹配实际上用处不大,因为我们直接用String.equals()就可以做到。大多数情况下,我们想要的匹配规则更多的是模糊匹配。我们可以用.匹配一个任意字符。

    例如,正则表达式a.c中间的.可以匹配一个任意字符,例如,下面的字符串都可以被匹配:

    “abc”,因为.可以匹配字符b;
    “a&c”,因为.可以匹配字符&;
    “acc”,因为.可以匹配字符c。
    但它不能匹配"ac"、“a&&c”,因为.匹配一个字符且仅限一个字符。

    匹配数字

    用.可以匹配任意字符,这个口子开得有点大。如果我们只想匹配0~9这样的数字,可以用\d匹配。例如,正则表达式00\d可以匹配:

    “007”,因为\d可以匹配字符7;
    “008”,因为\d可以匹配字符8。
    它不能匹配"00A",“0077”,因为\d仅限单个数字字符。

    匹配常用字符

    用\w可以匹配一个字母、数字或下划线,w的意思是word。例如,java\w可以匹配:

    “javac”,因为\w可以匹配英文字符c;
    “java9”,因为\w可以匹配数字字符9;。
    “java_”,因为\w可以匹配下划线_。
    它不能匹配"java#","java ",因为\w不能匹配#、空格等字符。

    匹配空格字符

    用\s可以匹配一个空格字符,注意空格字符不但包括空格,还包括tab字符(在Java中用\t表示)。例如,a\sc可以匹配:

    “a c”,因为\s可以匹配空格字符;
    “a c”,因为\s可以匹配tab字符\t。
    它不能匹配"ac","abc"等。

    匹配非数字-大写

    用\d可以匹配一个数字,而\D则匹配一个非数字。例如,00\D可以匹配:

    “00A”,因为\D可以匹配非数字字符A;
    “00#”,因为\D可以匹配非数字字符#。
    00\d可以匹配的字符串"007","008"等,00\D是不能匹配的。

    类似的,\W可以匹配\w不能匹配的字符,\S可以匹配\s不能匹配的字符,这几个正好是反着来的。

    // regex
    public class Main {
        public static void main(String[] args) {
            String re1 = "java\\d"; // 对应的正则是java\d
            System.out.println("java9".matches(re1));
            System.out.println("java10".matches(re1));
            System.out.println("javac".matches(re1));
    
            String re2 = "java\\D";
            System.out.println("javax".matches(re2));
            System.out.println("java#".matches(re2));
            System.out.println("java5".matches(re2));
        }
    }
    

    重复匹配

    我们用\d可以匹配一个数字,例如,A\d可以匹配"A0",“A1”,如果要匹配多个数字,比如"A380",怎么办?

    修饰符*可以匹配任意个字符,包括0个字符。我们用A\d*可以匹配:

    A:因为\d*可以匹配0个数字;
    A0:因为\d*可以匹配1个数字0;
    A380:因为\d*可以匹配多个数字380。
    修饰符+可以匹配至少一个字符。我们用A\d+可以匹配:

    A0:因为\d+可以匹配1个数字0;
    A380:因为\d+可以匹配多个数字380。
    但它无法匹配"A",因为修饰符+要求至少一个字符。

    修饰符?可以匹配0个或一个字符。我们用A\d?可以匹配:

    A:因为\d?可以匹配0个数字;
    A0:因为\d?可以匹配1个数字0。
    但它无法匹配"A33",因为修饰符?超过1个字符就不能匹配了。

    如果我们想精确指定n个字符怎么办?用修饰符{n}就可以。A\d{3}可以精确匹配:

    A380:因为\d{3}可以匹配3个数字380。
    如果我们想指定匹配n~m个字符怎么办?用修饰符{n,m}就可以。A\d{3,5}可以精确匹配:

    A380:因为\d{3,5}可以匹配3个数字380;
    A3800:因为\d{3,5}可以匹配4个数字3800;
    A38000:因为\d{3,5}可以匹配5个数字38000。
    如果没有上限,那么修饰符{n,}就可以匹配至少n个字符。

    复杂匹配规则

    匹配开头和结尾

    用正则表达式进行多行匹配时,我们用^表示开头,$表示结尾。例如,^A\d{3}$,可以匹配"A001""A380"

    匹配指定范围

    如果我们规定一个7~8位数字的电话号码不能以0开头,应该怎么写匹配规则呢?\d{7,8}是不行的,因为第一个\d可以匹配到0。

    使用[…]可以匹配范围内的字符,例如,[123456789]可以匹配1~9,这样就可以写出上述电话号码的规则:[123456789]\d{6,7}。

    把所有字符全列出来太麻烦,[…]还有一种写法,直接写[1-9]就可以。

    要匹配大小写不限的十六进制数,比如1A2b3c,我们可以这样写:[0-9a-fA-F],它表示一共可以匹配以下任意范围的字符:

    0-9:字符0~9;
    a-f:字符a~f;
    A-F:字符A~F。
    如果要匹配6位十六进制数,前面讲过的{n}仍然可以继续配合使用:[0-9a-fA-F]{6}。

    排除指定范围

    [...]还有一种排除法,即不包含指定范围的字符。假设我们要匹配任意字符,但不包括数字,可以写[^1-9]{3}

    可以匹配"ABC",因为不包含字符1~9;
    可以匹配"A00",因为不包含字符1~9;
    不能匹配"A01",因为包含字符1;
    不能匹配"A05",因为包含字符5。

    或规则匹配

    用|连接的两个正则规则是或规则,例如,AB|CD表示可以匹配AB或CD。

    我们来看这个正则表达式java|php:

    // regex
    public class Main {
        public static void main(String[] args) {
            String re = "java|php";
            System.out.println("java".matches(re));
            System.out.println("php".matches(re));
            System.out.println("go".matches(re));
        }
    }
    

    它可以匹配"java"或"php",但无法匹配"go"。

    要把go也加进来匹配,可以改写为java|php|go。

    使用括号-类似结合律

    现在我们想要匹配字符串learn java、learn php和learn go怎么办?一个最简单的规则是learn\sjava|learn\sphp|learn\sgo,但是这个规则太复杂了,可以把公共部分提出来,然后用(…)把子规则括起来表示成learn\s(java|php|go)。

    // regex
    public class Main {
        public static void main(String[] args) {
            String re = "learn\\s(java|php|go)";
            System.out.println("learn java".matches(re));
            System.out.println("learn Java".matches(re));
            System.out.println("learn php".matches(re));
            System.out.println("learn Go".matches(re));
        }
    }
    

    我们前面讲到的(…)可以用来把一个子规则括起来,这样写learn\s(java|php|go)就可以更方便地匹配长字符串了。

    分组匹配

    实际上(…)还有一个重要作用,就是分组匹配。

    我们来看一下如何用正则匹配区号-电话号码这个规则。利用前面讲到的匹配规则,写出来很容易:

    提取区号和电话号码

    \d{3,4}-\d{6,8}
    虽然这个正则匹配规则很简单,但是往往匹配成功后,下一步是提取区号和电话号码,分别存入数据库。于是问题来了:如何提取匹配的子串?

    当然可以用String提供的indexOf()和substring()这些方法,但它们从正则匹配的字符串中提取子串没有通用性,下一次要提取learn\s(java|php)还得改代码。

    正确的方法是用(…)先把要提取的规则分组,把上述正则表达式变为(\d{3,4})-(\d{6,8})。

    现在问题又来了:匹配后,如何按括号提取子串?

    现在我们没办法用String.matches()这样简单的判断方法了,必须引入java.util.regex包,用Pattern对象匹配,匹配后获得一个Matcher对象,如果匹配成功,就可以直接从Matcher.group(index)返回子串:

    import java.util.regex.*;
    public class Main {
        public static void main(String[] args) {
            Pattern p = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
            Matcher m = p.matcher("010-12345678");
            if (m.matches()) {
                String g1 = m.group(1);
                String g2 = m.group(2);
                System.out.println(g1);
                System.out.println(g2);
            } else {
                System.out.println("匹配失败!");
            }
        }
    }
    

    运行上述代码,会得到两个匹配上的子串010和12345678。

    要特别注意,Matcher.group(index)方法的参数用1表示第一个子串,2表示第二个子串。如果我们传入0会得到什么呢?答案是010-12345678,即整个正则匹配到的字符串。

    Pattern和Matcher

    我们在前面的代码中用到的正则表达式代码是String.matches()方法,而我们在分组提取的代码中用的是java.util.regex包里面的Pattern类和Matcher类。实际上这两种代码本质上是一样的,因为String.matches()方法内部调用的就是Pattern和Matcher类的方法。

    但是反复使用String.matches()对同一个正则表达式进行多次匹配效率较低,因为每次都会创建出一样的Pattern对象。完全可以先创建出一个Pattern对象,然后反复使用,就可以实现编译一次,多次匹配:

    import java.util.regex.*;
    public class Main {
        public static void main(String[] args) {
            Pattern pattern = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
            pattern.matcher("010-12345678").matches(); // true
            pattern.matcher("021-123456").matches(); // true
            pattern.matcher("022#1234567").matches(); // false
            // 获得Matcher对象:
            Matcher matcher = pattern.matcher("010-12345678");
            if (matcher.matches()) {
                String whole = matcher.group(0); // "010-12345678", 0表示匹配的整个字符串
                String area = matcher.group(1); // "010", 1表示匹配的第1个子串
                String tel = matcher.group(2); // "12345678", 2表示匹配的第2个子串
                System.out.println(area);
                System.out.println(tel);
            }
        }
    }
    

    使用Matcher时,必须首先调用matches()判断是否匹配成功,匹配成功后,才能调用group()提取子串。
    利用提取子串的功能,我们轻松获得了区号和号码两部分。

    非贪婪匹配

    在介绍非贪婪匹配前,我们先看一个简单的问题:

    给定一个字符串表示的数字,判断该数字末尾0的个数。例如:

    “123000”:3个0
    “10100”:2个0
    “1001”:0个0
    可以很容易地写出该正则表达式:(\d+)(0*),Java代码如下:

    import java.util.regex.*;
    public class Main {
        public static void main(String[] args) {
            Pattern pattern = Pattern.compile("(\\d+)(0*)");
            Matcher matcher = pattern.matcher("1230000");
            if (matcher.matches()) {
                System.out.println("group1=" + matcher.group(1)); // "1230000"
                System.out.println("group2=" + matcher.group(2)); // ""
            }
        }
    }
    

    然而打印的第二个子串是空字符串""。

    实际上,我们期望分组匹配结果是:

    input \d+ 0*
    123000 “123” “000”
    10100 “101” “00”
    1001 “1001” “”

    但实际的分组匹配结果是这样的:

    input \d+ 0*
    123000 “123000” “”
    10100 “10100” “”
    1001 “1001” “”

    仔细观察上述实际匹配结果,实际上它是完全合理的,因为\d+确实可以匹配后面任意个0。

    这是因为正则表达式默认使用贪婪匹配:任何一个规则,它总是尽可能多地向后匹配,因此,\d+总是会把后面的0包含进来。

    要让\d+尽量少匹配,让0*尽量多匹配,我们就必须让\d+使用非贪婪匹配。在规则\d+后面加个?即可表示非贪婪匹配。我们改写正则表达式如下:

    import java.util.regex.*;
    public class Main {
        public static void main(String[] args) {
            Pattern pattern = Pattern.compile("(\\d+?)(0*)");
            Matcher matcher = pattern.matcher("1230000");
            if (matcher.matches()) {
                System.out.println("group1=" + matcher.group(1)); // "123"
                System.out.println("group2=" + matcher.group(2)); // "0000"
            }
        }
    }
    

    因此,给定一个匹配规则,加上?后就变成了非贪婪匹配。

    我们再来看这个正则表达式(\d??)(9*),注意\d?表示匹配0个或1个数字,后面第二个?表示非贪婪匹配,因此,给定字符串"9999",匹配到的两个子串分别是"“和"9999”,因为对于\d?来说,可以匹配1个9,也可以匹配0个9,但是因为后面的?表示非贪婪匹配,它就会尽可能少的匹配,结果是匹配了0个9。

    搜索和替换

    分割字符串

    使用正则表达式分割字符串可以实现更加灵活的功能。String.split()方法传入的正是正则表达式。我们来看下面的代码:

    “a b c”.split("\s"); // { “a”, “b”, “c” }
    “a b c”.split("\s"); // { “a”, “b”, “”, “c” }
    “a, b ;; c”.split("[\,\;\s]+"); // { “a”, “b”, “c” }
    如果我们想让用户输入一组标签,然后把标签提取出来,因为用户的输入往往是不规范的,这时,使用合适的正则表达式,就可以消除多个空格、混合,和;这些不规范的输入,直接提取出规范的字符串。

    搜索字符串

    使用正则表达式还可以搜索字符串,我们来看例子:

    import java.util.regex.*;
    public class Main {
        public static void main(String[] args) {
            String s = "the quick brown fox jumps over the lazy dog.";
            Pattern p = Pattern.compile("\\wo\\w");
            Matcher m = p.matcher(s);
            while (m.find()) {
                String sub = s.substring(m.start(), m.end());
                System.out.println(sub);
            }
        }
    }
    

    我们获取到Matcher对象后,不需要调用matches()方法(因为匹配整个串肯定返回false),而是反复调用find()方法,在整个串中搜索能匹配上\wo\w规则的子串,并打印出来。这种方式比String.indexOf()要灵活得多,因为我们搜索的规则是3个字符:中间必须是o,前后两个必须是字符[A-Za-z0-9_]。

    替换字符串

    使用正则表达式替换字符串可以直接调用String.replaceAll(),它的第一个参数是正则表达式,第二个参数是待替换的字符串。我们还是来看例子:

    // regex
    public class Main {
        public static void main(String[] args) {
            String s = "The     quick\t\t brown   fox  jumps   over the  lazy dog.";
            String r = s.replaceAll("\\s+", " ");
            System.out.println(r); // "The quick brown fox jumps over the lazy dog."
        }
    }
    

    上面的代码把不规范的连续空格分隔的句子变成了规范的句子。可见,灵活使用正则表达式可以大大降低代码量。

    反向引用

    如果我们要把搜索到的指定字符串按规则替换,比如前后各加一个xxxx,这个时候,使用replaceAll()的时候,我们传入的第二个参数可以使用$1、$2来反向引用匹配到的子串。例如:

    // regex
    public class Main {
        public static void main(String[] args) {
            String s = "the quick brown fox jumps over the lazy dog.";
            String r = s.replaceAll("\\s([a-z]{4})\\s", " <b>$1</b> ");
            System.out.println(r);
        }
    }
    

    上述代码的运行结果是:

    the quick brown fox jumps <b>over</b> the <b>lazy</b> dog.
    它实际上把任何4字符单词的前后用<b>xxxx</b>括起来。实现替换的关键就在于" <b>$1</b> ",它用匹配的分组子串([a-z]{4})替换了$1
    展开全文
  • 正则表达式具体用法

    2018-10-19 13:39:30
    正则表达式的一般字符有3个 ... 转义字符(有特殊含义的字符转换成字面意思) [...] 字符集。对应字符集中任意字符             正则表达式预定...

    正则表达式的一般字符有3个

    字符

    含义

    匹配任意单个字符(不包括换行符\ n)的

    \

    转义字符(把有特殊含义的字符转换成字面意思)

    [...]

    字符集。对应字符集中的任意字符

     

     

     

     

     

     

    正则表达式预定义字符集有6个

    预定义字符集

    含义

    \ d

    匹配一个数字字符。等价于[0-9]。

    \ d

    匹配一个非数字字符。等价于[^ 0-9]。

    \ S

    匹配任何空白字符,包括空格,制表符,换页符等等。等价于[\ f \ n \ r \ t \ v]。

    \ S

    匹配任何非空白字符。等价于[^ \ f \ n \ r \ t \ v]。

    \ W

    匹配包括下划线的任何单词字符。等价于 '[A-ZA-Z0-9_]'。

    \ W

    匹配任何非单词字符。等价于'[^ A-Za-z0-9_]'。

    正则中的数量词列表

    数量词

    含义

    *

    匹配前一个字符0或无限次

    +

    匹配前一个字符1或无限次

    匹配前一个字符0或1次

    {M}

    匹配前一个字符米次

    {M,N}

    匹配前一个字符米至Ñ次

    边界匹配的关键符号

    边界匹配

    含义

    ^

    匹配字符串开头

    $

    匹配字符串结尾

    \一个

    仅匹配字符串开头

    仅匹配字符串结尾

    字符

    描述

    \

    将下一个字符标记为一个特殊字符,或一个原义字符,或一个向后引用,或一个八进制转义符。例如,n 匹配字符n \ n 匹配一个换行符。串行\\ 匹配\ \(则匹配

    ^

    匹配输入字符串的开始位置。如果设置了RegExp 对象的Multiline 属性,^ 也匹配\ n \ r 之后的位置。

    $

    匹配输入字符串的结束位置。如果设置了RegExp 对象的Multiline 属性,$ 也匹配\ n \ r 之前的位置。

    *

    匹配前面的子表达式零次或多次。例如,zo * 能匹配z 以及zoo * 等价于{0,}

    +

    匹配前面的子表达式一次或多次。例如,zo + 能匹配zo 以及zoo ,但不能匹配z + 等价于{1,}

    匹配前面的子表达式零次或一次。例如,做(es)?可以匹配中的等价于{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 *

    { nm }

    mn均为非负整数,其中n <= m。最少匹配n次且最多匹配m次。例如,o {1,3} 将匹配fooooood 中的前三个o o { 0,1} 等价于o?。请注意在逗号和两个数之间不能有空格。

    当该字符紧跟在任何一个其他限制符(*,+,?{ n } { n,} { nm } )后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串oooo o +?将匹配单个o ,而o + 将匹配所有o

    匹配除\ n之外的任何单个字符。要匹配包括\ n在内的任何字符,请使用像(。| \ n)的模式。

    (图案)

    匹配模式并获取这一匹配。所获取的匹配可以从产生的匹配集合得到,在VBScript 中使用SubMatches 集合,在JScript 中则使用$ 0 ... $ 9 属性。要匹配圆括号字符,请使用\(\)

    (?:图案)

    匹配模式但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用或字符(|)来组合一个模式的各个部分是很有用。例如industr ?:y | ies)就是一个比行业|行业更简略的表达式。

    (?=图案)

    正向肯定预查,在任何匹配模式的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如,Windows(?= 95 | 98 | NT | 2000)能匹配Windows2000 中的Windows ,但不能匹配Windows3.1 中的Windows 。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。

    (?!图案)

    正向否定预查,在任何不匹配模式的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如Windows(?!95 | 98 | NT | 2000)能匹配Windows3.1 中的Windows ,但不能匹配Windows2000 中的Windows 。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始

    (?<=图案)

    反向肯定预查,与正向肯定预查类拟,只是方向相反。例如,(?<= 95 | 98 | NT | 2000)Windows 能匹配2000Windows 中的Windows ,但不能匹配3.1Windows 中的Windows

    (?<!模式)

    反向否定预查,与正向否定预查类拟,只是方向相反。例如(?<!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

    [AZ]

    字符范围。匹配指定范围内的任意字符。例如,[az] 可以匹配a z 范围内的任意小写字母字符。

    [^ AZ]

    负值字符范围。匹配任何不在指定范围内的任意字符。例如,[^ az] 可以匹配任何不在a z 范围内的任意字符。

    \ b

    匹配一个单词边界,也就是指单词和空格间的位置。例如,er \ b 可以匹配never 中的er ,但不能匹配verb 中的

    \乙

    匹配非单词边界。er \ B 能匹配动词中的,但不能匹配never 中的

    \ CX

    匹配由X 指明的控制字符。例如,\ cM的匹配一个控制-M 或回车符。X 的值必须为AZ AZ 之一。否则,将Ç 视为一个原义的Ç 字符。

    \ 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_]

    \ n n

    匹配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的向后引用。如果前面的条件都不满足,若nm均为八进制数字(0-7 ),则\ nm将匹配八进制转义值nm

    \ nml

    如果n为八进制数字(0-3 ),且m l均为八进制数字(0-7 ),则匹配八进制转义值nm l

    ñ

    匹配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\.-]+)\.([az\.]{2,6})$/
    / ^ [az \ d ] +(\ [AZ \ d] +。)* @([\ DA-Z]( - [\ DA-Z]))+(。\ {1,2} [AZ] +)+ $ /

    网址

    /^(https?:\/\/)?([\\-z\.-]+)\.([az\.]{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]) $ /

    HTML 标签

    /^<([az]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/

    删除代码\\ 注释

    (<?HTTP:|!\ S)//.*$

    的Unicode 编码中的汉字范围

    / ^ [\ u2E80- \ u9FFF] + $ /

    展开全文
  • /*把字符串 numString ="my name is ${name},l like ${hobby}" * 根据数据 numArray = {name:"tom",hobby:"coding"} * * 转换成 theString = "my name is tom,l like coding" * */
    /*把字符串 numString ="my name is ${name},l like ${hobby}"
    * 根据数据 numArray = {name:"tom",hobby:"coding"}
    *
    * 转换成 theString = "my name is tom,l like coding"
    * */
    
    let numString = "my name is ${name},l like ${hobby}";
    let numArray = {name:"tom",hobby:"coding"};
    
    let theString = numString.replace(/\$\{(.*?)\}/g,function(numString,i){
        console.log(numString);
        console.log(k);
        return numArray[i];
    
    });
    console.log(theString);

     

    展开全文
  • JAVA: 简介:正则表达式是一套标准,它可以用于任何语言。Java标准库的java.util.regex包内置了正则表达式引擎,在Java程序中使用...对应的正则表达式就是:20\d\d,其中\d表示任意一个数字。 正则表达式转换为...

    JAVA:

    简介:正则表达式是一套标准,它可以用于任何语言。Java标准库的java.util.regex包内置了正则表达式引擎,在Java程序中使用正则表达式非常简单。

    举个例子:要判断用户输入的年份是否是20##年,我们先写出规则如下:

    一共有4个字符,分别是:200~9任意数字0~9任意数字

    对应的正则表达式就是:20\d\d,其中\d表示任意一个数字。

    把正则表达式转换为Java字符串就变成了20\\d\\d,注意Java字符串用\\表示\

    最后,用正则表达式匹配一个字符串的代码如下:

    //package zcy;
    //10.11
    import java.util.Scanner;
    import java.util.*;
    public class zcy {
      public static void main(String[] args){
        String x="20\\d\\d";
        System.out.println("2019".matches(x));//true
        System.out.println("2100".matches(x));//false
      }
    }

    一:匹配规则

    正则表达式的匹配规则是从左到右按规则匹配。我们首先来看如何使用正则表达式来做精确匹配。

    对于正则表达式abc来说,它只能精确地匹配字符串"abc",不能匹配"ab""Abc""abcd"等其他任何字符串。

    如果正则表达式有特殊字符,那就需要用\转义。例如,正则表达式a\&c,其中\&是用来匹配特殊字符&的,它能精确匹配字符串"a&c",但不能匹配"ac""a-c""a&&c"等。

    二:匹配任意字符(" . ")

    System.out.println("abc".matches("a.c"));
    System.out.println("a&c".matches("a&c"));

     二:匹配数字("\d")

     System.out.println("3879".matches("387\\d"));

     三:匹配常用字符("\w"):不能匹配‘#’和空格

        System.out.println("javac".matches("java\\w"));//true
        System.out.println("java9".matches("java\\w"));//true
        System.out.println("java_".matches("java\\w"));//true
        System.out.println("java#".matches("java\\w"));//false
        System.out.println("java ".matches("java\\w"));//false

    四:匹配空格("\s")

    System.out.println("a c".matches("a\\sc"));

    五:匹配非数字("\d")

    \d可以匹配一个数字,而\D则匹配一个非数字。

    类似的,\W可以匹配\w不能匹配的字符,\S可以匹配\s不能匹配的字符,这几个正好是反着来的。

    System.out.println("00A".matches("00\\D"));//true

    六:重复匹配("*")

     (1)修饰符*可以匹配任意个字符,包括0个字符:
        System.out.println("A".matches("A\\d*"));
        System.out.println("A0".matches("A\\d*"));
        System.out.println("A038".matches("A\\d*"));
      (2)修饰符+可以匹配至少一个字符:
        System.out.println("A".matches("A\\d+"));//false
        System.out.println("A0".matches("A\\d+"));
        System.out.println("A038".matches("A\\d+"));
      (3)修饰符?可以匹配0个或一个字符
        System.out.println("A".matches("A\\d?"));
        System.out.println("A0".matches("A\\d?"));
        System.out.println("A038".matches("A\\d?"));//false
      (4)精确匹配n个字符
        System.out.println("A380".matches("A\\d{3}"));
      (5)精确匹配n到m个字符
        System.out.println("A3800".matches("A\\d{3,5}"));
        System.out.println("A038".matches("A\\d{3,}"));//至少3个字符
    

    小结

    单个字符的匹配规则如下:

    正则表达式 规则 可以匹配
    A 指定字符 A
    \u548c 指定Unicode字符
    . 任意字符 ab&0
    \d 数字0~9 0~9
    \w 大小写字母,数字和下划线 a~zA~Z0~9_
    \s 空格、Tab键 空格,Tab
    \D 非数字 aA&_,……
    \W 非\w &@,……
    \S 非\s aA&_,……

    多个字符的匹配规则如下:

    正则表达式 规则 可以匹配
    A* 任意个数字符 空,AAAAAA,……
    A+ 至少1个字符 AAAAAA,……
    A? 0个或1个字符 空,A
    A{3} 指定个数字符 AAA
    A{2,3} 指定范围个数字符 AAAAA
    A{2,} 至少n个字符 AAAAAAAAA,……
    A{0,3} 最多n个字符 空,AAAAAA

     七:匹配开头和结尾

    用正则表达式进行多行匹配时,我们用^表示开头,$表示结尾。

    System.out.println("A380".matches("^A\\d{3}$"));

    八:匹配指定范围:使用[...]可以匹配范围内的字符

    [123456789]\d{6,7}([1-9]\d{6,7})用来匹配一个7~8位数字的电话号码不能以0开头。

    [0-9a-fA-F]匹配大小写不限的十六进制数。

    [^1-9]{3}匹配任意字符,但不包括数字。

    九:或匹配规则:用|连接的两个正则规则是规则

            String re = "java|php";
            System.out.println("java".matches(re));
            System.out.println("php".matches(re));
            System.out.println("go".matches(re));//false

    十:使用括号

    现在我们想要匹配字符串learn javalearn phplearn go怎么办?一个最简单的规则是learn\sjava|learn\sphp|learn\sgo,但是这个规则太复杂了,可以把公共部分提出来,然后用(...)把子规则括起来表示成learn\\s(java|php|go)

      String re = "learn\\s(java|php|go)";
      System.out.println("learn java".matches(re));//true
      System.out.println("learn Java".matches(re));//false
      System.out.println("learn php".matches(re));//true
      System.out.println("learn Go".matches(re));//false

    小结

    复杂匹配规则主要有:

    正则表达式 规则 可以匹配
    ^ 开头 字符串开头
    $ 结尾 字符串结束
    [ABC] […]内任意字符 A,B,C
    [A-F0-9xy] 指定范围的字符 A,……,F0,……,9xy
    [^A-F] 指定范围外的任意字符 A~F
    AB|CD|EF AB或CD或EF ABCDEF

     

    Python:

    上面的在python中也可以用,/也是转义字符,在前面加上r就可以不用考虑转义的情况了。

     

    import re
    test = 'A00'
    if re.match(r'A\d\d',test):
        print('ok')
    else:
        print('failed')

    eg:切分字符串

    用正则表达式切分字符串比用固定的字符更灵活,请看正常的切分代码:

    >>> 'a b   c'.split(' ')
    ['a', 'b', '', '', 'c']
    

    嗯,无法识别连续的空格,用正则表达式试试:

    >>> re.split(r'\s+', 'a b   c')
    ['a', 'b', 'c']
    

    无论多少个空格都可以正常分割。加入,试试:

    >>> re.split(r'[\s\,]+', 'a,b, c  d')
    ['a', 'b', 'c', 'd']
    

    再加入;试试:

    >>> re.split(r'[\s\,\;]+', 'a,b;; c  d')
    ['a', 'b', 'c', 'd']
    

    如果用户输入了一组标签,下次记得用正则表达式来把不规范的输入转化成正确的数组。

     

     

    展开全文
  • 正则表达式使用

    2020-04-15 15:51:32
    boost: 问题的提出: Boost.Regex作为Boost对正则表达式的实践,是C++开发中常用模式...思路:把字符转换成宽字符,然后再匹配。 需要用到以下和宽字符有关的类: 1、wstring: 作为STL中和string相对应的类,...
  • 在前一文章中总结了一下...看一下如何把正则表达式通过Thompson构造转换为NFA: DFA和NFA理解 一个例子: (and|any)转换为NFA“|”或者,也就是从开始分成两条路去选择。 或者:从初始状态分化两条对应字符为空
  • 1:例如“\u4E00\u9FA5”翻译为我们认识的中文 2:例如我一个txt文档是叫aaa,里面的内容是{“a”:"1:'0.95',2:'0.95'"} 我取到A就得到这个文档里对应的
  • 【转载】:Boost正则表达式汉字匹配 - 爱飞蒲公英 - 博客频道 - CSDN.NET【转载】:Boost正则表达式汉字匹配 分类: 中文处理 2009-12-03 09:41 814人阅读 评论(0) 收藏 举报思路:把字符转换成宽字符,然后再...
  • 我们知道,处于ε闭包中的任何一个状态节点时,我们可以不用输入任何字符就可以直达其他节点,因此,闭包中的所有节点其实可以等价于一个节点,这个节点就可以作为NFA对应的DFA中的一个节点。因此我们集合{ 17, 3 ...
  • 来源http://blog.csdn.net/sptoor/archive/2009/12/03/4930069.aspx思路:把字符转换成宽字符,然后再匹配。需要用到以下和宽字符有关的类:1、wstring:作为STL中和string相对应的类,专门用于处理宽字符串。方法...
  • json和 python格式的对应 字符串:字符中 数字:数字 队列:1ist 对象:dict 布尔值:布尔值 python for json: json包 json和 python对象的转换 json,.dumps():对数据编码, python格式表示成json格式 json....
  • 目录字符串替换正则表达式 本次实现是在scala中,使用replaceAll实现正则匹配,其中正则匹配替换key-value规则对应map中定义key-value值。 上一篇文章讲就是将用户传入的字符串参数按照格式分割并转换成map...
  • 字符串中有特殊字符的处理

    千次阅读 2018-11-02 11:10:23
    正则表达式进行转换处理 ...替换成html编码,解码就html编码替换成对应的字符,实现代码如下: var HtmlUtil = { /1.用正则表达式实现html转码/ htmlEncodeByRegExp:function (str){ var s = “...
  • 现在要实现一个功能,HTML中的字符实体转换成它们所对应的字符,比如:”<“转换成对对应字符为:”<“。 下面我们来看看代码实现: String.prototype.deentityfy=(function(){ var entity = { lt:'<', ...
  • 如何更改对象属性名

    千次阅读 2020-01-14 22:49:17
    先使用JSON.stringify方法对象转换成JSON格式,然后通过replace方法替换对应的属性名,可以用正则表达式来替换,/g表示全局替换该字符串 最后再通过JSON.parse方法JSON格式转换成对象格式 ...
  • 字符串同过正则匹配获取到每个表情的range, 再通过range获取元字符串中的表情字符串,如[哈哈], 在[哈哈] 和我们.plist中item下的chs字段匹配,然后获取对应的图片名,获取图片后图片转换成可变字符串的...
  • (技巧提示:空行仅包括空格符、制表符、回车符,且必须以这三个符号之一作为一行的开头,并且以回车符结尾,查找空行的关键是构造代表空行的正则表达式)。 直接在"查找"中输入正则表达式“^[ \t]*\n”,注意\t前有...
  • (技巧提示:空行仅包括空格符、制表符、回车符,且必须以这三个符号之一作为一行的开头,并且以回车符结尾,查找空行的关键是构造代表空行的正则表达式)。 直接在"查找"中输入正则表达式“^[ \t]*\n”,注意\t前有...
  • 问题的提出: Boost.Regex作为Boost对正则表达式的实践,是C++...思路:把字符转换成宽字符,然后再匹配。需要用到以下和宽字符有关的类:1、wstring:作为STL中和string相对应的类,专门用于处理宽字符串。方法...
  • 1.要求 将字符串中的字符 &、<、>...利用.replace()和正则表达式把字符 &、<、>、" (双引号), 以及 ' (单引号)转换为它们对应的 HTML 实体 3.代码 function convert(...
  • helper.rar

    2019-10-31 15:51:19
    同时还罗列了一些常用的正则表达式供开发者使用 页面取色工具 提供一个网页取色的工具,任意页面均可使用,方便大家在开发过程中能精准获取某元素的颜色值,再也不用截图后再通过Photoshop取色了 编码规范检测 对...
  • 同时还罗列了一些常用的正则表达式供开发者使用 编码规范检测 对当前网页进行Javascript、CSS、HTML编码规范的检测,包括文件是否压缩、标签是否正确闭合、cookie管理等等 页面性能检测 对当前页面的性能进行检测,...
  • Editplus 3[1].0

    2011-04-02 10:45:21
    (技巧提示:空行仅包括空格符、制表符、回车符,且必须以这三个符号之一作为一行的开头,并且以回车符结尾,查找空行的关键是构造代表空行的正则表达式)。 直接在"查找"中输入正则表达式“^[ \t]*\n”,注意\t前有...
  • EditPlus.rar +GCC

    2012-02-17 23:12:16
    (技巧提示:空行仅包括空格符、制表符、回车符,且必须以这三个符号之一作为一行的开头,并且以回车符结尾,查找空行的关键是构造代表空行的正则表达式)。 直接在"查找"中输入正则表达式“^[ \t]*\n”,注意\t前有...

空空如也

空空如也

1 2 3 4
收藏数 77
精华内容 30
关键字:

把字符转换对应的正则表达式