java 正则表达式 和 js正则表达式_java正则转javascript正则

        最近项目里面频繁使用到正则表达式，在这里将java正则表达式和js正则表达式都做个记录，以便日后参考。

目录

一 java正则表达式

正则规则

java字符串常用的正则方法

java常用的正则表达式

jdk的正则表达式

二 js正则表达式

正则规则

js常用的正则表达式

---

一 java正则表达式

• 正则规则

        java正则表达式须符合下面的规范，不必记住，需要用的时候随时参照就可以。

• java字符串常用的正则方法

        java字符串String里面总共有5个使用到正则的方法下面逐个测试：

        1.matches(String regex) 返回boolean

          matches(String regex)： 告诉这个字符串是否匹配给定的 regular expression          

        String reg = "abc";
        System.out.println("abc".matches(reg));

       2. replaceAll(String regex, String replacement) 返回String

          replaceAll(String regex, String replacement)  : 用给定的替换替换与给定的 regular           expression匹配的此字符串的每个子字符串

        String reg = "\\d";
        String result = "abc123edg".replaceAll(reg,"@");
        //result = abc@@@edg

       3.replaceFirst(String regex, String replacement) 返回String

          replaceFirst(String regex, String replacement): 用给定的替换替换与给定的 regular  expression匹配的此字符串的第一个子字符串。 

        String reg = "\\d";
        String result = "abc123edg".replaceFirst(reg,"@");
        System.out.println(result);
        //result = abc@23edg

       4. split(String regex) 返回 String []

          split(String regex) : 将此字符串分割为给定的 regular expression的匹配。 

        String reg = ":";
        String[] result = "boo:and:foo".split(reg);
        //result =["boo", "and", "foo" ]
        for (String str:result
             ) {
            System.out.println(str);
        }

       5.split(String regex, int limit) 返回String []

         split(String regex, int limit) : 将这个字符串拆分为给定的 regular expression的匹配。limit参     数控制应用模式的次数，因此影响生成的数组的长度。如果极限n大于0，则模式最多应用n           -1次，数组的长度不大于n ，数组的最后一个条目将包含超出最后一个匹配分隔符的所有输             入。 如果n是非正的，那么模式将被应用到尽可能多的次数，并且数组可以有任何长度。 如          果n为0，则模式将被应用尽可能多次，数组可以有任何长度，并且尾随的空字符串将被丢              弃。

        String reg = ":";
        String[] result = "boo:and:foo".split(reg,2);
        //result =["boo", "and:foo" ]
        for (String str:result
        ) {
            System.out.println(str);
        }
 
        String reg2 = ":";
        String[] result2 = "boo:and:foo".split(reg,5);
        //result =["boo", "and", "foo" ]
        for (String str:result2
        ) {
            System.out.println(str);
        }

• java常用的正则表达式

        1.\

         将下一字符标记为特殊字符序列 \\\\ 匹配 \\

        String reg = "\\\\";
        System.out.println("\\".matches(reg));//true

         2.^

         匹配输入字符串开始的位置

        String reg = "^\\d.*";
        System.out.println("2aaa".matches(reg));//true

         3.$

         匹配输入字符串结尾的位置

        String reg = "^\\d.*8$";
        System.out.println("2aaa8".matches(reg));//true

         4.*

         零次或多次匹配前面的字符或子表达式

        String reg = "aab*";
        System.out.println("aa".matches(reg));//true
        System.out.println("aab".matches(reg));//true
        System.out.println("aabbbb".matches(reg));//true

         5.+

         一次或多次匹配前面的字符或子表达式

        String reg = "aab+";
        String regMore = "a(ab)+";
        System.out.println("aab".matches(reg));//true
        System.out.println("aabbbbbb".matches(reg));//true
        System.out.println("aab".matches(regMore));//true
        System.out.println("aabab".matches(regMore));//true

         6.?

         零次或一次匹配前面的字符或子表达式

        String reg = "aab?";
        String regMore = "a(ab)?";
        System.out.println("aa".matches(reg));//true
        System.out.println("aab".matches(reg));//true
        System.out.println("aabbbbbb".matches(reg));//false
        System.out.println("aab".matches(regMore));//true
        System.out.println("aabab".matches(regMore));//false

         7.{n}

         n 是非负整数。正好匹配 n 次

        String reg = "aab{2}";
        String regMore = "aab{5}";
        System.out.println("aabb".matches(reg));//true
        System.out.println("aab".matches(reg));//false
        System.out.println("aabbbbb".matches(regMore));//true

         8.{n,}

         n 是非负整数。至少匹配 n 次

        String reg = "aab{2,}";
        String regMore = "aab{5,}";
        System.out.println("aabb".matches(reg));//true
        System.out.println("aabbb".matches(reg));//true
        System.out.println("aabbbbbbbbb".matches(regMore));//true

         9.{n,m} 

         m 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次

        String reg = "aab{2,5}";
        System.out.println("aabb".matches(reg));//true
        System.out.println("aabbbbbb".matches(reg));//false

         10..

         匹配除"\r\n"之外的任何单个字符

        String reg = "aab.";
        System.out.println("aabc".matches(reg));//true

         11.x|y

         匹配 x 或 y

        String reg = "aab(c|d)";
        System.out.println("aabc".matches(reg));//true
        System.out.println("aabd".matches(reg));//true

         12.[xyz]

         匹配包含的任一字符

        String reg = "aab[xyz]";
        System.out.println("aabx".matches(reg));//true
        System.out.println("aaby".matches(reg));//true
        System.out.println("aabz".matches(reg));//true
        System.out.println("aabd".matches(reg));//false

         13.[^xyz]

         匹配未包含的任何字符

        String reg = "aab[^xyz]";
        System.out.println("aabx".matches(reg));//false
        System.out.println("aaby".matches(reg));//false
        System.out.println("aabz".matches(reg));//false
        System.out.println("aabd".matches(reg));//true

         14.[a-z]

         匹配指定范围内的任何字符

        String reg = "aab[a-z]";
        System.out.println("aabx".matches(reg));//true
        System.out.println("aaby".matches(reg));//true
        System.out.println("aab3".matches(reg));//false
        System.out.println("aab#".matches(reg));//false

         15.[^a-z]

         匹配不在指定的范围内的任何字符

        String reg = "aab[^a-z]";
        System.out.println("aabx".matches(reg));//false
        System.out.println("aaby".matches(reg));//false
        System.out.println("aab3".matches(reg));//true
        System.out.println("aab#".matches(reg));//true

         16.\d

         数字字符匹配

        String reg = "aa\\d";
        System.out.println("aa8".matches(reg));//true
        System.out.println("aab".matches(reg));//false

         17.\D

         非数字字符匹配

        String reg = "aa\\D";
        System.out.println("aa8".matches(reg));//false
        System.out.println("aab".matches(reg));//true

         18.\s

         匹配任何空白字符

        String reg = "aa\\sc";
        System.out.println("aa c".matches(reg));//true
        System.out.println("aabc".matches(reg));//false

         19.\S

         匹配任何非空白字符

        String reg = "aa\\Sc";
        System.out.println("aa c".matches(reg));//false
        System.out.println("aabc".matches(reg));//true

         20.\w

         匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效

        String reg = "aa\\wc";
        System.out.println("aa_c".matches(reg));//true
        System.out.println("aabc".matches(reg));//true
        System.out.println("aa&c".matches(reg));//false
        System.out.println("aa c".matches(reg));//false

         21.\W

         与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效

        String reg = "aa\\Wc";
        System.out.println("aa_c".matches(reg));//false
        System.out.println("aabc".matches(reg));//false
        System.out.println("aa&c".matches(reg));//true
        System.out.println("aa c".matches(reg));//true

         22.\n

         换行符匹配

        String reg = "aa\\n";
        System.out.println("aa\n".matches(reg));//true
        System.out.println("aab".matches(reg));//false

• jdk的正则表达式

         1.java.util.regex 使用

         java.util.regex.Pattern & java.util.regex.Matcher 主要方法的使用

         compile(String regex) 将给定的正则表达式编译为模式。
         matcher(CharSequence input) 创建一个匹配器，匹配给定的输入与此模式。
         matches(String regex, CharSequence input) 编译给定的正则表达式，并尝试匹配给定的输入。 
         find() 尝试找到匹配模式的输入序列的下一个子

        String test = "dbfbbbbbbb251548796542165755hnrrrrrrrrrrrdbfbbbbbbb251548796542165756hnrrrrrrrrrrrdbfbbbbbbb251548796542165757hnrrrrrrrrrrr";
        String reg = "(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9]|X)";
 
        System.out.println(test.matches(reg));//false
        System.out.println("251548796542165755".matches(reg));//true
 
        List<String> resList = new ArrayList<>();
 
        Matcher m = Pattern.compile(reg).matcher(test);
        while(m.find()){
            System.out.println(m.group(0));
            resList.add(m.group());
        }
        System.out.println(resList);//[251548796542165755, 251548796542165756, 251548796542165757]

        Pattern.compile(reg)

        String test = "abcdefGFEIIiif";
        String reg = "[a-z]";
        List<String> resList = new ArrayList<>();
        //Pattern.compile(reg,Pattern.CASE_INSENSITIVE)启用不区分大小写的匹配。
        Matcher m = Pattern.compile(reg).matcher(test);
        while(m.find()){
            System.out.println(m.group(0));
            resList.add(m.group());
        }
        System.out.println(resList);//[a, b, c, d, e, f, i, i, f]

        Pattern.compile(reg,Pattern.CASE_INSENSITIVE) 

        String test = "abcdefGFEIIiif";
        String reg = "[a-z]";
        List<String> resList = new ArrayList<>();
        //Pattern.compile(reg,Pattern.CASE_INSENSITIVE)启用不区分大小写的匹配。
        Matcher m = Pattern.compile(reg,Pattern.CASE_INSENSITIVE).matcher(test);
        while(m.find()){
            System.out.println(m.group(0));
            resList.add(m.group());
        }
        System.out.println(resList);//[a, b, c, d, e, f, G, F, E, I, I, i, i, f]

      

  正则表达式在线测试工具

二 js正则表达式

• 正则规则

        javascript中的正则表达式和java的正则表达式基本上是相同的，
区别在于分组引用和对象，方法具体区别：
        1.javascript正则表达式创建有两种方法:
                a.显式创建：
                var re = new RegExp("正则表达式模式串");
                re.test(要校验或处理的源字符串);
                b.隐式创建：
                var re = /正则表达式模式串/;要校验或处理的源字符串.match(re);
        2.分组捕获对象引用方式不同javascript也是使用"()"进行分组，但是捕获对象用RegExp对象的$1到$99来引用捕获对象。

• js常用的正则表达式

        1.使用 test() 方法

var myString = "Hello, World!";
var reg= /Hello/;
var result = reg.test(myString);

        2.匹配多种可能性的文字字符串

var petString = "Loen has a pet cat.";
var reg= /dog|cat|bird|fish/; 
var result = reg.test(petString);

        3.全局匹配和忽略大小写

var twinkleStar = "Twinkle, twinkle, little star";
var reg = /Twinkle/gi;
var result = twinkleStar.match(reg); 

        4.使用 match() 方法提取匹配项

var extractStr = "hello world test yes yes";
var reg= /test/; 
var result = extractStr.match(reg); 

        5.匹配字母表中的字母

var quoteSample = "just do it";
var reg= /[a-z]/gi; 
var result = quoteSample.match(reg);

        6.匹配字母表中的字母和数字

var quoteSample = "I am 18 years old";
var reg= /[h-s2-6]/gi; 
var result = quoteSample.match(reg); 

        7.匹配出现一次或多次的字符

var difficultSpelling = "miss";
var reg= /s+/g;
var result = difficultSpelling.match(reg);

        8.匹配出现零次或多次的字符 

var chewieQuote = "Aaaaaaaaaaaaaaaa";
var reg= /Aa*/;
var result = chewieQuote.match(reg);

        9.用惰性匹配来查找字符

        它会匹配到满足正则表达式的字符串的最小可能部分

var text = "<h1>you are the best</h1>";
var reg= /<h*?1>/; 
var result = text.match(reg);

        10.匹配字符串的开头

var test= "you are the best.";
var reg= /^you/;
var result = test.test(reg);

        11.匹配字符串的末尾

var test= "you are the best";
var reg= /best$/;
var result = reg.test(test);

        12.匹配所有的字母和数字

var test= "you are the best 666";
var reg= /\w/g;
var result = test.match(reg);

        13.指定匹配的上限和下限

var ohStr = "Ohhh no";
var reg= /Oh{3,6}\sno/g;
var result = reg.test(ohStr);

        14.指定匹配的确切数量

var emo = "emmmmooo";
var reg= /em{4}ooo/g;
var result = reg.test(emo);

        15.检查前面的零个或一个元素

var favWord = "favorite";
var favRegex = /favou?rite/;
var result = favRegex.test(favWord);

        16.删除开头和结尾的空白    

var hello = "   Hello, World!  ";
var wsRegex = /^(\s+)(.+[^\s])(\s+)$/; 
var result = hello.replace(wsRegex,"$2"); 

        17.使用正则表达式里的括号 () 来检查字符组

var myString = "you are teh best.";
var reg= /(you|we).*best/;
var result = reg.test(myString);

        18.使用捕获组重用模式

var repeatNum = "18 18 18";
var reg = /^(\d+)\s\1\s\1$/;
var result = reg.test(repeatNum);