Regex

Предоставляет регулярные выражения для Elixir. Основано на модуле Erlang :re.

Как и модуль :re, Regex основан на PCRE (Perl Compatible Regular Expressions). Более подробную информацию можно найти в документации модуля :re.

Регулярные выражения в Elixir можно создавать с помощью Regex.compile!/2 или с использованием специальной формы с ~r или ~R:

# A simple regular expressions that matches foo anywhere in the string
~r/foo/

# A regular expression with case insensitive and Unicode options
~r/foo/iu

Regex представляется внутри как структура Regex. Поэтому, %Regex{} можно использовать всякий раз, когда требуется сопоставление с ними.

Модификаторы

Доступные модификаторы при создании Regex:

• unicode (u) - включает Unicode-специфичные шаблоны, такие как \p и изменяет модификаторы, такие как \w, \W, \s и аналогичные, чтобы они также соответствовали Unicode. Ожидает, что при сопоставлении будут предоставлены правильные строки Unicode

• caseless (i) - добавляет игнорирование регистра

• dotall (s) - заставляет точку соответствовать переходам на новую строку, а также устанавливает переходы на новую строку в любой CRLF; установка новой строки может быть переопределена путем установки (*CR) или (*LF) или (*CRLF) или (*ANY) в соответствии с документацией по re

• multiline (m) - заставляет ^ и $ отмечать начало и конец каждой строки; используйте \A и \z для соответствия концу или началу строки

• extended (x) - символы пробелов игнорируются, за исключением случаев, когда они экранированы, и позволяют # для разграничения комментариев

• firstline (f) - принуждает не-якорный шаблон к соответствию перед или на первой новой строке, хотя соответствующий текст может продолжаться через новую строку

• ungreedy (U) - инвертирует «жадность» регулярного выражения (предыдущий r параметр устарел в пользу U)

Недоступные параметры:

• anchored - недоступен, используйте ^ или \A вместо него
• dollar_endonly - недоступен, используйте \z вместо него
• no_auto_capture - недоступен, используйте ?: вместо него
• newline - недоступен, используйте (*CR) или (*LF) или (*CRLF) или (*ANYCRLF) или (*ANY) в начале регулярного выражения в соответствии с документацией модуля re

Захваты

Многие функции в этом модуле обрабатывают то, что захватывать в совпадении с регулярным выражением, через параметр :capture. Доступные значения:

• :all - все захваченные подмассивы, включая полную совпадающую строку (это значение по умолчанию)

• :first - только первый захваченный подмассив, который всегда является полным совпадающим фрагментом строки; все явно захваченные подмассивы отбрасываются

• :all_but_first - все, кроме первого совпадающего подмассива, т. е. все явно захваченные подмассивы, но не полная совпадающая часть строки

• :none - не возвращать совпадающие подмассивы вообще

• :all_names - захватывает все именованные подмассивы в Regex

• list(binary) - список именованных подмассивов для захвата

Резюме

Типы

t()

Функции

compile(source, options \\ "")

Компилирует регулярное выражение

compile!(source, options \\ "")

Компилирует регулярное выражение в соответствии с заданными параметрами. Возникает ошибка Regex.CompileError, если регулярное выражение не может быть скомпилировано

escape(string)

Экранирует строку для буквального сопоставления в регулярном выражении

match?(regex, string)

Возвращает булево значение, указывающее, было ли сопоставление или нет

named_captures(regex, string, options \\ [])

Возвращает заданные захваты в виде карты или nil , если захваты не найдены. Параметр :return может быть установлен в значение :index для получения индексов обратно

names(regex)

Возвращает список имён в регулярном выражении

opts(regex)

Возвращает параметры регулярного выражения в виде строки

re_pattern(regex)

Возвращает базовое регулярное выражение re_pattern в регулярном выражении

regex?(term)

Возвращает true , если данное term является регулярным выражением. В противном случае возвращает false

replace(regex, string, replacement, options \\ [])

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

run(regex, string, options \\ [])

Ищет в строке первое совпадение с регулярным выражением. Возвращает список всех захватов или nil , если совпадения не найдено

scan(regex, string, options \\ [])

То же, что и run/3, но выполняет поиск по целевой строке несколько раз, собирая все совпадения с регулярным выражением

source(regex)

Возвращает исходный текст регулярного выражения в виде бинарной строки

split(regex, string, options \\ [])

Разделяет заданную строку по заданному шаблону и на заданное количество частей

Типы

t()

t() :: %Regex{opts: binary, re_pattern: term, source: binary}

Функции

compile(source, options \\ "")

compile(binary, binary | [term]) :: {:ok, t} | {:error, any}

Компилирует регулярное выражение.

Указанные параметры могут быть либо бинарной строкой с символами, представляющими те же параметры регулярного выражения, которые передаются сигилу ~r, либо списком параметров, как ожидается от модуля Erlang :re.

В случае успеха возвращает {:ok, regex}, в противном случае {:error, reason}.

Примеры

iex> Regex.compile("foo")
{:ok, ~r"foo"}

iex> Regex.compile("*foo")
{:error, {'nothing to repeat', 0}}

compile!(source, options \\ "")

compile!(binary, binary | [term]) :: t

Компилирует регулярное выражение в соответствии с заданными параметрами. Вызывает ошибку Regex.CompileError, если регулярное выражение не может быть скомпилировано.

escape(string)

escape(String.t) :: String.t

Экранирует строку для буквального сопоставления в регулярном выражении.

Примеры

iex> Regex.escape(".")
"\\."

iex> Regex.escape("\\what if")
"\\\\what\\ if"

match?(regex, string)

match?(t, String.t) :: boolean

Возвращает булево значение, указывающее, было ли сопоставление или нет.

Примеры

iex> Regex.match?(~r/foo/, "foo")
true

iex> Regex.match?(~r/foo/, "bar")
false

named_captures(regex, string, options \\ [])

named_captures(t, String.t, [term]) :: map | nil

Возвращает заданные захваты в виде карты или nil , если захваты не найдены. Параметр :return может быть установлен в значение :index для получения индексов обратно.

Примеры

iex> Regex.named_captures(~r/c(?<foo>d)/, "abcd")
%{"foo" => "d"}

iex> Regex.named_captures(~r/a(?<foo>b)c(?<bar>d)/, "abcd")
%{"bar" => "d", "foo" => "b"}

iex> Regex.named_captures(~r/a(?<foo>b)c(?<bar>d)/, "efgh")
nil

names(regex)

names(t) :: [String.t]

Возвращает список имён в регулярном выражении.

Примеры

iex> Regex.names(~r/(?<foo>bar)/)
["foo"]

opts(regex)

opts(t) :: String.t

Возвращает параметры регулярного выражения в виде строки.

Примеры

iex> Regex.opts(~r(foo)m)
"m"

re_pattern(regex)

re_pattern(t) :: term

Возвращает базовое регулярное выражение re_pattern в регулярном выражении.

regex?(term)

regex?(any) :: boolean

Возвращает true , если данное term является регулярным выражением. В противном случае возвращает false.

Примеры

iex> Regex.regex?(~r/foo/)
true

iex> Regex.regex?(0)
false

replace(regex, string, replacement, options \\ [])

replace(t, String.t, String.t | (... -> String.t), [term]) :: String.t

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

Замена может быть либо строкой, либо функцией. Строка используется в качестве замены для каждого совпадения и позволяет получить доступ к определённым захватам через \\N или \g{N}, где N является захватом. В случае использования \\0, вставляется всё совпадение.

Когда замена является функцией, функция может иметь арность N, где каждый аргумент сопоставляется с захватом, а первый аргумент — это всё совпадение. Если функция ожидает больше аргументов, чем найдены захваты, оставшиеся аргументы получат "".

Параметры

• :global - если false, заменяет только первое вхождение (по умолчанию true )

Примеры

iex> Regex.replace(~r/d/, "abc", "d")
"abc"

iex> Regex.replace(~r/b/, "abc", "d")
"adc"

iex> Regex.replace(~r/b/, "abc", "[\\0]")
"a[b]c"

iex> Regex.replace(~r/a(b|d)c/, "abcadc", "[\\1]")
"[b][d]"

iex> Regex.replace(~r/\.(\d)$/, "500.5", ".\\g{1}0")
"500.50"

iex> Regex.replace(~r/a(b|d)c/, "abcadc", fn _, x -> "[#{x}]" end)
"[b][d]"

iex> Regex.replace(~r/a/, "abcadc", "A", global: false)
"Abcadc"

run(regex, string, options \\ [])

run(t, binary, [term]) ::
  nil |
  [binary] |
  [{integer, integer}]

Выполняет регулярное выражение над заданной строкой до первого совпадения. Возвращает список всех захватов или nil в случае отсутствия совпадения.

Параметры

• :return - устанавливается в :index для возврата индексов. По умолчанию :binary.
• :capture - что захватывать в результате. Обратитесь к документации модуля по адресу Regex, чтобы узнать возможные значения захватов.

Примеры

iex> Regex.run(~r/c(d)/, "abcd")
["cd", "d"]

iex> Regex.run(~r/e/, "abcd")
nil

iex> Regex.run(~r/c(d)/, "abcd", return: :index)
[{2, 2}, {3, 1}]

scan(regex, string, options \\ [])

scan(t, String.t, [term]) :: [[String.t]]

Аналогично run/3, но сканирует целевой объект несколько раз, собирая все совпадения с регулярным выражением.

Возвращается список списков, где каждый элемент в основном списке представляет совпадение, а каждый элемент во вторичном списке представляет захваченное содержимое.

Параметры

• :return - устанавливается в :index для возврата индексов. По умолчанию :binary.
• :capture - что захватывать в результате. Обратитесь к документации модуля по адресу Regex, чтобы узнать возможные значения захватов.

Примеры

iex> Regex.scan(~r/c(d|e)/, "abcd abce")
[["cd", "d"], ["ce", "e"]]

iex> Regex.scan(~r/c(?:d|e)/, "abcd abce")
[["cd"], ["ce"]]

iex> Regex.scan(~r/e/, "abcd")
[]

source(regex)

source(t) :: String.t

Возвращает исходный код регулярного выражения в двоичном формате.

Примеры

iex> Regex.source(~r(foo))
"foo"

split(regex, string, options \\ [])

split(t, String.t, [term]) :: [String.t]

Разбивает заданный целевой объект на основе заданного шаблона и на заданное количество частей.

Параметры

• :parts - при указании разбивает строку на заданное количество частей. Если не указано, :parts по умолчанию :infinity, что будет разделять строку на максимальное количество частей, возможное на основе заданного шаблона.

• :trim - при true, удаляет пустые строки ("") из результата.

• :on - определяет, на какие захваты разбить строку и в каком порядке. По умолчанию :first, что означает, что захваты внутри регулярного выражения не влияют на процесс разделения.

• :include_captures - при true, включает в результат совпадения с регулярным выражением. По умолчанию false.

Примеры

iex> Regex.split(~r/-/, "a-b-c")
["a", "b", "c"]

iex> Regex.split(~r/-/, "a-b-c", [parts: 2])
["a", "b-c"]

iex> Regex.split(~r/-/, "abc")
["abc"]

iex> Regex.split(~r//, "abc")
["a", "b", "c", ""]

iex> Regex.split(~r/a(?<second>b)c/, "abc")
["", ""]

iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second])
["a", "c"]

iex> Regex.split(~r/(x)/, "Elixir", include_captures: true)
["Eli", "x", "ir"]

iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second], include_captures: true)
["a", "b", "c"]