布尔“与”运算符。

提供一个短路运算符，仅当第一个表达式计算为真值（既不是 false 也不是 nil）时才计算和返回第二个表达式。否则返回第一个表达式。

在保护子句中不允许。

示例

iex> Enum.empty?([]) && Enum.empty?([])
true

iex> List.first([]) && true
nil

iex> Enum.empty?([]) && List.first([1])
1

iex> false && throw(:bad)
false

注意，与 and/2 不同，此运算符接受任何表达式作为第一个参数，而不仅仅是布尔值。

@spec integer() ** non_neg_integer() :: integer()

@spec integer() ** neg_integer() :: float()

@spec float() ** float() :: float()

@spec integer() ** float() :: float()

@spec float() ** integer() :: float()

幂运算符。

它接收两个数字作为输入。如果两个数字都是整数，并且右侧（exponent）也大于或等于 0，则结果也将是整数。否则，它将返回一个浮点数。

示例

iex> 2 ** 2
4
iex> 2 ** -4
0.0625

iex> 2.0 ** 2
4.0
iex> 2 ** 2.0
4.0

@spec list() ++ term() :: maybe_improper_list()

列表连接运算符。连接一个正确的列表和一个项，返回一个列表。

a ++ b 的复杂度与 length(a) 成正比，因此避免对任意长度的列表进行重复追加，例如 list ++ [element]。相反，考虑通过 [element | rest] 进行预置，然后反转。

如果 right 操作数不是一个完整的列表，它将返回一个不完整的列表。如果 left 操作数不是一个完整的列表，它将引发 ArgumentError。

由编译器内联。

示例

iex> [1] ++ [2, 3]
[1, 2, 3]

iex> ~c"foo" ++ ~c"bar"
~c"foobar"

# a non-list on the right will return an improper list
# with said element at the end
iex> [1, 2] ++ 3
[1, 2 | 3]
iex> [1, 2] ++ {3, 4}
[1, 2 | {3, 4}]

# improper list on the right will return an improper list
iex> [1] ++ [2 | 3]
[1, 2 | 3]

++/2 运算符是右结合的，这意味着

iex> [1, 2, 3] -- [1] ++ [2]
[3]

因为它等效于

iex> [1, 2, 3] -- ([1] ++ [2])
[3]

@spec list() -- list() :: list()

列表减法运算符。对右列表中的每个元素，删除左列表中第一个出现的元素。

此函数经过优化，因此 a -- b 的复杂度与 length(a) * log(length(b)) 成正比。另请参阅 Erlang 效率指南。

由编译器内联。

示例

iex> [1, 2, 3] -- [1, 2]
[3]

iex> [1, 2, 3, 2, 1] -- [1, 2, 2]
[3, 1]

--/2 运算符是右结合的，这意味着

iex> [1, 2, 3] -- [2] -- [3]
[1, 3]

因为它等效于

iex> [1, 2, 3] -- ([2] -- [3])
[1, 3]

创建完整切片范围 0..-1//1。

此宏返回具有以下属性的范围

• 枚举时，它是空的

• 当用作 slice 时，它将按原样返回切片元素

有关更多信息，请参见 ..///3 以及 Range 模块。

示例

iex> Enum.to_list(..)
[]

iex> String.slice("Hello world!", ..)
"Hello world!"

从 first 到 last 创建一个范围。

如果 first 小于 last，则范围将从 first 增加到 last。如果 first 等于 last，则范围将包含一个元素，即该数字本身。

如果 first 大于 last，则范围将从 first 减少到 last，尽管这种行为已弃用。相反，请使用 first..last//-1 明确列出步长。

有关更多信息，请参见 Range 模块。

示例

iex> 0 in 1..3
false
iex> 2 in 1..3
true

iex> Enum.to_list(1..3)
[1, 2, 3]

从 first 到 last 创建一个步长为 step 的范围。

有关更多信息，请参见 Range 模块。

示例

iex> 0 in 1..3//1
false
iex> 2 in 1..3//1
true
iex> 2 in 1..3//2
false

iex> Enum.to_list(1..3//1)
[1, 2, 3]
iex> Enum.to_list(1..3//2)
[1, 3]
iex> Enum.to_list(3..1//-1)
[3, 2, 1]
iex> Enum.to_list(1..0//1)
[]

布尔“非”运算符。

接收任何值（不仅仅是布尔值），如果 value 是 false 或 nil，则返回 true；否则返回 false。

在保护子句中不允许。

示例

iex> !Enum.empty?([])
false

iex> !List.first([])
true

二进制连接运算符。连接两个二进制文件。

如果其中一方不是二进制文件，则引发 ArgumentError。

示例

iex> "foo" <> "bar"
"foobar"

只要左侧参数是文字二进制文件，<>/2 运算符也可以用于模式匹配（以及守卫子句）。

iex> "foo" <> x = "foobar"
iex> x
"bar"

x <> "bar" = "foobar" 将导致 ArgumentError 异常。

@spec String.t() =~ (String.t() | Regex.t()) :: boolean()

基于文本的匹配运算符。将 left 上的项与 right 上的正则表达式或字符串进行匹配。

如果 right 是正则表达式，则如果 left 与 right 匹配，则返回 true。

如果 right 是字符串，则如果 left 包含 right，则返回 true。

示例

iex> "abcd" =~ ~r/c(d)/
true

iex> "abcd" =~ ~r/e/
false

iex> "abcd" =~ ~r//
true

iex> "abcd" =~ "bc"
true

iex> "abcd" =~ "ad"
false

iex> "abcd" =~ "abcd"
true

iex> "abcd" =~ ""
true

有关正则表达式的更多信息，请查看 Regex 模块。

模块属性一元运算符。

读取和写入当前模块中的属性。

属性的典型示例是注释模块实现 OTP 行为，例如 GenServer

defmodule MyServer do
  @behaviour GenServer
  # ... callbacks ...
end

默认情况下，Elixir 支持 Erlang 支持的所有模块属性，但也可以使用自定义属性。

defmodule MyServer do
  @my_data 13
  IO.inspect(@my_data)
  #=> 13
end

与 Erlang 不同，这些属性默认情况下不会存储在模块中，因为在 Elixir 中，通常使用自定义属性来存储将在编译时可用的临时数据。可以使用 Module.register_attribute/3 将自定义属性配置为更接近 Erlang 的行为。

模块属性前缀

库和框架应考虑将任何私有模块属性前缀为下划线，例如 @_my_data，以便代码完成工具不会在建议和提示中显示它们。

最后，请注意，属性也可以在函数内部读取。

defmodule MyServer do
  @my_data 11
  def first_data, do: @my_data
  @my_data 13
  def second_data, do: @my_data
end

MyServer.first_data()
#=> 11

MyServer.second_data()
#=> 13

重要的是要注意，读取属性会获取其当前值的快照。换句话说，该值是在编译时读取的，而不是在运行时读取的。有关操作模块属性的其他函数，请查看 Module 模块。

注意！同一属性的多个引用

如上所述，每次读取模块属性时，都会获取其当前值的快照。因此，如果您在模块属性中存储大量值（例如，将外部文件嵌入模块属性中），则应避免多次引用同一属性。例如，不要这样做

@files %{
  example1: File.read!("lib/example1.data"),
  example2: File.read!("lib/example2.data")
}

def example1, do: @files[:example1]
def example2, do: @files[:example2]

在上面，对 @files 的每次引用最终都可能导致整个 @files 模块属性的完整独立副本。相反，在私有函数中引用一次模块属性

@files %{
  example1: File.read!("lib/example1.data"),
  example2: File.read!("lib/example2.data")
}

defp files(), do: @files
def example1, do: files()[:example1]
def example2, do: files()[:example2]

注意！编译时依赖项

请记住，即使在模块属性中，对其他模块的引用也会生成对这些模块的编译时依赖项。

例如，考虑这种常见的模式

@values [:foo, :bar, :baz]

def handle_arg(arg) when arg in @values do
  ...
end

虽然以上内容没问题，但想象一下，如果在模块属性中实际使用的是模块名称，例如

@values [Foo, Bar, Baz]

def handle_arg(arg) when arg in @values do
  ...
end

上面的代码将对模块 Foo、Bar 和 Baz 定义编译时依赖项，这样，如果它们中的任何一个发生更改，当前模块就必须重新编译。在这种情况下，最好完全避免使用模块属性。

def handle_arg(arg) when arg in [Foo, Bar, Baz] do
  ...
end

在引号内使用时，表示给定的别名不应被卫生化。这意味着在宏扩展时将扩展该别名。

有关更多信息，请查看 quote/2。

@spec apply((... -> any()), [any()]) :: any()

使用参数列表 args 调用给定的匿名函数 fun。

如果参数数量在编译时已知，则优先使用 fun.(arg_1, arg_2, ..., arg_n)，因为它比 apply(fun, [arg_1, arg_2, ..., arg_n]) 更清晰。

由编译器内联。

示例

iex> apply(fn x -> x * 2 end, [2])
4

@spec apply(module(), function_name :: atom(), [any()]) :: any()

使用参数列表 args 调用来自 module 的给定函数。

apply/3 用于调用函数，其中模块、函数名称或参数在运行时动态定义。因此，您不能使用 apply/3 调用宏，只能调用函数。

如果参数数量和函数名称在编译时已知，则优先使用 module.function(arg_1, arg_2, ..., arg_n)，因为它比 apply(module, :function, [arg_1, arg_2, ..., arg_n]) 更清晰。

apply/3 不能用于调用私有函数。

由编译器内联。

示例

iex> apply(Enum, :reverse, [[1, 2, 3]])
[3, 2, 1]

从范围开始处的偏移量返回一个二进制文件，到范围结束处的偏移量。

如果范围的开始或结束为负数，则它们将根据二进制文件的大小转换为正索引。例如，-1 表示二进制文件的最后一个字节。

这类似于 binary_part/3，只是它使用范围，并且在守卫中不允许。

此函数使用字节。对于考虑字符的切片操作，请参见 String.slice/2。

示例

iex> binary_slice("elixir", 0..5)
"elixir"
iex> binary_slice("elixir", 1..3)
"lix"
iex> binary_slice("elixir", 1..10)
"lixir"

iex> binary_slice("elixir", -4..-1)
"ixir"
iex> binary_slice("elixir", -4..6)
"ixir"
iex> binary_slice("elixir", -10..10)
"elixir"

对于 start > stop 的范围，您需要明确地将其标记为递增。

iex> binary_slice("elixir", 2..-1//1)
"ixir"
iex> binary_slice("elixir", 1..-2//1)
"lixi"

您可以使用 ../0 作为 0..-1//1 的快捷方式，它将返回完整的二进制文件。

iex> binary_slice("elixir", ..)
"elixir"

步长可以是任何正数。例如，要获取二进制文件的每 2 个字符

iex> binary_slice("elixir", 0..-1//2)
"eii"

如果第一个位置在字符串结尾之后或在范围的最后一个位置之后，则它将返回一个空字符串。

iex> binary_slice("elixir", 10..3//1)
""
iex> binary_slice("elixir", -10..-7)
""
iex> binary_slice("a", 1..1500)
""

返回从偏移量 start 开始，大小为 size 的二进制文件。

这类似于 binary_part/3，只是如果 start + size 大于二进制文件大小，它会自动将其剪切到二进制文件大小，而不是引发异常。与 binary_part/3 相反，此函数在守卫中不允许。

此函数使用字节。对于考虑字符的切片操作，请参见 String.slice/3。

示例

iex> binary_slice("elixir", 0, 6)
"elixir"
iex> binary_slice("elixir", 0, 5)
"elixi"
iex> binary_slice("elixir", 1, 4)
"lixi"
iex> binary_slice("elixir", 0, 10)
"elixir"

如果 start 为负数，则会根据二进制文件大小进行标准化，并钳位到 0。

iex> binary_slice("elixir", -3, 10)
"xir"
iex> binary_slice("elixir", -10, 10)
"elixir"

如果 size 为零，则返回一个空二进制文件。

iex> binary_slice("elixir", 1, 0)
""

如果 start 大于或等于二进制文件大小，则返回一个空二进制文件。

iex> binary_slice("elixir", 10, 10)
""

以关键字列表的形式返回给定上下文的绑定。

在返回的结果中，键是变量名称，值是相应的变量值。

如果给定的 context 为 nil（默认情况下为），则返回当前上下文的绑定。

示例

iex> x = 1
iex> binding()
[x: 1]
iex> x = 2
iex> binding()
[x: 2]

iex> binding(:foo)
[]
iex> var!(x, :foo) = 1
1
iex> binding(:foo)
[x: 1]

调试给定的 code。

dbg/2 可用于通过可配置的调试函数调试给定的 code。它返回给定代码的结果。

示例

让我们来看一下对 dbg/2 的调用

dbg(Atom.to_string(:debugging))
#=> "debugging"

它返回字符串 "debugging"，这是 Atom.to_string/1 调用的结果。此外，上面的调用还打印以下内容

[my_file.ex:10: MyMod.my_fun/0]
Atom.to_string(:debugging) #=> "debugging"

默认的调试函数在处理管道时会打印其他调试信息。它会打印管道中每个“步骤”的值。

"Elixir is cool!"
|> String.trim_trailing("!")
|> String.split()
|> List.first()
|> dbg()
#=> "Elixir"

上面的代码打印以下内容

[my_file.ex:10: MyMod.my_fun/0]
"Elixir is cool!" #=> "Elixir is cool!"
|> String.trim_trailing("!") #=> "Elixir is cool"
|> String.split() #=> ["Elixir", "is", "cool"]
|> List.first() #=> "Elixir"

不带参数，dbg() 会调试有关当前绑定的信息。请参见 binding/1。

dbg 在 IEx 中

您可以通过调用以下内容来启用 IEx 将 dbg 替换为其 IEx.pry/0 后端

$ iex --dbg pry

在这种情况下，dbg 将启动一个 pry 会话，您可以在其中与当前环境中 dbg 调用位置的导入、别名和变量进行交互。

如果您在 IEx 中使用管道（使用 |>）在管道末尾调用 dbg，则可以通过输入“next”（或“n”）逐个执行管道的每个步骤。

请注意，dbg 只支持对管道的单步执行（换句话说，它只能单步执行它看到的代码）。对于一般单步执行，您可以使用 IEx.break!/4 设置断点。

有关更多信息，请 参阅 IEx 文档。

配置调试函数

dbg/2 的优点之一是，它的调试逻辑是可配置的，这使工具能够通过增强的行为来扩展 dbg。例如，IEx 通过交互式 shell 扩展了 dbg，您可以在其中直接检查和访问值。

调试函数可以通过 :elixir 应用程序的 :dbg_callback 键在编译时进行配置。调试函数必须是一个 {module, function, args} 元组。module 中的 function 函数将被调用，其参数为 prepended 到 args

1. code 的 AST
2. options 的 AST
3. 调用 dbg/2 的位置的 Macro.Env 环境

调试函数在编译时被调用，并且它也必须返回一个 AST。预期 AST 最终会返回调试表达式求值的結果。

这是一个简单的例子

defmodule MyMod do
  def debug_fun(code, options, caller, device) do
    quote do
      result = unquote(code)
      IO.inspect(unquote(device), result, label: unquote(Macro.to_string(code)))
    end
  end
end

要配置调试函数

# In config/config.exs
config :elixir, :dbg_callback, {MyMod, :debug_fun, [:stdio]}

默认调试函数

默认情况下，我们使用的调试函数是 Macro.dbg/3。它只是将有关代码的信息打印到标准输出并返回对 code 求值后返回的值。 options 用于控制术语的检查方式。它们是 inspect/2 接受的相同选项。

使用给定的名称和主体定义一个公有函数。

例子

defmodule Foo do
  def bar, do: :baz
end

Foo.bar()
#=> :baz

可以按如下方式定义一个期望参数的函数

defmodule Foo do
  def sum(a, b) do
    a + b
  end
end

在上面的例子中，定义了一个 sum/2 函数；该函数接收两个参数并返回它们的和。

默认参数

\\ 用于为函数参数指定默认值。例如

defmodule MyMath do
  def multiply_by(number, factor \\ 2) do
    number * factor
  end
end

MyMath.multiply_by(4, 3)
#=> 12

MyMath.multiply_by(4)
#=> 8

编译器将此转换为具有不同元数的多个函数，这里有 MyMath.multiply_by/1 和 MyMath.multiply_by/2，它们分别表示为具有默认值的参数传递或未传递参数的情况。

在定义具有默认参数和多个显式声明的子句的函数时，必须编写一个声明默认值的函数头。例如

defmodule MyString do
  def join(string1, string2 \\ nil, separator \\ " ")

  def join(string1, nil, _separator) do
    string1
  end

  def join(string1, string2, separator) do
    string1 <> separator <> string2
  end
end

请注意，\\ 不能与匿名函数一起使用，因为它们只能有一个元数。

具有默认参数的关键字列表

包含许多参数的函数可以通过使用 Keyword 列表将属性分组并作为一个值传递来获益。

defmodule MyConfiguration do
  @default_opts [storage: "local"]

  def configure(resource, opts \\ []) do
    opts = Keyword.merge(@default_opts, opts)
    storage = opts[:storage]
    # ...
  end
end

使用 Map 和 Keyword 来存储许多参数之间的区别在于 Keyword 的键

• 必须是原子
• 可以多次给出
• 按开发人员指定的顺序排列

函数名

Elixir 中的函数和变量名必须以下划线或非大写或标题大小写的 Unicode 字母开头。它们可以继续使用 Unicode 字母、数字和下划线的序列。它们可以以 ? 或 ! 结尾。Elixir 的 命名约定 建议函数和变量名以 snake_case 格式编写。

rescue/catch/after/else

函数体支持 rescue、catch、after 和 else，就像 try/1 一样（称为“隐式尝试”）。例如，以下两个函数是等效的

def convert(number) do
  try do
    String.to_integer(number)
  rescue
    e in ArgumentError -> {:error, e.message}
  end
end

def convert(number) do
  String.to_integer(number)
rescue
  e in ArgumentError -> {:error, e.message}
end

定义一个委托给另一个模块的函数。

使用 defdelegate/2 定义的函数是公开的，可以从定义它们的模块之外调用，就像使用 def/2 定义的一样。因此，defdelegate/2 是关于扩展当前模块的公共 API。如果您想在不使用完整模块名的情况下调用另一个模块中定义的函数，则可以使用 alias/2 来缩短模块名，或者使用 import/2 来完全不使用模块名就可以调用该函数。

委托仅适用于函数；不支持委托宏。

查看 def/2 以了解有关命名和默认参数的规则。

选项

• :to - 要分派的模块。

• :as - 要在 :to 中给定的目标上调用的函数。此参数是可选的，默认值为委托的名称（funs）。

例子

defmodule MyList do
  defdelegate reverse(list), to: Enum
  defdelegate other_reverse(list), to: Enum, as: :reverse
end

MyList.reverse([1, 2, 3])
#=> [3, 2, 1]

MyList.other_reverse([1, 2, 3])
#=> [3, 2, 1]

定义一个异常。

异常是通过实现 Exception 行为的模块支持的结构。 Exception 行为要求实现两个函数

• exception/1 - 接收传递给 raise/2 的参数并返回异常结构。默认实现接受一组关键字参数，这些参数将合并到结构中，或接受一个用作异常消息的字符串。

• message/1 - 接收异常结构，并且必须返回其消息。最常见的异常有一个消息字段，默认情况下通过此函数访问。但是，如果异常没有消息字段，则必须显式实现此函数。

由于异常是结构，因此 defstruct/1 支持的 API 也在 defexception/1 中可用。

引发异常

引发异常最常见的方法是通过 raise/2

defmodule MyAppError do
  defexception [:message]
end

value = [:hello]

raise MyAppError,
  message: "did not get what was expected, got: #{inspect(value)}"

在许多情况下，将预期值传递给 raise/2 并生成消息在 Exception.exception/1 回调中更为方便

defmodule MyAppError do
  defexception [:message]

  @impl true
  def exception(value) do
    msg = "did not get what was expected, got: #{inspect(value)}"
    %MyAppError{message: msg}
  end
end

raise MyAppError, value

上面的例子展示了自定义异常消息的首选策略。

@spec defguard(Macro.t()) :: Macro.t()

生成一个适合在守卫表达式中使用的宏。

如果定义使用不在保护范围内的表达式，它会在编译时引发异常，否则它会创建一个可以在保护范围内部或外部使用的宏。

请注意，Elixir 中的约定是在返回布尔值的保护符之前添加 is_ 前缀，例如 is_list/1。但是，如果函数/宏返回布尔值并且不在保护范围内，则它不应该有任何前缀，并且应该以问号结尾，例如 Keyword.keyword?/1。

例子

defmodule Integer.Guards do
  defguard is_even(value) when is_integer(value) and rem(value, 2) == 0
end

defmodule Collatz do
  @moduledoc "Tools for working with the Collatz sequence."
  import Integer.Guards

  @doc "Determines the number of steps `n` takes to reach `1`."
  # If this function never converges, please let me know what `n` you used.
  def converge(n) when n > 0, do: step(n, 0)

  defp step(1, step_count) do
    step_count
  end

  defp step(n, step_count) when is_even(n) do
    step(div(n, 2), step_count + 1)
  end

  defp step(n, step_count) do
    step(3 * n + 1, step_count + 1)
  end
end

@spec defguardp(Macro.t()) :: Macro.t()

生成一个适合在守卫表达式中使用的私有宏。

如果定义使用不在保护范围内的表达式，它会在编译时引发异常，否则它会创建一个可以在当前模块的保护范围内部或外部使用的私有宏。

与 defmacrop/2 类似，defguardp/1 必须在其在当前模块中使用之前定义。

为给定的协议定义一个实现。

有关更多信息，请参阅 Protocol 模块。

使用给定的名称和主体定义一个公有宏。

宏必须在其使用之前定义。

查看 def/2 以了解有关命名和默认参数的规则。

例子

defmodule MyLogic do
  defmacro unless(expr, opts) do
    quote do
      if !unquote(expr), unquote(opts)
    end
  end
end

require MyLogic

MyLogic.unless false do
  IO.puts("It works")
end

使用给定的名称和主体定义一个私有宏。

私有宏只能从定义它们的同一个模块访问。

私有宏必须在其使用之前定义。

查看 defmacro/2 以了解更多信息，并查看 def/2 以了解有关命名和默认参数的规则。

使用给定的名称和内容定义一个模块。

此宏使用给定的 alias 作为其名称并使用给定的内容定义一个模块。它返回一个具有四个元素的元组

• :module
• 模块名称
• 模块的二进制内容
• 求值内容块的结果

例子

defmodule Number do
  def one, do: 1
  def two, do: 2
end
#=> {:module, Number, <<70, 79, 82, ...>>, {:two, 0}}

Number.one()
#=> 1

Number.two()
#=> 2

模块名称和别名

模块名称（和别名）必须以 ASCII 大写字母开头，后面可以跟任何 ASCII 字母、数字或下划线。Elixir 的 命名约定 建议模块名称和别名以 CamelCase 格式编写。

您也可以使用原子作为模块名称，尽管它们只能包含 ASCII 字符。

嵌套

将一个模块嵌套在另一个模块中会影响嵌套模块的名称

defmodule Foo do
  defmodule Bar do
  end
end

在上面的例子中，创建了两个模块 - Foo 和 Foo.Bar。当嵌套时，Elixir 会自动为内部模块创建一个别名，允许在定义它的同一个词法范围内访问第二个模块 Foo.Bar 作为 Bar（Foo 模块）。只有在通过别名定义嵌套模块时才会发生这种情况。

如果将 Foo.Bar 模块移到其他地方，则需要将 Foo 模块中对 Bar 的引用更新为完全限定的名称（Foo.Bar），或者必须使用 alias/2 在 Foo 模块中显式设置别名。

defmodule Foo.Bar do
  # code
end

defmodule Foo do
  alias Foo.Bar
  # code here can refer to "Foo.Bar" as just "Bar"
end

动态名称

Elixir 模块名称可以动态生成。这在处理宏时非常有用。例如，可以编写

defmodule Module.concat(["Foo", "Bar"]) do
  # contents ...
end

只要传递给 defmodule/2 的第一个参数的表达式求值为原子，Elixir 就会接受任何模块名称。请注意，当使用动态名称时，Elixir 不会将名称嵌套在当前模块下，也不会自动设置别名。

保留的模块名称

如果您尝试定义一个已存在的模块，您将收到一个警告，提示模块已被重新定义。

有些模块 Elixir 目前没有实现，但可能在将来实现。这些模块是保留的，定义它们会导致编译错误。

defmodule Any do
  # code
end
** (CompileError) iex:1: module Any is reserved and cannot be defined

Elixir 保留以下模块名称：Elixir、Any、BitString、PID 和 Reference。

使当前模块中的给定定义可重写。

如果用户使用相同名称和元数定义新的函数或宏，则可覆盖的函数或宏将被丢弃。否则，将使用原始定义。

被覆盖的定义可能具有与原始定义不同的可见性：公有函数可以被私有函数覆盖，反之亦然。

宏不能被函数覆盖，反之亦然。

示例

defmodule DefaultMod do
  defmacro __using__(_opts) do
    quote do
      def test(x, y) do
        x + y
      end

      defoverridable test: 2
    end
  end
end

defmodule ChildMod do
  use DefaultMod

  def test(x, y) do
    x * y + super(x, y)
  end
end

如上面的示例所示，可以使用 super 来调用默认实现。

免责声明

谨慎使用 defoverridable。如果您需要定义多个具有相同行为的模块，最好将默认实现移到调用方，并通过 Code.ensure_loaded?/1 和 function_exported?/3 检查是否存在回调。

例如，在上面的示例中，假设有一个模块调用 test/2 函数。此模块可以这样定义：

defmodule CallsTest do
  def receives_module_and_calls_test(module, x, y) do
    if Code.ensure_loaded?(module) and function_exported?(module, :test, 2) do
      module.test(x, y)
    else
      x + y
    end
  end
end