Regex

@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 в случае ошибок.

@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/(\w+)@(\w+).(\w+)/, "abc@def.com", fn _full, _c1, _c2, c3 -> "TLD: #{c3}" end)
"TLD: com"

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

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

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

Опции

• :return - при установке в :index, возвращает индекс байта и длину совпадения. По умолчанию :binary.
• :capture - что захватывать в результате. Проверьте модуль документации для Regex, чтобы увидеть возможные значения захвата.
• :offset - (с версии v1.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 - что захватывать в результате. Проверьте модуль документации для Regex, чтобы увидеть возможные значения захвата.
• :offset - (с версии v1.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()

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