Проверьте, является ли строка префиксом Javascript RegExp

Люди, кажется, разделяют равномерно о том, как они интерпретируют этот вопрос, таким образом, я продемонстрирую понятие с примером Java.

import java.util.regex.*;

public class Test
{

  public static void main(String[] args) throws Exception
  {
    tryMatch("^a*b+$", "a", "ab", "abc");
  }

  public static void tryMatch(String regex, String... targets)
  {
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher("");
    System.out.printf("%nregex: %s%n", regex);
    System.out.printf("target | matches() | hitEnd()%n");
    for (String str : targets)
    {
      m.reset(str);
      System.out.printf("%-6s | %-9B | %-9B%n",
          str, m.matches(), m.hitEnd());
    }
  }
}

вывод:

regex: ^a*b+$
target | matches() | hitEnd()
a      | FALSE     | TRUE
ab     | TRUE      | TRUE
abc    | FALSE     | FALSE

Целевая строка "a" не соответствует, потому что regex требует по крайней мере одного b, но это мог быть префикс успешного соответствия, таким образом, hitEnd() возвраты true. Строка "ab" имеет все, что это требуется для соответствия, но она также соответствовала бы, если бы мы добавили больше bв конец, таким образом, hitEnd() все еще возвраты true. С "abc" сбои попытки соответствия, прежде чем это достигнет конца целевой строки, таким образом, regex не мог соответствовать никакой строке, которая запускается с "abc".

Насколько я знаю, JavaScript не имеет ничего как Java hitEnd() метод, но могло бы быть возможно фальсифицировать его. Если кто-либо знает, как, случится так что Скандальная Задира, Steven Levithan.

Я думаю, что Ваш лучший выбор здесь состоит в том, чтобы сделать Ваш Regex защищенным от префикса. Для примера Вы дали, /a*b/, Я думаю, что Вы могли, вероятно, использовать /a*b?/.test(userinput). Для более сложных шаблонов это могло стать все больше трудным, но я все еще думаю, что это может быть сделано вложением каждое подвыражение в серии дополнительных кванторов (?). Например:

/a*bcd*e/

Префикс regex мог быть:

/a*(b(c(d*e?)?)?)?/

Это немного грязно, но решит Вашу проблему скорее хорошо, я думаю.

Сначала Вы определяете свое регулярное выражение как: ре var = новый RegExp (/^ (regexp здесь) $/);

на onKeypress событии Вы проверяете regexp как это:

text.match (regexp) - где текст является вводимой строкой.

Это ясно?

Очень интересный вопрос. В моем быстром поиске я ничто не нашел предопределенным (даже в Perl), который решает эту проблему.

Править: Ай, кажется, что Java имеет названный hitEnd чего-то подобного () - см. ответ M Alan. То, что делает hitEnd (), говорят, что результат соответствия () (любой TRUE или FALSE) мог бы быть изменен дополнительным входом. Книга, 'Осваивающая Регулярные выражения", говорит, что это не очень надежно хотя (не уверенный почему, страница 392, не доступная в книгах Google).

В зависимости от того, какие функции регулярных выражений Вы используете, быстрый взлом как запись своего рода префиксов Вашего regexp:

например, для a+a*b+c Ваши префиксы будут:

a+
a+a*
a+a*b+
a+a*b+c

и попытайтесь соответствовать любому из них с Вашей строкой, мог бы работать. Этот быстрый взлом сделан трудным при использовании оператора выбора при использовании оператора диапазона {n, m} или обратные ссылки.

Однако я думаю, что хорошее решение состоит в том, чтобы немного изменить алгоритм соответствия.

Алгоритм соответствия, обычно используемый, является алгоритмом отслеживания в обратном порядке (который работает хорошо на практике, даже если худшее поведение случая экспоненциально). Этот алгоритм успешно завершается каждый раз, когда он достиг конца regexp (даже если не вся строка была использована). То, что необходимо сделать, должно изменить условие завершения, таким образом, что оно также завершается успешно, когда оно использовало весь вход.

Однако необходимо было бы, вероятно, на самом деле реализовать алгоритм в JavaScript. Надо надеяться, это станет частью библиотек, таких как JQuery.

Для большего количества ссылок и теории на алгоритме, проверьте эту статью:

http://swtch.com/~rsc/regexp/regexp1.html

(даже если это излагает доводы против алгоритма отслеживания в обратном порядке и предлагает основанный на FA алгоритм (но FA не может обработать обратные ссылки)).

Один способ сделать это мог состоять в том, чтобы сцепить с onKeyUp событием текстового поля и .test текст против регулярного выражения. Мое предположение, конечно, что Вы хотите сделать соответствие регулярного выражения. Я не уверен, точно ли это, в чем Вы нуждаетесь, на самом деле Ваш код:

"a".isPrefixOf( re ); // true

никогда не будет соответствовать, так как это требуется, чтобы также иметь последующий "b" символ (можно хотеть изменить регулярное выражение). Например, этот код протестирует против любого сопоставления строк этот формат:

a-n(n)-b

Вот код, сохраните его как страницу и загрузите его в своем браузере:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="it">
<body>
    <input type="text" size="20" id="txtData" onkeyup="showResult()" />
    <div id="dvResult" />
</body>
</html>
<script type="text/javascript">
//<![CDATA[

    theRegExp = /^a\-\d{1,2}\-b$/;

    function isPrefixOf( aText, aRegExp )
    {
        return aRegExp.test( aText );
    }

    function showResult()
    {
        res = document.getElementById( "dvResult" );
        res.innerHTML = isPrefixOf( document.getElementById( "txtData" ).value, theRegExp ) ? "Correct" : "Bad input";
    }

//]]>
</script>