JavaScript RegExp

Question

我正在努力

Match 1: test(testing() tester())

Match 2: theTest()

從

test(testing() tester()) theTest()

我正在使用此RegExp

/([az]+)\\((.*)\\)/ig

但是它匹配整個字符串嗎

我認為問題出在.*但我不知道該怎么辦

如何使RegExp匹配花括號而不與內部花括號沖突

這是一個例子

編輯：由於我發現這並非完全適合尋找的東西，是否有可以完成我尋找的功能或方法？

Answer 1

有趣的問題。 是的，JavaScript regex引擎確實不能匹配最外面的平衡對匹配括號，但是可以使用以下簡單的regex模式輕松匹配最里面的平衡對：

reInnerParens

/\\([^()]*\\)/

此正則表達式可以有效地以迭代方式使用，以從內到外匹配嵌套的平衡括號。 以下有用的經過測試的函數使用此方法來確定字符串是否平衡，並且可能嵌套到任何深度並匹配括號：

function isBalancedParens(text)

function isBalancedParens(text) {
    var reInnerParens = /\([^()]*\)/g;
    // Iteratively remove balanced pairs from inside out.
    while (text.search(reInnerParens) !== -1) {
        text = text.replace(reInnerParens, '');
    }
    // Any remaining parens indicate unbalanced pairs.
    if (/[()]/.test(text)) return false;
    return true;
}

上面的函數通過從內到外迭代刪除最里面的平衡括號來工作，直到沒有更多匹配為止。 如果有任何剩余的括號，則該字符串包含不匹配的括號，並且不平衡。

可以使用類似的迭代技術來解決當前的問題。 首先，需要一個正則表達式，該表達式與平衡的一對括號匹配，該括號包含至少一對內部括號，但嵌套的深度僅為一個級別。 這是自由間距模式格式：

reOuterParens

/* reOuterParens
    # Match outer parens having inner parens one level deep.
    \(          # Outer open paren.
    (           # $1: Contents of outer parens .
      (?:       # One or more nested parens (1 deep).
        [^()]*  # Zero or more non-parens.
        \(      # Inner open paren.
        [^()]*  # Zero or more non-parens.
        \)      # Inner close paren.
      )+        # One or more nested parens (1 deep).
      [^()]*    # Zero or more non-parens.
    )           # End $1: Contents of outer parens .
    \)          # Outer close paren.
*/
var reOuterParens = /\(((?:[^()]*\([^()]*\))+[^()]*)\)/g;

以下經過測試的JavaScript函數迭代地將此正則表達式應用於“隱藏”所有內部括號作為HTML實體。 完成此操作后，僅保留所需的最外面的括號。

function getOutermostParens(text)

// Match and return all outermost "word(..(..))" patterns from string.
function getOutermostParens(text) {
    var reOuterParens = /\(((?:[^()]*\([^()]*\))+[^()]*)\)/g;
    var results = [];
    // Ensure all (possibly nested) matching parentheses are properly balanced.
    if (!isBalancedParens(text)) return null;
    text = text.replace(/&/g, '&') // Temporarily hide html entities.
    // Iteratively hide all parens nested one level deep.
    while (text.search(reOuterParens) !== -1) {
        // Hide nested parens by converting to html entities.
        text = text.replace(reOuterParens,
            function(m0, m1){
                m1 = m1.replace(/[()]/g,
                    function(n0){
                        return {'(':'(', ')': ')'}[n0];
                    });
                return '('+ m1 +')';
            });
    }
    // Match all outermost "word(...)" and load into results array.
    text.replace(/\w+\([^()]*\)/g,
        function(m0){
            m0 = m0.replace(/&#4[01];/g, // Restore hidden parens.
                function(n0){
                    return {'(': '(', ')': ')'}[n0];
                });
            // Restore temporarily hidden html entities.
            m0 = m0.replace(/&/g, '&');
            results.push(m0);
            return ''; // Not used.
        });
    return results;
}

請注意，內部的嵌套()括號字符是通過將它們替換為等效的HTML實體（即(和) ）來隱藏的，但是為了安全地執行此操作，原始字符串中可能存在的所有HTML實體必須被保護。 這可以通過用&替換所有&來完成& 在例程開始時，這些都將在例程結束時恢復。

Answer 2

為什么不只在最后一個空格上分割字符串呢？

str.split(/ (?=[^ ]*$)/);

小提琴

Answer 3

    String i = "test(testing() tester()) theTest()";

    String regex = "\\w+\\(\\w+\\(\\)\\s\\w+\\(\\)\\)|\\w+\\(\\)";
    p = Pattern.compile(regex);
    m = p.matcher(i);
    if (m.find()) {
        System.out.println(m.group());
    }

如果您的文字太多，請嘗試使用此正則表達式。

Answer 4

使用以下正則表達式：

/[a-z]+\(([a-z]+\(\) [a-z]+\(\))*\)/gi

完整代碼：

str.match(/[a-z]+\(([a-z]+\(\) [a-z]+\(\))*\)/gi);

O / P：

["test(testing() tester())", "theTest()"]