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

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

Указанные опции могут быть либо двоичной строкой с символами, представляющими те же опции регулярного выражения, что и у ~r (см. sigil_r/2) сигил, либо списком опций, как ожидается модулем Erlang's :re.

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

Примеры

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

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

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

iex> Regex.compile("foo", [:caseless])
{:ok, Regex.compile!("foo", [:caseless])}

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

Компилирует регулярное выражение и генерирует исключение Regex.CompileError в случае ошибок.

@spec escape(String.t()) :: String.t()

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

Примеры

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

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

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

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

Примеры

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

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

Elixir также предоставляет текстовый оператор сопоставления =~/2 и функцию String.match?/2 в качестве альтернативы для проверки строк на соответствие регулярным выражениям и строкам.

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

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

Опции

• :return - при установке в :index, возвращает индекс байта и длину совпадения. По умолчанию :binary.

Примеры

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

@spec names(t()) :: [String.t()]

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

Примеры

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

@spec opts(t()) :: String.t() | [term()]

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

См. документацию по Regex.compile/2 для получения дополнительной информации.

Примеры

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

iex> Regex.opts(Regex.compile!("foo", [:caseless]))
[:caseless]

@spec re_pattern(t()) :: term()

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

@spec recompile(t()) :: {:ok, t()} | {:error, any()}

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

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

@spec recompile!(t()) :: t()

Перекомпилирует существующее регулярное выражение и генерирует исключение Regex.CompileError в случае ошибок.

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

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

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

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

Когда замена является функцией, функция может иметь арность 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"

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

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

Опции

• :return - при установке в :index, возвращает индекс байта и длину совпадения. По умолчанию :binary.
• :capture - что захватить в результате. Проверьте moduledoc для Regex, чтобы увидеть возможные значения захвата.
• :offset - (с версии 1.12.0) указывает начальный смещение для поиска в заданной строке. По умолчанию ноль.

Примеры

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}]

@spec scan(t(), String.t(), [term()]) :: [[String.t()]] | [[{integer(), integer()}]]

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

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

Опции

• :return - при установке в :index, возвращает индекс байта и длину совпадения. По умолчанию :binary.
• :capture - что захватить в результате. Проверьте moduledoc для Regex, чтобы увидеть возможные значения захвата.
• :offset - (с версии 1.12.0) указывает начальный смещение для поиска в заданной строке. По умолчанию ноль.

Примеры

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")
[]

iex> Regex.scan(~r/\p{Sc}/u, "$, £, and €")
[["$"], ["£"], ["€"]]

iex> Regex.scan(~r/=+/, "=ü†ƒ8===", return: :index)
[[{0, 1}], [{9, 3}]]

@spec source(t()) :: String.t()

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

Примеры

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

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

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

Параметры

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

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

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

• :include_captures - при true, включает в результат совпадения регулярного выражения. Совпадения не учитываются в максимальном количестве частей, если объединены с параметром :parts . По умолчанию 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"]

@spec version() :: term()

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