Regexp, алчность до второго матча

Question

Я не пытаюсь что-то вроде этого

^(.*)[\s]*(?:\[[\s]*(.*)[\s]*\])?$ 

Моей идеи заключается в том, что первый матч возвращает все, но время от времени второго матча, который ничего внутри []. Входящая строка для соответствия уже обрезана.

Например

'aaaaa [] [ddd]' -> returns 'aaaa []' plus 'ddd' 
'[] [ddd]' -> returns '[]' plus 'ddd' 
'aaaaaaaa' -> returns 'aaaaaaa' plus NULL 
'aaaaaaaa []' -> returns 'aaaaaaa' plus '' 
'aaaaaa [' -> returns 'aaaaaa [' plus NULL 
'aaaa [] ddd' -> returns 'aaaa [] ddd' plus NULL 
'[a] [b] [c] [d]' returns '[a] [b] [c]' plus 'd' instead of '' plus 'a] [b] [c] [d' 
'[fff]' -> return '' plus 'fff' <- That's particular since first match can never be null  

Мои основные проблемы связаны с первого матча, так как. * (Глотает все) и *? (Проглатывает только до первой], если несколько) дают нежелательный результат

псевдокод алгоритма будет что-то вроде:

• Если последний символ является «]», второй матч будет что-нибудь внутри вплоть до ближайший «[» в обратном направлении (если есть) -> это может быть пустым или «», если входной строка заканчивается «[]»
• Отдыхать первый матч, который не может быть NULL, только «»

Любые sugug Stion?

Answer 1

Если нет вложенности, вы можете использовать это регулярное выражение:

^(.*?)\s*(?:\[([^\]]*)\])?$ 

regex101 demo

В противном случае, если вы можете иметь вложенные [] в главном [], то регулярное выражение должно быть пересмотрено. Вы можете создать регулярное выражение для вложенных [], но только до определенного уровня вложенности; если у вас есть до 2 уровней гнездования, вы создаете регулярное выражение для 2, если у вас есть до 5 уровней гнездования, вы делаете более сложный для 5 и т. д.

Answer 2

Я не уверен, что понимаю, что вы хотите сделать, но, вот попытка: /(.*?)\[(.*?)\]$/.

Еще одна попытка, позволяющая второй группе оставаться неопределенной: /(.*?)(?:\[(.*?)\])?$/.

Я никогда не использовал Scriptular, но вот то, что консоли Chrome говорит:

// result : [full match, group 1, group 2] 
'abc'.match(/(.*?)(?:\[(.*?)\])?$/) // ["abc", "abc", undefined] 
'[abc]'.match(/(.*?)(?:\[(.*?)\])?$/) // ["[abc]", "", "abc"] 

Что об этом один: /(.*?)(?:\[([^\[]*?)\])?$/?

'aze[[[rty]'.match(/(.*?)(?:\[([^\[]*?)\])?$/) // ["aze[[[rty]", "aze[[", "rty"] 

Последняя попытка: /(.+?)(?:\[([^\[]*?)\])?$/.

test   result 
------------------------------------------- 
''   null 
'aze'  ["aze", "aze", undefined] 
'[rty]'  ["[rty]", "[rty]", undefined] 
'aze[rty]' ["aze[rty]", "aze", "rty"] 
'aze[]'  ["aze[]", "aze", ""] 
'aze[][rty]' ["aze[][rty]", "aze[]", "rty"] 
'aze[[]rty]' ["aze[[]rty]", "aze[", "]rty"] 

Answer 3

Я думаю, что регулярные выражения здесь не являются ответом, особенно потому, что вы даете простой алгоритм для решения проблемы. Просто переведите ваш алгоритм в код.

Также регулярные выражения не являются решением, потому что у вас несбалансированные и вложенные [], как вы указываете в своих комментариях, что делает регулярное выражение нецелесообразным.

Попробуйте JavaScript, как это:

function parse (text) { 
    var first, inside; 
    if (text.substr (-1) == ']') { 
     var pos = text.lastIndexOf ('['); 
     first = text.substr (0, pos); 
     inside = text.substr (pos + 1, text.length -pos - 1); 
    } else { 
     first = text; 
    } 
    return [ first, inside ]; 
}