正则表达式 知识

在开发过程中，我们经常需要对很多数据进行查找，替换，分割，过滤，验证，掌握正则表达式就显得十分重要，所谓的正则表达式其实就是一个匹配的规则，我们通过定义这个规则，来匹配符合规则的这类字符串

• 有很多测试正则表达式的工具，比如RegexBuddy，这个工具可以方便的让我们对正则表达式进行测试，测试通过后，再到程序中使用

匹配规则

• 普通字符
  字母、数字、汉字、下划线、以及没有特殊定义的标点符号，都是“普通字符”。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符
• 转义字符
  简单的各种转义字符
  \n 换行符
  \t 制表符
  \ 匹配 \
  \u unicode字符
  也可以通过 \^ ,$, (,{,+ 等等来匹配这些字符本身
• 字符集合
  \d 任意一个数字，0~9 中的任意一个
  \w 任意一个字母或数字或下划线，也就是 A~Z,a~z,0~9,_ 中任意一个
  \s 包括空格、制表符、换行符等空白字符的其中任意一个
  . 小数点可以匹配除了换行符（\n）以外的任意一个字符
  这些地方需要非常小心，往往对复杂表达式的空格及大小写把握不对都会出问题，并且你很难发现
• 自定义字符集合：[ ]方括号匹配方式，能够匹配方括号中任意一个字符
  [abc123@] 匹配 “a” 或 “b” 或”c”或 “1”或”2”或”3” 或 “@”
  [^A-Z0-9] 匹配 “A”~”Z”,”0”~”9” 之外的任意一个字符 ^这里表示非
  [\s\S][\d\D][\w\W] 匹配任意字符
  [\u4E00-\u9FA5] 匹配任意中文
• 修饰匹配次数的特殊符号
  “?” 匹配表达式0次或者1次，相当于 {0,1}
  “+” 表达式至少出现1次，相当于 {1,}
  “*” 表达式不出现或出现任意次，相当于 {0,}
  {n} 表达式重复n次
  {m,n} 表达式至少重复m次，最多重复n次
  {m,} [没有{，9}这样的写法。] 表达式至少重复m次
• 字符的边界
  ^字符 开始位置
  字符$ 结束位置
• 选择符和分组
  | 或 左右两边表达式之间 “或” 关系，匹配左边或者右边
  ( ) 子匹配 （）里面的表示式可以单独来匹配，找到的结果通过编号可以得到，从1开始，0是默认整个表达式匹配的文本内容
• 匹配模式
  • i （忽略大小写）
  • g （全文查找）
  • m （多行查找）

java中通过java.util.regex包下面的Pattern ,Matcher类操作

//任意一个数字，0~9 中的任意一个
public class TestReg {

    /**
     * 验证传入的字符串是否整个匹配正表达式
     * @param regex: 正则表达式
     * @param tarStr：要匹配的字符串
     * @return ：若匹配，则返回true;否则，返回false;
     */
    public static boolean validate(String regex, String tarStr) {
        // 表达式对象
        Pattern p = Pattern.compile(regex,Pattern.CASE_INSENSITIVE);
        // 创建 Matcher 对象
        Matcher m = p.matcher(tarStr);  
        // 是否完全匹配
        boolean yesorno = m.matches();   //该方法尝试将整个输入序列与该模式匹配
        return yesorno;
    }

    /**
     * 验证传入的字符串是否有子字符串匹配正表达式
     * @param regex: 正则表达式
     * @param tarStr：要匹配的字符串
     * @return ：若匹配，则返回true;否则，返回false;
     */
    public static boolean validate2(String regex, String tarStr) {
        // 表达式对象
        Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        // 创建 Matcher 对象
        Matcher m = p.matcher(tarStr);  
        // 是否完全匹配
        boolean yesorno = m.find();   //该方法扫描输入序列以查找与该模式匹配的下一个子序列。
        return yesorno;
    }

    /**
     * 给定字符串中是否有符合给定正则表达式的子字符串，返回匹配的第一个子字符串
     * @param regex：正则表达式
     * @param tarStr：要匹配的字符串
     * @return :返回匹配的第一个字符串，若不匹配则null
     */
    public static String search(String regex, String tarStr) {
        Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(tarStr);  
        // 是否找到匹配
        boolean found = m.find();  //该方法扫描输入序列以查找与该模式匹配的下一个子序列。
         String foundstring="";
        if(found){
            foundstring = m.group();
            String foundstring0 = m.group(0);  //group(),group(0)返回符合整个表达式的子字符串
            String foundstring1 = m.group(1);  //group(1)返回符合整个表达式的子字符串中匹配第一个表达式的子字符串
            String foundstring2 = m.group(2);   //group(2)返回符合整个表达式的子字符串中匹配第一个表达式的子字符串
//          String foundstring3 = m.group(3);
            System.out.println("foundstring:"+foundstring);
            System.out.println("foundstring0:"+foundstring0);
            System.out.println("foundstring1:"+foundstring1);
            System.out.println("foundstring2:"+foundstring2);
//          System.out.println("foundstring3:"+foundstring3);
        }
        return foundstring;
    }

    /**
     * 返回给定字符串中匹配给定正则表达式所有子字符串
     * @param regex
     * @param tarStr
     * @return List：返回所有匹配正则表达式的子字符串
     */
    public static List searchSubStr(String regex,String tarStr) {
        Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(tarStr);  
        List<String> list = new ArrayList<String>();
        while(m.find()){    //12a345b666cwer
            list.add(m.group());
        }
        for (String string : list) {
            System.out.println(string); 
        }
        return list;
    }

    /**
     * 替换给定字符串中匹配正则表达式的子字符串
     * @param regex：正则表达式
     * @param tarStr：所要匹配的字符串
     * @param replaceStr：将符合正则表达式的子串替换为该字符串
     * @return：返回替换以后新的字符串
     */
    public static String replace(String regex,String tarStr,String replaceStr) {
        Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(tarStr);
        // 替换
        String newstring = m.replaceAll(replaceStr);
        System.out.println(newstring);
        return newstring;
    }

    public static void testSplit() {
        String str = "abc5Adefghi7Ajklmn";
        // 分割
        String [] strs = str.split("(\\d)A");
        for(int i=0;i<strs.length;i++) {
            System.out.println(strs[i]);
        }
    }   
    public static void main(String[] args) {
        replace("\\d", "dsfd;sa;ksd12a34b567c890d888e999f","*");
//      System.out.println(validate("\\d+", "334455aaa"));
//      System.out.println(validate2("\\d+", "334455aaa"));
//      System.out.println(searchSubStr("(\\d+)([a-z]+)", "334455aaa--3232423aaa-32324bbb")); 
        testSplit();
    }
}

JAVASCRIPT中使用正则表达式

var re1=new RegExp("\\d{7}","ig");
var re2 = /\d{7}/ig;

常用的一些方法
test( ) 返回一个布尔值，是否找到
exec( ) 返回的是一个数组。该数组包含了匹配该模式的第一个子字符串以及该子字符串中匹配相关分组的字符串
match( ) ,search( ),split( ),replace( )

var reg=/^[\u4E00-\u9FA5a-zA-z]+$/;
var r=deName.match(reg);
if(r==null)
{                 document.getElementById("domDeNameError").innerHTML = "名称  必须是字母，'-'线，或数字！！";
}