布林「and」運算子。

提供一個短路運算子，如果第一個表達式評估為真值（既不是 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()

次方運算子。

它需要兩個數字作為輸入。如果兩者都是整數，且右邊（指數）也大於或等於 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。

此巨集傳回具有下列屬性的範圍

• 列舉時為空

• 用作 切片 時，會依原樣傳回切片元素

請參閱 ..///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)
[]

布林「not」運算子。

接收任何值（不只是布林值），如果 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 是字串，則回傳 true，如果 left 包含 right。

範例

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 (預設為 nil)，則會傳回目前 context 的繫結。

範例

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 以其 IEx.pry/0 後端取代 dbg，方法是呼叫

$ iex --dbg pry

在這種情況下，dbg 會啟動一個 pry 會話，你可以在其中與 dbg 呼叫位置的目前環境中的匯入、別名和變數進行互動。

如果你在 IEx 中於管線的結尾 (使用 |>) 呼叫 dbg，你可以透過輸入「next」(或「n」) 來逐一檢視管線的每個步驟。

請注意，dbg 僅支援管線的逐步執行 (換句話說，它只能逐步執行它看到的程式碼)。對於一般的逐步執行，你可以使用 IEx.break!/4 設定中斷點。

如需更多資訊，請參閱 IEx 文件。

設定除錯函數

dbg/2 的其中一個好處是它的除錯邏輯是可設定的，允許工具以增強的行為來延伸 dbg。例如，IEx 就會延伸 dbg，並提供一個互動式外殼，讓你可以直接檢查和存取值。

除錯函數可以在編譯時透過 :elixir 應用程式的 :dbg_callback 鍵來設定。除錯函數必須是一個 {module, function, args} 元組。module 中的 function 函數會以三個參數呼叫，這些參數會附加到 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)，或者必須在 Foo 模組中使用 alias/2 明確設定一個別名。

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