Читаються регулярні вирази, не втрачаючи своєї сили?

Багато програмістів знають радість збивати швидкий регулярний вираз, в ці дні часто за допомогою якогось веб-сервісу, або, традиційно, за інтерактивного підказки, або, можливо, написання невеликого сценарію, який має регулярний вираз, що розробляється, і колекцію тестових випадків . У будь-якому випадку процес є ітераційним і досить швидким: продовжуйте злому криптовалютного рядка, поки він не збігається і не зафіксує те, що ви хочете, і відхилить те, що ви не хочете.

Для простого випадку результат може бути чимось таким, як регекс Java:

Pattern re = Pattern.compile(
  "^\\s*(?:(?:([\\d]+)\\s*:\\s*)?(?:([\\d]+)\\s*:\\s*))?([\\d]+)(?:\\s*[.,]\\s*([0-9]+))?\\s*$"
);

Багато програмістів також знають, що потрібно редагувати регулярний вираз або просто кодувати навколо регулярного виразу в застарілій базі коду. З невеликим редагуванням, щоб розділити його, вище regexp все ще дуже легко зрозуміти для всіх, хто добре знайомий з регулярними експедиціями, і ветеран regexp повинен відразу побачити, що він робить (відповісти в кінці публікації, якщо хтось захоче вправу самі розібратися).

Однак речам не потрібно набагато складніше, щоб регулярний генекп став справді єдиним для запису, і навіть при ретельному документознавстві (що, звичайно, кожен робить для всіх складних регулярних виразів, які вони пишуть ...), модифікація регулярних виразів стає складне завдання. Це може бути і дуже небезпечним завданням, якщо regexp не буде ретельно перевірений одиницею (але, звичайно, кожен має вичерпні одиничні тести для всіх своїх комплексних регулярних виразів, як позитивних, так і негативних ...).

Отже, коротке оповідання, чи є рішення / альтернатива для читання рішень / альтернативи для регулярних виразів, не втрачаючи своєї сили? Як би виглядало вищезгадане regexp з альтернативним підходом? Будь-яка мова є чудовою, хоча найкращим є багатомовне рішення, оскільки ступінь зворотного зразка є багатомовною.

І тоді, що робить більш раннє regexp, це це: проаналізувати рядок чисел у форматі 1:2:3.4, захоплюючи кожне число, де дозволено пробіли і 3потрібно лише .

Кілька людей згадували композиції з менших частин, але ніхто ще не подав приклад, тож ось моя:

string number = "(\\d+)";
string unit = "(?:" + number + "\\s*:\\s*)";
string optionalDecimal = "(?:\\s*[.,]\\s*" + number + ")?";

Pattern re = Pattern.compile(
  "^\\s*(?:" + unit + "?" + unit + ")?" + number + optionalDecimal + "\\s*$"
);

Не найчитабельніше, але я відчуваю, що це зрозуміліше, ніж оригінал.

Крім того, у C # є @оператор, який може бути заздалегідь створений до рядка, щоб вказати, що його слід приймати буквально (без символів втечі), так numberби було@"([\d]+)";

Ключовим фактором документування регулярного виразу є його документування. Занадто часто люди кидаються на те, що, здається, шумить і залишають це при цьому.

У Perl/x оператор в кінці регулярного виразу пригнічує прогалини дозволяючи документувати регулярний вираз.

Вищенаведений регулярний вираз стане тоді:

$re = qr/
  ^\s*
  (?:
    (?:       
      ([\d]+)\s*:\s*
    )?
    (?:
      ([\d]+)\s*:\s*
    )
  )?
  ([\d]+)
  (?:
    \s*[.,]\s*([\d]+)
  )?
  \s*$
/x;

Так, це трохи забирає вертикальний пробіл, хоча можна скоротити його, не приносячи великої кількості читабельності.

І тоді, що робить попередній регулярний вираз, це: проаналізувати рядок чисел у форматі 1: 2: 3.4, захоплюючи кожне число, де дозволено пробіли і потрібно лише 3.

Переглядаючи цей регулярний вираз, можна побачити, як він працює (і не працює). У цьому випадку цей регулярний вираз буде відповідати рядку 1.

Подібні підходи можна використовувати і в іншій мові. Тут працює опція python re.VERBOSE .

Perl6 (вищенаведений приклад був для perl5) продовжує це з концепцією правил, що призводить до навіть більш потужних структур, ніж PCRE (він забезпечує доступ до інших граматик (вільний від контексту та залежно від контексту), ніж просто звичайні та розширені регулярні).

У Java (звідки цей приклад черпає) можна використовувати конкатенацію рядків для формування регулярного вираження.

Pattern re = Pattern.compile(
  "^\\s*"+
  "(?:"+
    "(?:"+
      "([\\d]+)\\s*:\\s*"+  // Capture group #1
    ")?"+
    "(?:"+
      "([\\d]+)\\s*:\\s*"+  // Capture group #2
    ")"+
  ")?"+ // First groups match 0 or 1 times
  "([\\d]+)"+ // Capture group #3
  "(?:\\s*[.,]\\s*([0-9]+))?"+ // Capture group #4 (0 or 1 times)
  "\\s*$"
);

Справді, це створює ще багато "в рядку, що, можливо, призводить до певної плутанини там, може бути легше прочитати (особливо з виділенням синтаксису у більшості IDE) та задокументовано.

Ключовим є розпізнавання сили та "напишіть один раз" характер, в який регулярно впадають регулярні вирази. Написання коду з метою оборонного уникнення цього, щоб регулярний вираз залишався чітким і зрозумілим є ключовим. Ми форматуємо код Java для наочності - регулярні вирази нічим не відрізняються, коли мова дає можливість зробити це.

Режим «багатослівний», який пропонують деякі мови та бібліотеки, є однією з відповідей на ці проблеми. У цьому режимі пробіл у рядку regexp викреслений (тому потрібно використовувати \s), і коментарі можливі. Ось короткий приклад в Python, який підтримує це за замовчуванням:

email_regex = re.compile(r"""
    ([\w\.\+]+) # username (captured)
    @
    \w+         # minimal viable domain part
    (?:\.w+)    # rest of the domain, after first dot
""", re.VERBOSE)

На будь-якій мові, яка цього не робить, реалізація перекладача з багатослівного в «нормальний» режим має бути простим завданням. Якщо ви стурбовані читабельністю своїх regexps, ви, ймовірно, виправдаєте цей час інвестиції досить легко.

Кожна мова, що використовує регулярні вирази, дозволяє складати їх з більш простих блоків, щоб полегшити читання, і з чим-небудь складнішим, ніж (або настільки складним, як) ваш приклад, ви обов'язково повинні скористатися цим варіантом. Особлива проблема з Java та багатьма іншими мовами полягає в тому, що вони не трактують регулярні вирази як "першокласні" громадяни, а вимагають від них прокрастися до мови за допомогою рядкових літералів. Це означає, що багато лапок та зворотних косих ринків, які насправді не є частиною синтаксису регулярних виразів та ускладнюють їх читання, а також означає, що ви не можете отримати набагато більше читабельності, ніж це, без ефективного визначення власної міні-мови та інтерпретатора.

Прототиповим кращим способом інтеграції регулярних виразів був, звичайно, Perl, з його варіантом пробілів та операторами цитування регулярних виразів. Perl 6 розширює концепцію створення регексів з частин до фактичних рекурсивних граматик, що набагато краще використовувати, це насправді зовсім не порівняння. Мова, можливо, пропустила човен своєчасності, але його підтримка регулярного вираження була The Good Stuff (tm).

Мені подобається використовувати Expresso: http://www.ultrapico.com/Expresso.htm

Ця безкоштовна програма має такі функції, які мені здаються корисними з часом:

• Ви можете просто скопіювати і вставити ваш регулярний вираз, і програма розбере його для вас
• Щойно ваш регекс буде написаний, ви можете протестувати його безпосередньо з програми (додаток надасть вам список захоплень, замін ...)
• Після того, як ви його протестували, він генерує код C # для його реалізації (зауважте, що код буде містити пояснення щодо вашого регулярного виразу).

Наприклад, щойно ви подали регулярний вираз, він виглядатиме так:

Звичайно, спробувати варто описати це тисячу слів. Зауважте також, що я звертаю увагу на будь-який спосіб з редактором цієї програми.

Для деяких речей може допомогти просто використовувати граматику типу BNF. Вони можуть бути набагато простішими для читання, ніж регулярні вирази. Інструмент, такий як GoldParser Builder, може потім перетворити граматику в аналізатор, який робить важкий підйом для вас.

Граматики BNF, EBNF тощо можуть бути набагато простішими для читання та складання, ніж складне регулярне вираження. GOLD - це один із інструментів для таких речей.

Посилання на вікі c2 нижче міститься список можливих альтернатив, які можна гуглювати, включаючи деякі обговорення щодо них. Це в основному посилання "див. Також", щоб доповнити мою рекомендацію щодо граматики:

Альтернативи регулярним виразам

Приймаючи "альтернативу", щоб означати "семантично еквівалентний об'єкт з різним синтаксисом", існують принаймні такі альтернативи / з RegularExpressions:

• Основні регулярні вирази
• "Розширені" регулярні вирази
• Регулярні регулярні вирази, сумісні з Perl
• ... та багато інших варіантів ...
• Синтаксис RE у стилі SNOBOL (SnobolLanguage, IconLanguage)
• Синтаксис SRE (RE як EssExpressions)
• різні синтаксиси FSM
• Граматики кінцевого стану перетину (досить виразні)
• ParsingExpressionGrammars, як у OMetaLanguage та LuaLanguage ( http://www.inf.puc-rio.br/~roberto/lpeg/lpeg.html )
• Режим розбору RebolLanguage
• ЙмовірністьBaseParsing ...

Це давнє запитання, і я не бачив жодної згадки про Вербальні вирази, тому подумав, що додам цю інформацію і тут, і майбутнім шукачам. Вербальні вирази були спеціально розроблені для того, щоб зробити регулярний виразник людиною зрозумілим, не потрібно вивчати значення символу регулярного вираження. Дивіться наступний приклад. Я думаю, що це найкраще робить те, про що ви просите.

// Create an example of how to test for correctly formed URLs
var tester = VerEx()
    .startOfLine()
    .then('http')
    .maybe('s')
    .then('://')
    .maybe('www.')
    .anythingBut(' ')
    .endOfLine();

// Create an example URL
var testMe = 'https://www.google.com';

// Use RegExp object's native test() function
if (tester.test(testMe)) {
    alert('We have a correct URL '); // This output will fire}
} else {
    alert('The URL is incorrect');
}

console.log(tester); // Outputs the actual expression used: /^(http)(s)?(\:\/\/)(www\.)?([^\ ]*)$/

Цей приклад для javascript, ви можете знайти цю бібліотеку зараз для багатьох мов програмування.

Найпростішим способом було б все-таки використовувати регулярний вираз, але побудувати свій вираз із складання більш простих виразів з описовими іменами, наприклад, http://www.martinfowler.com/bliki/ComposedRegex.html (і так, це з рядкового конкомату)

проте в якості альтернативи ви також можете використати бібліотеку комбінаторів парсера, наприклад http://jparsec.codehaus.org/, яка дасть вам повний рекурсивний гідний аналізатор. знову реальна сила тут походить від композиції (цього разу функціональної композиції).

Я подумав, що варто було б згадати гроцькі вирази логсташа . Grok ґрунтується на ідеї складання довгих синтаксичних виразів із коротших. Це дозволяє зручно протестувати ці будівельні блоки та поставляється з упаковкою з понад 100 часто використовуваних моделей . Крім цих шаблонів, він дозволяє використовувати всі синтаксиси регулярних виразів.

Наведений вище шаблон, виражений у grok, (я тестував у програмі налагодження, але міг помилитися):

"(( *%{NUMBER:a} *:)? *%{NUMBER:b} *:)? *%{NUMBER:c} *(. *%{NUMBER:d} *)?"

Необов'язкові частини та пробіли здаються трохи потворнішими, ніж зазвичай, але і тут, і в інших випадках використання гроку може зробити життя кращим.

У F # у вас є модуль FsVerbalExpressions . Це дозволяє складати Regexes з вербальних виразів, у нього також є кілька попередньо вбудованих регулярних виразів (наприклад, URL).

Один із прикладів цього синтаксису:

let groupName =  "GroupNumber"

VerbEx()
|> add "COD"
|> beginCaptureNamed groupName
|> any "0-9"
|> repeatPrevious 3
|> endCapture
|> then' "END"
|> capture "COD123END" groupName
|> printfn "%s"

// 123

Якщо ви не знайомі з синтаксисом F #, groupName - це рядок "GroupNumber".

Потім вони створюють Вербальне вираження (VerbEx), яке вони конструюють як "COD (? <GroupNumber> [0-9] {3}) END". Потім вони тестують на рядок "COD123END", де отримують названу групу захоплення "GroupNumber". Це призводить до 123.

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

По-перше, зрозумійте, що код, який просто працює, - це поганий код. Хороший код також повинен точно повідомляти про виниклі помилки.

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

Тепер подумайте про свій приклад "розбору рядка чисел у форматі 1: 2: 3.4". Все, що робить регулярний вираз, - це повідомлення про "пропуск / помилку", який не дозволяє адекватному зворотному зв’язку представляти користувачеві (чи цей відгук є повідомленням про помилку в журналі або інтерактивним графічним інтерфейсом, де помилки відображаються червоним кольором як типи користувачів або що-небудь ще). Які типи помилок не вдається правильно описати? Поганий символ у першому номері, перший номер занадто великий, двокрапка після першого числа тощо.

Щоб перетворити "поганий код, який просто працює", в "хороший код, який забезпечує адекватні описові помилки", вам потрібно розбити регулярний вираз на багато менших регулярних регексів (як правило, такі маленькі регулярні вирази, що простіше зробити це без регексів в першу чергу ).

Зробити код читабельним / ремонтопридатним - лише випадковий наслідок покращення коду.