Поиск по регулярным выражениям

В GNU Emacs можно искать следующее совпадение для регулярного выражения (см. Синтаксис регулярных выражений) как поэтапно, так и без него. Для команд поиска с пошаговым вводом см. Поиск по регулярным выражениям в Руководстве GNU Emacs. Здесь мы описываем только функции поиска, полезные в программах. Основная из них — re-search-forward.

Эти функции поиска преобразуют регулярное выражение в многобайтовое, если буфер многобайтовый; они преобразуют регулярное выражение в однобайтовое, если буфер однобайтовый. См. Представления текста.

Команда: re-search-forward regexp &optional limit noerror count

Эта функция ищет вперёд в текущем буфере строку текста, соответствующую регулярному выражению regexp. Функция пропускает любое количество текста, не соответствующего regexp, и устанавливает точку в конце первого найденного совпадения. Она возвращает новое значение точки.

Если limit не nil, оно должно быть позицией в текущем буфере. Оно определяет верхнюю границу поиска. Совпадение, распространяющееся после этой позиции, не принимается. Если limit опущено или nil, по умолчанию оно устанавливается в конец доступной части буфера.

То, что re-search-forward делает при неудачном поиске, зависит от значения noerror:

nil

Сгенерировать ошибку search-failed.

t

Ничего не делать и вернуть nil.

в любом другом случае

Переместить точку в limit (или в конец доступной части буфера) и вернуть nil.

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

Если count является положительным числом n, поиск выполняется n раз; каждый последующий поиск начинается в конце предыдущего совпадения. Если все эти последовательные поиски успешны, функция успешно выполняется, перемещая точку и возвращая её новое значение. В противном случае вызов функции завершается неудачей с результатами, зависящими от значения noerror, как описано выше. Если count является отрицательным числом -n, поиск выполняется n раз в обратном (обратном) направлении.

В следующем примере точка изначально находится перед ‘T’. Выполнение вызова поиска перемещает точку в конец этой строки (между ‘t’ в ‘hat’ и символом новой строки).

---------- Buffer: foo ----------
I read "∗The cat in the hat
comes back" twice.
---------- Buffer: foo ----------

(re-search-forward "[a-z]+" nil t 5)
     ⇒ 27

---------- Buffer: foo ----------
I read "The cat in the hat∗
comes back" twice.
---------- Buffer: foo ----------

Команда: re-search-backward regexp &optional limit noerror count

Эта функция ищет назад в текущем буфере строку текста, соответствующую регулярному выражению regexp, оставляя точку в начале первого найденного текста.

Эта функция аналогична re-search-forward, но они не являются простым зеркальным отражением. re-search-forward находит совпадение, начало которого находится как можно ближе к начальной точке. Если бы re-search-backward была идеальным зеркальным отражением, она бы находила совпадение, конец которого был бы как можно ближе. Однако на самом деле она находит совпадение, начало которого находится как можно ближе (и при этом конец находится перед начальной точкой). Причина этого в том, что соответствие регулярному выражению в заданной точке всегда происходит слева направо и начинается в указанной начальной позиции.

Истинное зеркальное отображение re-search-forward потребовало бы специальной функции для поиска соответствия регулярным выражениям справа налево. Это не стоит усилий реализации.

Функция: string-match regexp string &optional start

Эта функция возвращает индекс начала первого совпадения регулярного выражения regexp в string или nil, если совпадения нет. Если start не nil, поиск начинается с этого индекса в string.

Например,

(string-match
 "quick" "The quick brown fox jumped quickly.")
     ⇒ 4

(string-match
 "quick" "The quick brown fox jumped quickly." 8)
     ⇒ 27

Индекс первого символа строки равен 0, индекс второго символа равен 1 и так далее.

Если эта функция находит совпадение, индекс первого символа за совпадением доступен как (match-end 0). См. Данные совпадения.

(string-match
 "quick" "The quick brown fox jumped quickly." 8)
     ⇒ 27

(match-end 0)
     ⇒ 32

Функция: string-match-p regexp string &optional start

Эта предикатная функция делает то же, что и string-match, но избегает изменения данных совпадения.

Функция: looking-at regexp

Эта функция определяет, соответствует ли текст в текущем буфере непосредственно после точки регулярному выражению regexp. «Непосредственно после» означает именно это: поиск «закреплён» и может быть успешным только с первого символа после точки. Результат — t, если это так, nil в противном случае.

Эта функция не перемещает точку, но обновляет данные совпадения. См. Данные совпадения. Если вам нужно проверить совпадение без изменения данных совпадения, используйте looking-at-p, описанную ниже.

В этом примере точка находится непосредственно перед ‘T’. Если бы она была где-то ещё, результат был бы nil.

---------- Buffer: foo ----------
I read "∗The cat in the hat
comes back" twice.
---------- Buffer: foo ----------

(looking-at "The cat in the hat$")
     ⇒ t

Функция: looking-back regexp limit &optional greedy

Эта функция возвращает t, если regexp соответствует тексту непосредственно перед точкой (т.е. заканчивается на точке), и nil в противном случае.

Поскольку соответствие регулярным выражениям работает только вперёд, это реализуется путём поиска назад от точки для совпадения, которое заканчивается на точке. Это может быть довольно медленным, если нужно искать на большом расстоянии. Вы можете ограничить время, указав ненулевое значение для limit, что означает не искать перед limit. В этом случае совпадение должно начинаться в или после limit. Вот пример:

---------- Buffer: foo ----------
I read "∗The cat in the hat
comes back" twice.
---------- Buffer: foo ----------

(looking-back "read \"" 3)
     ⇒ t
(looking-back "read \"" 4)
     ⇒ nil

Если greedy не nil, эта функция расширяет совпадение назад насколько это возможно, останавливаясь, когда один дополнительный предыдущий символ не может быть частью совпадения для regexp. При расширении совпадения его начальная позиция может находиться до limit.

В качестве общей рекомендации, старайтесь избегать использования looking-back, поскольку оно медленное. По этой причине нет планов добавить функцию looking-back-p.

Функция: looking-at-p regexp

Этот предикатная функция работает как looking-at, но без обновления данных совпадения.

Переменная: search-spaces-regexp

Если эта переменная не nil, она должна быть регулярным выражением, которое указывает, как искать пробелы. В этом случае любая группа пробелов в искомом регулярном выражении используется для использования этого регулярного выражения. Однако пробелы внутри конструкций, таких как ‘[…]’ и ‘*’, ‘+’, ‘?’, не влияют на search-spaces-regexp.

Поскольку эта переменная влияет на все конструкции поиска и соответствия регулярным выражениям, её следует временно привязывать на как можно более короткое время кода.