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

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

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

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

Примеры

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

iex> Regex.compile("*foo")
{:error, {~c"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()) :: [term()]

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

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

Примеры

iex> Regex.opts(~r/foo/m)
[:multiline]

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()), [
  {:global, boolean()}
]) :: 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 - что захватывать в результате. См. раздел "Совпадения", чтобы увидеть возможные значения захвата.
• :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}]

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

iex> Regex.run(~r/c(?<foo>d)/, "abcd", capture: ["foo", "bar"])
["d", ""]

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

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

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

Параметры

• :return - если установлено в :index, возвращает индекс байта и длину совпадения. По умолчанию :binary.
• :capture - что захватывать в результате. См. раздел "Совпадения", чтобы увидеть возможные значения захвата.
• :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/ab|bc|cd/, "abcd")
[["ab"], ["cd"]]

iex> Regex.scan(~r/ab|bc|cd/, "abbccd")
[["ab"], ["bc"], ["cd"]]

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

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

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

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

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

@spec version() :: term()

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