-spec abs(Float) -> float() when Float :: float();
         (Int) -> non_neg_integer() when Int :: integer().

傳回一個整數或浮點數，該整數或浮點數是 Float 或 Int 的算術絕對值。

例如

> abs(-3.33).
3.33
> abs(-3).
3

-spec append_element(Tuple1, Term) -> Tuple2 when Tuple1 :: tuple(), Tuple2 :: tuple(), Term :: term().

傳回一個新的元組，該元組比 Tuple1 多一個元素，並且包含 Tuple1 中的元素，後面接著 Term 作為最後一個元素。

語義上等效於 list_to_tuple(tuple_to_list(Tuple1) ++ [Term])，但速度快得多。

例如

> erlang:append_element({one, two}, three).
{one,two,three}

-spec atom_to_binary(Atom) -> binary() when Atom :: atom().

等效於 atom_to_binary(Atom, utf8)。

-spec atom_to_binary(Atom, Encoding) -> binary()
                        when Atom :: atom(), Encoding :: latin1 | unicode | utf8.

傳回對應於 Atom 的文字表示形式的二進位。

如果 Encoding 是 latin1，則文字表示中的每個字元會佔用一個位元組。如果 Encoding 是 utf8 或 unicode，則字元會使用 UTF-8 編碼，其中字元可能需要多個位元組。

變更

從 Erlang/OTP 20 開始，原子 (atom) 可以包含任何 Unicode 字元，並且如果 Atom 的文字表示包含 Unicode 字元 > 255，則 atom_to_binary(Atom, latin1) 可能會失敗。

範例

> atom_to_binary('Erlang', latin1).
<<"Erlang">>

-spec atom_to_list(Atom) -> string() when Atom :: atom().

傳回對應於 Atom 的文字表示形式的 Unicode 程式碼點清單。

例如

> atom_to_list('Erlang').
"Erlang"

> atom_to_list('你好').
[20320,22909]

關於如何將產生的列表轉換為不同的格式，請參閱 unicode。

-spec binary_part(Subject, PosLen) -> binary()
                     when
                         Subject :: binary(),
                         PosLen :: {Start :: non_neg_integer(), Length :: integer()}.

提取由 PosLen 描述的二進位部分。

可以使用負數長度來提取二進制資料末尾的位元組。

例如

1> Bin = <<1,2,3,4,5,6,7,8,9,10>>.
2> binary_part(Bin,{byte_size(Bin), -5}).
<<6,7,8,9,10>>

失敗：如果 PosLen 以任何方式參考到二進制資料外部，則會發生 badarg 錯誤。

Start 是從零開始的索引，也就是說

1> Bin = <<1,2,3>>
2> binary_part(Bin,{0,2}).
<<1,2>>

關於 PosLen 語意的詳細資訊，請參閱 binary。

-spec binary_part(Subject, Start, Length) -> binary()
                     when Subject :: binary(), Start :: non_neg_integer(), Length :: integer().

等效於 binary_part(Subject, {Start, Length})。

-spec binary_to_atom(Binary) -> atom() when Binary :: binary().

等效於 binary_to_atom(Binary, utf8)。

-spec binary_to_atom(Binary, Encoding) -> atom()
                        when Binary :: binary(), Encoding :: latin1 | unicode | utf8.

傳回文字表示形式為 Binary 的原子。如果 Encoding 為 utf8 或 unicode，則二進位必須包含有效的 UTF-8 序列。

變更

從 Erlang/OTP 20 開始，binary_to_atom(Binary, utf8) 能夠解碼任何 Unicode 字元。較早的版本如果二進制資料包含 Unicode 字元 > 255，則會失敗。

注意

原子名稱中允許的字元數量是有限制的。預設限制可以在 效率指南 (系統限制章節) 中找到。

注意

可以存在的原子數量有可設定的限制，而且原子不會被垃圾回收。因此，建議考慮 binary_to_existing_atom/2 是否比 binary_to_atom/2 更好的選擇。預設限制可以在 效率指南 (系統限制章節) 中找到。

範例

> binary_to_atom(<<"Erlang">>, latin1).
'Erlang'

> binary_to_atom(<<1024/utf8>>, utf8).
'Ѐ'

-spec binary_to_existing_atom(Binary) -> atom() when Binary :: binary().

等效於 binary_to_existing_atom(Binary, utf8)。

-spec binary_to_existing_atom(Binary, Encoding) -> atom()
                                 when Binary :: binary(), Encoding :: latin1 | unicode | utf8.

與 binary_to_atom/2 相同，但原子必須存在。

Erlang 系統對於可以存在的原子總數有可設定的限制，而且原子不會被垃圾回收。因此，從來自不受信任來源（例如，從網際網路擷取的文件）的二進制資料建立許多原子是不安全的，例如使用 binary_to_atom/2。因此，當輸入二進制資料來自不受信任的來源時，此函數是合適的選擇。

當原子包含在已載入的 Erlang 模組中，或以程式方式建立時（例如，通過 binary_to_atom/2），原子會存在於 Erlang 系統中。請參閱下一個註解，了解一個範例，說明原子在 Erlang 模組的原始程式碼中存在，但不在相同模組的編譯版本中。

失敗：如果原子不存在，則會發生 badarg 錯誤。

注意

請注意，編譯器可能會最佳化掉原子。例如，編譯器會將 atom_to_list(some_atom) 重寫為 "some_atom"。如果該表示式是包含模組中唯一提及的原子 some_atom，則在載入模組時不會建立該原子，並且後續呼叫 binary_to_existing_atom(<<"some_atom">>, utf8) 將會失敗。

注意

原子名稱中允許的字元數量是有限制的。預設限制可以在 效率指南 (系統限制章節) 中找到。

-spec binary_to_float(Binary) -> float() when Binary :: binary().

傳回文字表示形式為 Binary 的浮點數。

例如

> binary_to_float(<<"2.2017764e+0">>).
2.2017764

浮點數的字串格式與 Erlang 浮點數文字的格式相同，但底線符號不允許使用。

失敗：如果 Binary 包含錯誤的浮點數表示法，則會發生 badarg 錯誤。

-spec binary_to_integer(Binary) -> integer() when Binary :: binary().

傳回文字表示形式為 Binary 的整數。

例如

> binary_to_integer(<<"123">>).
123

binary_to_integer/1 接受與 list_to_integer/1 相同的字串格式。

失敗：如果 Binary 包含錯誤的整數表示法，則會發生 badarg 錯誤。

-spec binary_to_integer(Binary, Base) -> integer() when Binary :: binary(), Base :: 2..36.

傳回以 Base 為底的文字表示形式為 Binary 的整數。

例如

> binary_to_integer(<<"3FF">>, 16).
1023

binary_to_integer/2 接受與 list_to_integer/2 相同的字串格式。

失敗：如果 Binary 包含錯誤的整數表示法，則會發生 badarg 錯誤。

-spec binary_to_list(Binary) -> [byte()] when Binary :: binary().

傳回對應於 Binary 的位元組的整數清單。

-spec binary_to_list(Binary, Start, Stop) -> [byte()]
                        when Binary :: binary(), Start :: pos_integer(), Stop :: pos_integer().

與 binary_to_list/1 相同，但傳回一個對應於 Binary 中從位置 Start 到位置 Stop 的位元組的整數清單。二進位中的位置從 1 開始編號。

注意

這個函數使用的二進制資料的一基索引 (one-based indexing) 已被棄用。 新的程式碼應改用 STDLIB 中的 binary:bin_to_list/3。模組 binary 中的所有函數都一致地使用從零開始的索引 (zero-based indexing)。

-spec binary_to_term(Binary) -> term() when Binary :: ext_binary().

傳回 Erlang 項，該項是解碼二進位物件 Binary 的結果，該物件必須根據 Erlang 外部項格式進行編碼。

> Bin = term_to_binary(hello).
<<131,100,0,5,104,101,108,108,111>>
> hello = binary_to_term(Bin).
hello

警告

當解碼來自不受信任來源的二進制資料時，不受信任的來源可能會以建立無法被垃圾回收且導致阻斷服務攻擊的資源（例如，原子和遠端參考）的方式提交資料。在這種情況下，請考慮使用具有 safe 選項的 binary_to_term/2。

另請參閱 term_to_binary/1 和 binary_to_term/2。

-spec binary_to_term(Binary, Opts) -> term() | {term(), Used}
                        when
                            Binary :: ext_binary(),
                            Opt :: safe | used,
                            Opts :: [Opt],
                            Used :: pos_integer().

等效於 binary_to_term(Binary)，但可以設定為適合特殊用途。

允許的選項如下：

• safe - 當接收來自不受信任來源的二進制資料時，請使用此選項。

  啟用後，它會阻止解碼可用於攻擊 Erlang 執行時的資料。如果收到不安全的資料，解碼會失敗並產生 badarg 錯誤。

  這會直接阻止建立新的原子，間接阻止建立新的原子（因為它們嵌入在某些結構中，例如處理程序識別碼、refs 和 funs），並阻止建立新的外部函數參考。這些資源都不會被垃圾回收，因此未經檢查地建立它們可能會耗盡可用記憶體。

  > binary_to_term(<<131,100,0,5,"hello">>, [safe]).
  ** exception error: bad argument
  > hello.
  hello
  > binary_to_term(<<131,100,0,5,"hello">>, [safe]).
  hello

  警告

  safe 選項可確保 Erlang 執行時安全地處理資料，但它不保證資料對您的應用程式安全。您必須始終驗證來自不受信任來源的資料。如果二進制資料被儲存或通過不受信任的來源傳輸，您也應該考慮對其進行密碼簽署。

• used - 將回傳值變更為 {Term, Used}，其中 Used 是實際從 Binary 讀取的位元組數。

  > Input = <<131,100,0,5,"hello","world">>.
  <<131,100,0,5,104,101,108,108,111,119,111,114,108,100>>
  > {Term, Used} = binary_to_term(Input, [used]).
  {hello, 9}
  > split_binary(Input, Used).
  {<<131,100,0,5,104,101,108,108,111>>, <<"world">>}

失敗：如果指定了 safe 並且解碼了不安全的資料，則會發生 badarg 錯誤。

另請參閱 term_to_binary/1、binary_to_term/1 和 list_to_existing_atom/1。

-spec bit_size(Bitstring) -> non_neg_integer() when Bitstring :: bitstring().

傳回一個整數，該整數是 Bitstring 的位元大小。

例如

> bit_size(<<433:16,3:3>>).
19
> bit_size(<<1,2,3>>).
24

-spec bitstring_to_list(Bitstring) -> [byte() | bitstring()] when Bitstring :: bitstring().

傳回對應於 Bitstring 的位元組的整數清單。

如果二進制資料中的位元數不能被 8 整除，則列表的最後一個元素是一個包含剩餘 1-7 位元的位元字串。

例如

> bitstring_to_list(<<433:16>>).
[1,177]

> bitstring_to_list(<<433:16,3:3>>).
[1,177,<<3:3>>]

-spec byte_size(Bitstring) -> non_neg_integer() when Bitstring :: bitstring().

傳回一個整數，該整數是包含 Bitstring 所需的位元組數。也就是說，如果 Bitstring 中的位元數不能被 8 整除，則產生的位元組數會向上捨入。

例如

> byte_size(<<433:16,3:3>>).
3
> byte_size(<<1,2,3>>).
3

-spec ceil(Number) -> integer() when Number :: number().

傳回不小於 Number 的最小整數。

例如

> ceil(5.5).
6

-spec decode_packet(Type, Bin, Options) -> {ok, Packet, Rest} | {more, Length} | {error, Reason}
                       when
                           Type ::
                               raw | 0 | 1 | 2 | 4 | asn1 | cdr | sunrm | fcgi | tpkt | line | http |
                               http_bin | httph | httph_bin,
                           Bin :: binary(),
                           Options :: [Opt],
                           Opt :: {packet_size, non_neg_integer()} | {line_length, non_neg_integer()},
                           Packet :: binary() | HttpPacket,
                           Rest :: binary(),
                           Length :: non_neg_integer() | undefined,
                           Reason :: term(),
                           HttpPacket :: HttpRequest | HttpResponse | HttpHeader | http_eoh | HttpError,
                           HttpRequest :: {http_request, HttpMethod, HttpUri, HttpVersion},
                           HttpResponse :: {http_response, HttpVersion, integer(), HttpString},
                           HttpHeader ::
                               {http_header,
                                integer(),
                                HttpField,
                                UnmodifiedField :: HttpString,
                                Value :: HttpString},
                           HttpError :: {http_error, HttpString},
                           HttpMethod ::
                               'OPTIONS' | 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'TRACE' |
                               HttpString,
                           HttpUri ::
                               '*' |
                               {absoluteURI,
                                http | https,
                                Host :: HttpString,
                                Port :: inet:port_number() | undefined,
                                Path :: HttpString} |
                               {scheme, Scheme :: HttpString, HttpString} |
                               {abs_path, HttpString} |
                               HttpString,
                           HttpVersion :: {Major :: non_neg_integer(), Minor :: non_neg_integer()},
                           HttpField ::
                               'Cache-Control' | 'Connection' | 'Date' | 'Pragma' |
                               'Transfer-Encoding' | 'Upgrade' | 'Via' | 'Accept' | 'Accept-Charset' |
                               'Accept-Encoding' | 'Accept-Language' | 'Authorization' | 'From' |
                               'Host' | 'If-Modified-Since' | 'If-Match' | 'If-None-Match' |
                               'If-Range' | 'If-Unmodified-Since' | 'Max-Forwards' |
                               'Proxy-Authorization' | 'Range' | 'Referer' | 'User-Agent' | 'Age' |
                               'Location' | 'Proxy-Authenticate' | 'Public' | 'Retry-After' | 'Server' |
                               'Vary' | 'Warning' | 'Www-Authenticate' | 'Allow' | 'Content-Base' |
                               'Content-Encoding' | 'Content-Language' | 'Content-Length' |
                               'Content-Location' | 'Content-Md5' | 'Content-Range' | 'Content-Type' |
                               'Etag' | 'Expires' | 'Last-Modified' | 'Accept-Ranges' | 'Set-Cookie' |
                               'Set-Cookie2' | 'X-Forwarded-For' | 'Cookie' | 'Keep-Alive' |
                               'Proxy-Connection' | HttpString,
                           HttpString :: string() | binary().

根據 Type 指定的封包協定解碼二進位 Bin。與具有選項 {packet,Type} 的 Socket 所做的封包處理類似。

如果整個封包都包含在 Bin 中，則會連同二進制資料的剩餘部分一起以 {ok,Packet,Rest} 的形式傳回。

如果 Bin 不包含整個封包，則會傳回 {more,Length}。Length 要么是封包的預期總大小，要么是 undefined（如果預期封包大小未知）。然後可以使用添加的更多資料再次呼叫 decode_packet。

如果封包不符合協定格式，則會傳回 {error,Reason}。

Type 類型

• raw | 0 - 不執行封包處理。除非二進制資料為空，否則會傳回整個二進制資料。

• 1 | 2 | 4 - 封包由指定封包位元組數的標頭組成，後面跟著該位元組數。標頭的長度可以是一個、兩個或四個位元組；位元組的順序是大端序 (big-endian)。當封包傳回時，標頭會被移除。

• line - 封包是以分隔符號位元組終止的行，預設是 latin-1 換行字元。分隔符號位元組包含在傳回的封包中，除非該行根據選項 line_length 被截斷。

• asn1 | cdr | sunrm | fcgi | tpkt - 標頭不會被移除。

  封包類型的含義如下：

  • asn1 - ASN.1 BER

  • sunrm - Sun 的 RPC 編碼

  • cdr - CORBA (GIOP 1.1)

  • fcgi - Fast CGI

  • tpkt - TPKT 格式 [RFC1006]

• http | httph | http_bin | httph_bin - 超文本傳輸協定。封包會根據先前描述的 HttpPacket 格式傳回。封包可以是請求、回應、標頭或標頭結束標記。無效的行會以 HttpError 傳回。

  已識別的請求方法和標頭欄位會以原子形式傳回。其他則以字串形式傳回。無法識別的標頭欄位字串會格式化為僅第一個字母和大寫，以及連字號後面的字母，例如 "Sec-Websocket-Key"。標頭欄位名稱也會以字串形式在 UnmodifiedField 中傳回，不經任何轉換或格式化。

  當預期為 HttpRequest 或 HttpResponse 時，協定類型 http 僅用於第一行。後續的呼叫應使用 httph 來取得 HttpHeader，直到傳回 http_eoh 為止，這表示標頭的結束和任何後續訊息主體的開始。

  變體 http_bin 和 httph_bin 會以二進位形式傳回字串 (HttpString)，而不是列表。

  自 OTP 26.0 起，Host 可以是用 [] 括起來的 IPv6 位址，如 RFC2732 中所定義。

選項

• {packet_size, integer() >= 0} - 設定封包主體允許的最大大小。如果封包標頭指示封包的長度大於允許的最大長度，則該封包會被視為無效。預設值為 0，表示沒有大小限制。

• {line_length, integer() >= 0} - 對於封包類型 line，超過指定長度的行會被截斷。

  如果沒有設定 packet_size 本身，選項 line_length 也會作為選項 packet_size 的別名，套用於 http* 封包類型。此用法僅用於向後相容性。

• {line_delimiter, 0 =< byte() =< 255} - 對於封包類型 line，設定分隔位元組。預設值為 latin-1 字元 $\n。

範例

> erlang:decode_packet(1,<<3,"abcd">>,[]).
{ok,<<"abc">>,<<"d">>}
> erlang:decode_packet(1,<<5,"abcd">>,[]).
{more,6}

-spec delete_element(Index, Tuple1) -> Tuple2
                        when Index :: pos_integer(), Tuple1 :: tuple(), Tuple2 :: tuple().

傳回一個新的元組，其中元素在元組 Tuple1 中移除 Index 的位置。

例如

> erlang:delete_element(2, {one, two, three}).
{one,three}

-spec display(Term) -> true when Term :: term().

在標準輸出上印出 Term 的文字表示形式。

警告

此 BIF 僅用於除錯。列印的表示形式可能包含不符合 Erlang 中術語高階表示形式的內部詳細資訊。

-spec element(N, Tuple) -> term() when N :: pos_integer(), Tuple :: tuple().

傳回 Tuple 的第 N 個元素（從 1 開始編號）。

例如

> element(2, {a, b, c}).
b

-spec external_size(Term) -> non_neg_integer() when Term :: term().

計算以 Erlang 外部項格式編碼的項目的最大位元組大小，而無需執行編碼。

以下條件始終適用

> Size1 = byte_size(term_to_binary(Term)),
> Size2 = erlang:external_size(Term),
> true = Size1 =< Size2.
true

這等同於呼叫

erlang:external_size(Term, [])

-spec external_size(Term, Options) -> non_neg_integer()
                       when
                           Term :: term(),
                           Options ::
                               [compressed |
                                {compressed, Level :: 0..9} |
                                deterministic |
                                {minor_version, Version :: 0..2} |
                                local].

計算以 Erlang 外部項格式編碼的項目的最大位元組大小，而無需執行編碼。

以下條件始終適用

> Size1 = byte_size(term_to_binary(Term, Options)),
> Size2 = erlang:external_size(Term, Options),
> true = Size1 =< Size2.
true

選項 {minor_version, Version} 指定浮點數的編碼方式。有關詳細描述，請參閱 term_to_binary/2。

-spec float(Number) -> float() when Number :: number().

透過將 Number 轉換為浮點數來傳回浮點數。

例如

> float(55).
55.0

注意

如果在 guard 的最上層使用，它會測試參數是否為浮點數；為了清楚起見，請改用 is_float/1。

當在 guard 中的表達式中使用 float/1 時，例如 'float(A) == 4.0'，它會如先前所述轉換數字。

-spec float_to_binary(Float) -> binary() when Float :: float().

等效於 float_to_binary(Float, [{scientific, 20}])。

-spec float_to_binary(Float, Options) -> binary()
                         when
                             Float :: float(),
                             Options :: [Option],
                             Option ::
                                 {decimals, Decimals :: 0..253} |
                                 {scientific, Decimals :: 0..249} |
                                 compact | short.

傳回一個對應於使用固定小數點格式的 Float 的文字表示形式的二進位。

Options 的行為方式與 float_to_list/2 相同。

例如

> float_to_binary(7.12, [{decimals, 4}]).
<<"7.1200">>
> float_to_binary(7.12, [{decimals, 4}, compact]).
<<"7.12">>
> float_to_binary(7.12, [{scientific, 3}]).
<<"7.120e+00">>
> float_to_binary(7.12, [short]).
<<"7.12">>
> float_to_binary(0.1+0.2, [short]).
<<"0.30000000000000004">>
> float_to_binary(0.1+0.2)
<<"3.00000000000000044409e-01">>

-spec float_to_list(Float) -> string() when Float :: float().

等效於 float_to_list(Float, [{scientific, 20}])。

-spec float_to_list(Float, Options) -> string()
                       when
                           Float :: float(),
                           Options :: [Option],
                           Option ::
                               {decimals, Decimals :: 0..253} |
                               {scientific, Decimals :: 0..249} |
                               compact | short.

傳回一個對應於使用固定小數點格式的 Float 的文字表示形式的字串。

可用的選項

• 如果指定選項 decimals，則傳回的值最多包含小數點後 Decimals 位數的數字。如果數字不符合 256 位元組的內部靜態緩衝區，則該函式會拋出 badarg。
• 如果指定選項 compact，則會截斷列表末尾的尾隨零。此選項僅在與選項 decimals 一起使用時才有意義。
• 如果指定選項 scientific，則使用科學記號格式化浮點數，並具有 Decimals 位數的精度。
• 如果指定選項 short，則格式化浮點數時會使用最小位數，仍然保證 F =:= list_to_float(float_to_list(F, [short]))。當浮點數在範圍 (-2⁵³, 2⁵³) 內時，會使用產生最小字元數的表示法（科學記號表示法或一般十進制表示法）。範圍 (-2⁵³, 2⁵³) 之外的浮點數始終使用科學記號格式化，以避免在執行算術運算時造成混淆的結果。
• 如果 Options 為 []，則該函式的行為方式與 float_to_list/1 相同。

範例

> float_to_list(7.12, [{decimals, 4}]).
"7.1200"
> float_to_list(7.12, [{decimals, 4}, compact]).
"7.12"
> float_to_list(7.12, [{scientific, 3}]).
"7.120e+00"
> float_to_list(7.12, [short]).
"7.12"
> float_to_list(0.1+0.2, [short]).
"0.30000000000000004"
> float_to_list(0.1+0.2)
"3.00000000000000044409e-01"

在最後一個範例中，float_to_list(0.1+0.2) 的計算結果為 "3.00000000000000044409e-01"。原因已在浮點數的表示問題中解釋。

-spec floor(Number) -> integer() when Number :: number().

傳回不大於 Number 的最大整數。

例如

> floor(-10.5).
-11

-spec fun_info(Fun) -> [{Item, Info}]
                  when
                      Fun :: function(),
                      Item ::
                          arity | env | index | name | module | new_index | new_uniq | pid | type | uniq,
                      Info :: term().

傳回一個包含函式 Fun 資訊的清單。每個清單元素都是一個元組。元組的順序是未定義的，並且在未來版本中可以新增更多元組。

警告

此 BIF 主要用於除錯，但有時在需要驗證（例如 fun 的 arity）的程式庫函式中很有用。

兩種類型的 fun 具有稍微不同的語義

• 由 fun M:F/A 建立的 fun 稱為外部 fun。呼叫它將始終呼叫模組 M 最新程式碼中 arity 為 A 的函式 F。請注意，當建立 fun fun M:F/A 時，甚至不需要載入模組 M。
• 所有其他 fun 都稱為本地 fun。當呼叫本地 fun 時，會呼叫建立 fun 的相同版本的程式碼（即使已載入模組的較新版本）。

對於本地和外部 fun，以下元素始終存在於列表中

• {type, Type} - Type 為 local 或 external。

• {module, Module} - Module (一個原子) 是模組名稱。

  如果 Fun 是本地 fun，則 Module 是定義該 fun 的模組。

  如果 Fun 是外部 fun，則 Module 是 fun 指向的模組。

• {name, Name} - Name (一個原子) 是函式名稱。

  如果 Fun 是本地 fun，則 Name 是實作該 fun 的本地函式的名稱。（此名稱由編譯器產生，僅供參考之用。由於它是本地函式，因此無法直接呼叫。）如果目前沒有為 fun 載入任何程式碼，則會傳回 [] 而不是原子。

  如果 Fun 是外部 fun，則 Name 是 fun 指向的已匯出函式的名稱。

• {arity, Arity} - Arity 是 fun 被呼叫時所使用的參數數量。

• {env, Env} - Env (一個列表) 是 fun 的環境或自由變數。對於外部 fun，傳回的列表始終為空。

只有當 Fun 是本地 fun 時，以下元素才會存在於列表中

• {pid, Pid} - Pid 是本地節點上 init 程序的程序識別碼。

  變更

  從 Erlang/OTP 27 開始，無論最初在哪個程序或節點上建立 fun，Pid 始終指向本地 init 程序。

  請參閱 即將出現的潛在不相容性。

• {index, Index} - Index (一個整數) 是模組 fun 表格中的索引。

• {new_index, Index} - Index (一個整數) 是模組 fun 表格中的索引。

• {new_uniq, Uniq} - Uniq (一個二進位) 是此 fun 的唯一值。它是從整個模組的已編譯程式碼計算而來的。

• {uniq, Uniq} - Uniq (一個整數) 是此 fun 的唯一值。從 Erlang/OTP R15 起，此整數是從整個模組的已編譯程式碼計算而來的。在 Erlang/OTP R15 之前，此整數僅基於 fun 的主體。

-spec fun_info(Fun, Item) -> {Item, Info}
                  when Fun :: function(), Item :: fun_info_item(), Info :: term().

以 {Item,Info} 形式傳回 Fun 的資訊，如 Item 所指定。

對於任何 fun，Item 可以是原子 module、name、arity、env 或 type 中的任何一個。

對於本地函式（local fun），Item 也可以是原子（atom）index、new_index、new_uniq、uniq 和 pid。對於外部函式（external fun），這些項目的值永遠是原子 undefined。