正则表达式 | Regex

雷杰克斯

为Elixir提供正则表达式。

正则表达式基于PCRE（Perl兼容正则表达式），并基于Erlang :re模块构建。更多信息可以在:re模块文档中找到。

可以使用Sigils创建elxir中的正则表达式。~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

通过Sigils创建的正则表达式被预编译并存储在.beam档案。注意，如果您正在预编译Elixir，请参阅“预编译”部分以获得更多信息，这可能是一个问题。

Regex在内部表示为Regex结构。因此，%Regex{}可以在需要匹配的时候使用。请记住，不能保证来自同一源的两个正则表达式是相等的，例如：

~r/(?<foo>.)(?<bar>.)/ == ~r/(?<foo>.)(?<bar>.)/

可能会回来true或false取决于您的计算机、endian、可用的优化以及其他。但是，您可以通过访问source字段，然后直接比较这些字段：

~r/(?<foo>.)(?<bar>.)/.source == ~r/(?<foo>.)(?<bar>.)/.source

预编译

使用sigil构建的正则表达式被预编译并存储在.beam档案。如果您正在预编译Elixir以在不同的OTP版本中运行，这可能是一个问题，因为OTP发行版可能随时更新底层正则表达式引擎。

出于这些原因，我们总是使用OTP版本预编译Elixir项目，以便在生产中运行。如果交叉编译是必要的，您可以手动调用。Regex.recompile/1或Regex. recompile!/1若要执行运行时版本检查，并在必要时重新编译regex。

修饰符

创建Regex时可用的修饰符如下：

• unicode（U） -使得像Unicode的具体模式\p和变化修饰符像\w，\W，\s和朋友也匹配Unicode的。它期望在匹配时给出有效的Unicode字符串

• caseless （i） - 增加不区分大小写

• dotall（s） - 使点匹配换行符，并将换行符设置为anycrlf; 新的生产线设置可以通过设置来覆盖(*CR)或(*LF)或(*CRLF)或(*ANY)根据重新文档

• 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)在开始处

捕捉

本模块中的许多函数通过:capture选择。所支持的值是：

• :all - 所有捕获的子模式，包括完整的匹配字符串（这是默认的）

• :first-只有第一个捕获的子模式，它始终是字符串的完全匹配部分；所有显式捕获的子模式都被丢弃

• :all_but_first-除了第一个匹配子模式，即所有显式捕获子模式，而不是字符串的完全匹配部分。

• :none-根本不返回匹配的子模式

• :all_names-捕获Regex中的所有名称

• list(binary)-要捕获的命名捕获的列表

摘要

类型

T（）

功能

编译（源码，选项\“”）

编译正则表达式

编译！（来源，选项\“”）

编译正则表达式并引发Regex.CompileError如有错误

escape（字符串）

转义字符串，以便在正则表达式中按字面匹配。

匹配？（正则表达式，字符串）

返回指示是否匹配的布尔值。

named_captures（正则表达式，字符串，选项\ []）

返回给定的捕获作为地图或nil如果没有找到捕获。选择:return可以设置为:index获取索引

名（正则表达式）

返回正则表达式中的名称列表。

OPTS（正则表达式）

以字符串的形式返回regex选项。

re_pattern（正则表达式）

返回基础re_pattern在正则表达式中

重新编译（正则表达式）

如果有必要，重新编译现有的正则表达式

重新编译！（正则表达式）

重构现有正则表达式并引发Regex.CompileError如有错误

正则表达式？（项）

返回true如果给定term是一种审判。否则返回false

替换（正则表达式，字符串，替换，选项\ []）

接收regex、二进制和替换，返回一个新的二进制，其中所有匹配项都由替换替换。

运行（正则表达式，字符串，选项\ []）

针对给定的字符串运行正则表达式，直到第一次匹配。它返回一个包含所有捕获的列表或者nil如果没有匹配发生

扫描（正则表达式，字符串，选项\ []）

同run/3，但多次扫描目标，收集正则表达式的所有匹配项。

源（正则表达式）

以二进制形式返回regex源。

split（正则表达式，字符串，选项\ []）

根据给定的模式和给定的部件数拆分给定的目标。

版（）

返回基础regex引擎的版本。

类型

T（）

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

功能

编译（源码，选项\“”）

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

编译正则表达式。

给定的选项既可以是二进制的，也可以是字符表示给定给~r如Erlang所期望的，Sgil或选项列表:re模块。

它回来了{:ok, regex}如果成功的话，{:error, reason}否则。

实例

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

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

编译！（来源，选项\“”）

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

编译正则表达式并引发Regex.CompileError万一出错。

逃生（字符串）

escape(String.t) :: String.t

将字符串转义成正则表达式中的匹配字符串。

实例

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

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

匹配？（正则表达式，字符串）

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

返回一个布尔值，指示是否匹配。

实例

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

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

named_captures（正则表达式，字符串，选项\ []）

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(t) :: [String.t]

返回正则表达式中的名称列表。

实例

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

OPTS（正则表达式）

opts(t) :: String.t

以字符串的形式返回regex选项。

实例

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

re_pattern（正则表达式）

re_pattern(t) :: term

返回基础re_pattern在正则表达式中。

重新编译（正则表达式）

recompile(t) :: t

如果有必要，重构现有的正则表达式。

这将检查存储在正则表达式中的版本，并在版本不匹配的情况下重新编译regex。

重新编译！（正则表达式）

recompile!(t) :: t

重构现有正则表达式并引发Regex.CompileError万一出错。

正则表达式？（项）

regex?(any) :: boolean

回报true如果给定term是一种审判。否则返回false...

实例

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

iex> Regex.regex?(0)
false

替换（正则表达式，字符串，替换，选项\ []）

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

接收regex、二进制和替换，返回一个新二进制，其中所有匹配都由替换替换。

替换可以是字符串或函数。该字符串被用作每个匹配的替换，并且它允许通过\N或访问特定的捕捉，捕捉在\g{N}哪里N。在使用的情况下\0，插入整个比赛。请注意，在正则表达式中，反斜杠需要被转义，因此实际上您需要使用\\N和\\g{N}。

当替换是一个函数时，该函数可能具有N，其中每个参数映射到一个捕获，第一个参数是整个匹配。如果函数期望的参数比捕获的要多，则其余的参数将收到。""...

备选方案

• :global - when false, replaces only the first occurrence (defaults to true) Examplesiex> 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}]Runs the regular expression against the given string until the first match. It returns a list with all captures or nil if no match occurred.Options

• :return-设定为:index返回索引。默认为:binary...

• :capture - 在结果中要捕获什么。检查moduledoc 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(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")
[]

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

源（正则表达式）

source(t) :: String.t

以二进制形式返回regex源。

实例

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

split（正则表达式，字符串，选项\ []）

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

版（）

返回基础Regex引擎的版本。