Java regexp in matcher input

Question

Я пытаюсь получить строки с кавычками, используя regexp.

String regexp = "('([^\\\\']+|\\\\([btnfr\"'\\\\]|[0-3]?[0-7]{1,2}|u[0-9a-fA-F]{4}))*'|\"([^\\\\\"]+|\\\\([btnfr\"'\\\\]|[0-3]?[0-7]{1,2}|u[0-9a-fA-F]{4}))*\")"; 
Pattern p = Pattern.compile(regexp); 
Matcher m = p.matcher(source); 
while (m.find()) { 
    String newElement = m.group(1); 
    //... 
} 

Он хорошо работает, но если исходный текст содержит

' onkeyup="this.value = this.value.replace (/\D/, \'\')">'

программа переходит в вечный цикл.

Как правильно получить эту строку?

К примеру, у меня есть текст (PHP код):

'qty'=>'<input type="text" maxlength="3" class="qty_text" id='.$key.' value =' 

Результат должен быть

'qty' 
'<input type="text" maxlength="3" class="qty_text" id=' 
' value =' 

Answer 1

Ваше регулярное выражение, похоже, работает нормально, если представлено строкой, в которой оно соответствует; это когда не может соответствовать тому, что он входит в бесконечный цикл. (В этом случае это \D, что заставляет его задохнуться.) Но это регулярное выражение намного сложнее, чем должно быть; вы пытаетесь выполнить команду , не проверяя их. Вот квинтэссенция регулярное выражение для строкового литерала в языках C-стиле:

"[^"\\\r\n]*(?:\\.[^"\\\r\n]*)*" 

... и одинарных кавычках версия, для языков, которые поддерживают этот стиль:

'[^'\\\r\n]*(?:\\.[^'\\\r\n]*)*' 

Он использует Фридл в «развернутый петля "для максимальной эффективности.Вот код Java для него, как генерируется RegexBuddy 4:

Pattern regex = Pattern.compile(
    "\"[^\"\\\\\r\n]*(?:\\\\.[^\"\\\\\r\n]*)*\"|'[^'\\\\\r\n]*(?:\\\\.[^'\\\\\r\n]*)*'" 
); 

Answer 2

Может быть, я неправильно понять принцип, но это выглядит довольно тривиально теперь, когда вы добавили пример.

Рассмотрим это, например:

String input = "'qty'=>'<input type=\"text\" maxlength=\"3\" class=\"qty_text\" id='.$key.' value ='"; 
String otherInput = "' onkeyup=\"this.value = this.value.replace (/\\D/, \'\')\">'"; 
// matching anything starting with single quote and ending with single quote 
// included, reluctant quantified 
Pattern p = Pattern.compile("'.+?'"); 
Matcher m = p.matcher(input); 
while (m.find()) { 
    System.out.println(m.group()); 
} 
m = p.matcher(otherInput); 
System.out.println(); 
while (m.find()) { 
    System.out.println(m.group()); 
} 

Выход:

'qty' 
'<input type="text" maxlength="3" class="qty_text" id=' 
' value =' 

' onkeyup="this.value = this.value.replace (/\D/, ' 
')">' 

Смотрите Java Patterndocumentation для более подробного объяснения.

Answer 3

Группы символов, которые не соответствуют ни обратной косой чертой, ни кавычкам, не должны сопровождаться +. Удалите + es, чтобы исправить зависание (которое было вызвано catastrophic backtracking).

Кроме того, ваше исходное регулярное выражение не распознало \D как допустимый обратный слэш - поэтому константа строки в тестовом входе, содержащем \D, не была сопоставлена. Если вы сделаете правила своего регулярного выражения более либеральными, чтобы распознать любого персонажа сразу после обратного слэша как части константы строки, он будет вести себя так, как вы ожидаете.

"('([^\\\\']|\\\\.)*'|\"([^\\\\\"]|\\\\.)*\")" 

Answer 4

Вы можете сделать все это в одной строке с помощью split() с правом регулярного выражения:

String[] array = source.replaceAll("^[^']+", "").split("(?<!\\G.)(?<=').*?(?='|$)"); 

Там разумное количество регулярных выражений кунг-фу здесь происходит, так что я сломаю его вниз:

• ограничитель обернут чет/нечет цитаты, но не может содержать кавычки, потому что split()истребляет разделитель, так что заглянуть за (?<=') и смотреть вперед (?=') (которые, не потребляя) используется для сопоставления кавычки вместо буквальнога цитаты в регулярном выражении
• неохотно матч .*? для символов между кавычками обеспечивают проведение что он останавливается на следующую цитате (вместо сопоставления до последней котировки)
• я добавил альтернативный матч для завершения ввода карапуза он смотреть вперед (?='|$) в случае нет задней близко котировки
• И экономить лучший для последнего , регулярное выражение, которое является ключом к тому, чтобы все это работало, - это отрицательный внешний вид (?<!\\G.), что означает «не совпадают» в конце предыдущего совпадения "и гарантирует, что следующий матч продвинется к концу предыдущего разделителя, без которого вы получите только символы кавычек в вашем массиве. \G соответствует концу предыдущего совпадения, но также соответствует началу ввода для первого совпадения, поэтому он довольно аккуратно обрабатывает не совпадение по первой кавычки - таким образом делая разделитель завернут в четную/нечетную цитату вместо нечетного/даже, как это было бы иначе.
• Для удовлетворения первого символа на входе не является котировкой, вы должны сдирать ведущие символы перед расщеплением - вот почему replaceAll() нужен

---

Вот некоторый тестовый код с помощью ввода пробы:

String source = "'qty'=>'<input type=\"text\" maxlength=\"3\" class=\"qty_text\" id='.$key.' value ='"; 
String[] array = source.replaceAll("^[^']+", "").split("(?<!\\G.)(?<=').*?(?='|$)"); 
System.out.println(Arrays.toString(array)); 

Выход:

['qty', '<input type="text" maxlength="3" class="qty_text" id=', ' value =']