IT工程師數位筆記本

/*
 * 對正則表達式進行編譯，并返回Pattern實例
 * 入參flag作為表達式屬性，啟用多個表達式屬性時，采用管道符（|）連接多個表達式屬性。除了通過入參的方式設置表達式屬性，還可以使用嵌入式標識來設置表達式屬性，格式為：(?表達式屬性1表達式屬性2)正則表達式，示例——不區分大小寫和全局匹配abcd：(?ig)abcd
 */
Pattern compile(String regex);
Pattern compile(String regex, int flag);

// 字符串完整匹配表達式的快捷方式，內部依然是
// Pattern p = Pattern.compile(regex);
// p.matcher(input).matches();
boolean matches(String regex, CharSequence input);

// 返回可以配置入參s的字面量模式。注意格式為\\Q表達式\\E。表達式中的元字符將當作普通字符處理
String quote(String s);

// 以\n作為換行符，內嵌為(?d)
Pattern.UNIX_LINES

// US-ASCII編碼字符不區分大小寫，內嵌為(?i)
Pattern.CASE_INSENSITIVE

// 忽略空格和注釋（注釋為以#開頭直到出現換行符），內嵌為(?x)
Pattern.COMMENTS

// 啟動多行模式，^和$匹配換行符或字符串起始位置。默認為單行模式，^和$僅匹配字符串起始位置。內嵌為(?m)
Pattern.MULTILINE

// 字面量模式，將元字符當作普通字符處理，沒有內嵌方式，但可以通過"\\Q正則表達式\\E"的方式實現
Pattern.LITERAL

// 元字符.將匹配換行符。默認情況下，元字符.不匹配換行符。內嵌為(?s)
Pattern.DOTALL

// UNICODE編碼字符不區分大小寫，內嵌為(?u)
Pattern.UNICODE_CASE

// 當且僅當正則分解匹配時才配置成功。
Pattern.CANON_EQ

// 啟用Unicode版本的預定義字符類和POSIX字符類，內嵌為(?U)
Pattern.UNICODE_CHARACTER_CLASS

// 返回正則表達式
String pattern();

// 使用正則表達式匹配的字符串切割入參input
// 入參limit用于設置返回數組長度的最大值，設置為0時則不限制最大值。
String[] split(CharSequence input);
String[] split(CharSequence input, int limit);

// 獲取匹配類
Matcher matcher(CharSequence input);

// 將入參s中的\和$元字符轉換為普通字符，并返回處理后的s字符串。
String quoteReplacement(String s)

// 獲取匹配子字符串的起始索引
int start();
// 獲取匹配子字符串的結束索引
int end();

// 從字符串的end+1位置開始搜索下一個匹配的字符串
boolean find();
boolean find(int start);

// 通過分組索引獲取分組內容，若入參group超出分組數量則拋異常
String group();
String group(int group);
// 通過分組名稱獲取分組內容，若沒有相應的分組則返回null
String group(String name);

// 重置匹配實例內部的狀態屬性
Matacher reset();
// 重置匹配實例內部的狀態屬性，并重置被匹配的字符串
Matacher reset(CharSequence input);
// 重置模式實例，這導致group信息丟失，但注意：start等信息依舊保留不變。
Matcher usePattern(Pattern newPattern);

// 從字符串起始位開始將匹配成功的子字符串均用入參replacement替換掉
String replaceAll(String replacement);
// 從字符串起始位開始將第一個匹配成功的子字符串均用入參replacement替換掉
String replaceFirst(String replacement);
// 將從字符串起始位開始到最后一匹配的子字符串最后一個字符的位置的字符串復制到sb中，并用入參replacement替換sb中匹配的內容
String appendReplace(StringBuffer sb, String replacement);
// 將剩余的子字符串復制到sb中
String appendTail(StringBuffer sb);
// 示例: sb為one dog two dog
Matcher m = p.matcher("one cat two cats in the yard");
StringBuffer sb = new StringBuffer();
while (m.find()) {
  m.appendReplacement(sb, "dog");
}

// 字符串從頭到尾匹配表達式
boolean matches();
// 從字符串起始位置開始匹配表達式，但不要字符串從頭到尾匹配表達式
boolean lookingAt();

String replaceAll(String replacement);
String replaceFirst(String replacement);
String[] split(String regex);
String[] split(String regex, int limit);
boolean matches(String regex)

final class RegExp{
    // 全字符串匹配
    public static boolean isMatch(String regex, String input){
        if (null == input) return false;
        return input.matches(regex);
    }
    
    // 包含子字符串
    public static boolean contains(String regex, String input){
        Pattern r = Pattern.compile(regex);
        return r.matcher(input).find();
    }

    // 實現indexOf
    public static int indexOf(String regex, String input){
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        int index = -1;
        if(m.find())
            index = m.start();
        
        return index;
    }
    
    // 實現lastIndexOf
    public static int lastIndexOf(String regex, String input){
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        int index = -1;
        while(m.find())
            index = m.start();
        
        return index;
    }
    
    // 替換全部匹配字符串
    public static String replaceAll(String regex, String input, String replacement){
        if (null == regex || regex.isEmpty()) return input;
        return input.replaceAll(regex, replacement);
    }

    // 替換第N個匹配字符串
    public static String replaceSome(String regex, String input, String replacement, int n){
        if (null == regex || regex.isEmpty()) return input;
        if (0 == n) return input.replaceFirst(regex, replacement);
        
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        int i = 0;
        StringBuffer buffer = new StringBuffer();
        while (i <= n && m.find()){
            if (i == n){
                m.appendReplacement(buffer, replacement);
                m.appendTail(buffer);
            }
            ++i;
        }
        if (0 == buffer.length())
            buffer.append(input);
        
        return buffer.toString();
    }
    
    // 萃取字符串
    public static String extract(String regex, String input){
        String ret = "";
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        if (m.find())
            ret = m.group();
        
        return ret;
    }
    
    // 拆分字符串
    public static String[] split(String regex, String input, int limit){
        if (null == input || input.isEmpty() 
                || null == regex || regex.isEmpty()) return new String[]{input};
        return input.split(regex, limit);
    }
}

<div>parent     # 步驟1，((?'g'<div>).*?)匹配成功，然后向g棧壓入一個元素
<div>child      # 步驟2，((?'g'<div>).*?)匹配成功，然后向g棧壓入一個元素，現在棧含2個元素
</div>          # 步驟3，(?'-g'</div>)匹配成功，然后彈出g棧的棧頂元素，現在棧含1個元素
</div>          # 步驟4，(?'-g'</div>)匹配成功，然后彈出g棧的棧頂元素，現在棧含0個元素
                # 步驟5，由于g棧為空因此結束匹配，返回<div>parent<div>child</div></div>

console.log(RegExp('').test("12345")) // 顯示true
console.log((?:)/.test("12345")) // 顯示true
console.log(/(?=)/.test("12345")) // 顯示true
console.log(/()/.test("12345")) // 顯示true

console.log(/(?!)/.test("12345")) // 顯示false