erlang format(Format)用法及代碼示例

根據 Format 將 Data ([]) 中的項目寫入標準輸出 (IoDevice)。 Format 包含複製到輸出設備的純字符以及用於格式化的控製序列，請參見下文。如果 Format 是原子或二進製，則首先借助 atom_to_list/1 或 binary_to_list/1 將其轉換為列表。例子：

1> io:fwrite("Hello world!~n", []).
Hello world!
ok

控製序列的一般格式為~F.P.PadModC。

字符C 確定要使用的控製序列的類型。這是唯一必填字段。 F 、 P 、 Pad 和 Mod 都是可選的。例如，要將 # 用於 Pad 但使用 F 和 P 的默認值，您可以編寫 ~..#C 。

• F 是打印參數的field width。負值意味著參數在字段內左對齊，否則右對齊。如果未指定字段寬度，則使用所需的打印寬度。如果指定的字段寬度太小，則整個字段將填充* 字符。

• P 是打印參數的precision。如果未指定精度，則使用默認值。精度的解釋取決於控製序列。除非另有說明，否則參數 within 用於確定打印寬度。

• Pad 是填充字符。這是用於填充參數的打印表示形式的字符，以便它符合指定的字段寬度和精度。隻能指定一個填充字符，並且隻要適用，它就會用於字段寬度和精度。默認填充字符是' '(空格)。

• Mod 是控製序列修飾符。這是一個或多個更改 Data 解釋的字符。

  當前的修改器是：

  
  

  t

  用於 Unicode 翻譯。

  
  

  l

  用於阻止 p 和 P 檢測可打印字符。

  
  

  k

  配合使用p,P,w， 和W格式化map-key中的Mapordered訂單(參見Map：iterator_order())。

  
  

  K

  相似k，用於按 map-key 順序格式化Map，但需要一個額外的參數來指定Map：iterator_order().

  例如：

  > M = #{ a => 1, b => 2 }.
  #{a => 1,b => 2}
  > io:format("~Kp~n", [reversed, M]).
  #{b => 2,a => 1}
  ok

如果 F 、 P 或 Pad 是 * 字符，則 Data 中的下一個參數將用作值。例如：

1> io:fwrite("~*.*.0f~n",[9, 5, 3.14159265]).
003.14159
ok

要將文字 * 字符用作 Pad ，必須將其作為參數傳遞：

2> io:fwrite("~*.*.*f~n",[9, 5, $*, 3.14159265]).
**3.14159
ok

可用的控製序列：

~

寫入字符~。

c

參數是一個被解釋為 ASCII 代碼的數字。精度是字符打印的次數，默認為字段寬度，而字段寬度又默認為 1。示例：

1> io:fwrite("|~10.5c|~-10.5c|~5c|~n", [$a, $b, $c]).
|     aaaaa|bbbbb     |ccccc|
ok

如果 Unicode 轉換修飾符 ( t ) 有效，則整數參數可以是表示有效 Unicode 代碼點的任何數字，否則它將是小於或等於 255 的整數，否則將使用 16#FF 進行掩碼：

2> io:fwrite("~tc~n",[1024]).
\x{400}
ok
3> io:fwrite("~c~n",[1024]).
^@
ok

f

參數是一個浮點數，寫作 [-]ddd.ddd ，其中精度是小數點後的位數。默認精度為 6，且不能 < 1。

e

參數是一個浮點數，寫作 [-]d.ddde+-ddd ，其中精度是寫入的位數。默認精度為 6，並且不能 < 2。

g

參數是一個浮點數，如果 >= 0.1 且 < 10000.0，則寫為 f 。否則，將以e 格式編寫。精度是有效位數。默認為 6，且不小於 2。如果浮點數的絕對值不允許以所需有效位數的 f 格式寫入，則也以 e 格式寫入。

s

使用字符串語法打印參數。如果不存在 Unicode 翻譯修飾符，則參數為 iolist() 、 binary() 或 atom() 。如果 Unicode 轉換修飾符 ( t ) 有效，則參數為 unicode:chardata() ，這意味著二進製文件采用 UTF-8 格式。打印的字符不帶引號。該字符串首先按指定的精度截斷，然後填充並對齊到指定的字段寬度。默認精度是字段寬度。

此格式可用於打印任何對象並截斷輸出以使其適合指定的字段：

1> io:fwrite("|~10w|~n", [{hey, hey, hey}]).
|**********|
ok
2> io:fwrite("|~10s|~n", [io_lib:write({hey, hey, hey})]).
|{hey,hey,h|
3> io:fwrite("|~-10.8s|~n", [io_lib:write({hey, hey, hey})]).
|{hey,hey  |
ok

如果未指定 Unicode 轉換修飾符，則整數 > 255 的列表將被視為錯誤：

4> io:fwrite("~ts~n",[[1024]]).
\x{400}
ok
5> io:fwrite("~s~n",[[1024]]).
** exception error: bad argument
     in function  io:format/3
        called as io:format(<0.53.0>,"~s~n",[[1024]])

w

使用標準語法寫入數據。這用於輸出 Erlang 術語。如果原子包含嵌入的不可打印字符，則它們會在引號內打印。除非使用 Unicode 翻譯修飾符 ( t )，否則大於 255 的原子字符將被轉義。浮點數被準確地打印為最短、正確圓角的字符串。

p

以與 ~w 相同的方式使用標準語法寫入數據，但將打印表示形式長於一行的術語分成多行，並合理地縮進每行。不支持Left-justification。它還嘗試檢測可打印字符的平麵列表並將其輸出為字符串。例如：

1> T = [{attributes,[[{id,age,1.50000},{mode,explicit},
{typename,"INTEGER"}], [{id,cho},{mode,explicit},{typename,'Cho'}]]},
{typename,'Person'},{tag,{'PRIVATE',3}},{mode,implicit}].
...
2> io:fwrite("~w~n", [T]).
[{attributes,[[{id,age,1.5},{mode,explicit},{typename,
[73,78,84,69,71,69,82]}],[{id,cho},{mode,explicit},{typena
me,'Cho'}]]},{typename,'Person'},{tag,{'PRIVATE',3}},{mode
,implicit}]
ok
3> io:fwrite("~62p~n", [T]).
[{attributes,[[{id,age,1.5},
               {mode,explicit},
               {typename,"INTEGER"}],
              [{id,cho},{mode,explicit},{typename,'Cho'}]]},
 {typename,'Person'},
 {tag,{'PRIVATE',3}},
 {mode,implicit}]
ok

字段寬度指定最大行長度。默認為 80。精度指定術語的初始縮進。默認為該行打印的字符數相同的撥電至write/1或者format/1,2,3。例如，使用T多於：

4> io:fwrite("Here T = ~62p~n", [T]).
Here T = [{attributes,[[{id,age,1.5},
                        {mode,explicit},
                        {typename,"INTEGER"}],
                       [{id,cho},
                        {mode,explicit},
                        {typename,'Cho'}]]},
          {typename,'Person'},
          {tag,{'PRIVATE',3}},
          {mode,implicit}]
ok

從 Erlang/OTP 21.0 開始，字段寬度值 0 可用於指定行無限長，這意味著不插入換行符。例如：

5> io:fwrite("~0p~n", [lists:seq(1, 30)]).
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
ok

當指定修飾符 l 時，不會檢測可打印字符列表，例如：

6> S = [{a,"a"}, {b, "b"}],
   io:fwrite("~15p~n", [S]).
[{a,"a"},
 {b,"b"}]
ok
7> io:fwrite("~15lp~n", [S]).
[{a,[97]},
 {b,[98]}]
ok

Unicode 轉換修飾符 t 指定如何處理 Latin-1 代碼點範圍之外的原子、字符串和二進製字符。例如，打印包含字符 > 255 的原子：

8> io:fwrite("~p~n",[list_to_atom([1024])]).
'\x{400}'
ok
9> io:fwrite("~tp~n",[list_to_atom([1024])]).
'Ѐ'
ok

默認情況下，Erlang 僅將 Latin-1 範圍內的字符列表檢測為字符串，但是+pc unicode標誌可用於更改此設置(請參閱 printable_range/0了解詳情)。例如：

10> io:fwrite("~p~n",[[214]]).
"Ö"
ok
11> io:fwrite("~p~n",[[1024]]).
[1024]
ok
12> io:fwrite("~tp~n",[[1024]]).
[1024]
ok

但如果 Erlang 是用 +pc unicode 啟動的：

13> io:fwrite("~p~n",[[1024]]).
[1024]
ok
14> io:fwrite("~tp~n",[[1024]]).
"Ѐ"
ok

同樣，如果指定了 t 修飾符，則看起來像 UTF-8 編碼字符串的二進製文件將以二進製字符串語法輸出：

15> io:fwrite("~p~n", [<<208,128>>]).
<<208,128>>
ok
16> io:fwrite("~tp~n", [<<208,128>>]).
<<"Ѐ"/utf8>>
ok
17> io:fwrite("~tp~n", [<<128,128>>]).
<<128,128>>
ok

W

以與 ~w 相同的方式寫入數據，但需要一個額外的參數，即打印術語的最大深度。低於此深度的任何內容都將替換為 ... 。例如，使用上麵的T：

8> io:fwrite("~W~n", [T,9]).
[{attributes,[[{id,age,1.5},{mode,explicit},{typename,...}],
[{id,cho},{mode,...},{...}]]},{typename,'Person'},
{tag,{'PRIVATE',3}},{mode,implicit}]
ok

如果達到最大深度，則無法在結果輸出中讀取。此外，元組中的 ,... 形式表示元組中有更多元素，但這些元素低於打印深度。

P

以與 ~p 相同的方式寫入數據，但需要一個額外的參數，即打印術語的最大深度。低於此深度的任何內容都將替換為 ... ，例如：

9> io:fwrite("~62P~n", [T,9]).
[{attributes,[[{id,age,1.5},{mode,explicit},{typename,...}],
              [{id,cho},{mode,...},{...}]]},
 {typename,'Person'},
 {tag,{'PRIVATE',3}},
 {mode,implicit}]
ok

B

寫入基數為 2-36 的整數，默認基數為 10。負整數會打印前導破折號。

precision字段選擇base，例如：

1> io:fwrite("~.16B~n", [31]).
1F
ok
2> io:fwrite("~.2B~n", [-19]).
-10011
ok
3> io:fwrite("~.36B~n", [5*36+35]).
5Z
ok

X

與 B 類似，但需要一個額外的參數，該參數是要在數字之前插入的前綴，但在前導破折號之後(如果有)。

前綴可以是可能很深的字符列表或原子。例子：

1> io:fwrite("~X~n", [31,"10#"]).
10#31
ok
2> io:fwrite("~.16X~n", [-31,"0x"]).
-0x1F
ok

#

與 B 類似，但使用 Erlang 樣式 # 分隔的基本前綴打印數字。例子：

1> io:fwrite("~.10#~n", [31]).
10#31
ok
2> io:fwrite("~.16#~n", [-31]).
-16#1F
ok

b

與 B 類似，但打印小寫字母。

x

與 X 類似，但打印小寫字母。

+

與 # 類似，但打印小寫字母。

n

寫入新行。

i

忽略下一個術語。

該函數返回：

ok

格式化成功。

如果發生錯誤，則沒有輸出。例子：

1> io:fwrite("~s ~w ~i ~w ~c ~n",['abc def', 'abc def', {foo, 1},{foo, 1}, 65]).
abc def 'abc def'  {foo,1} A
ok
2> io:fwrite("~s", [65]).
** exception error: bad argument
     in function  io:format/3
        called as io:format(<0.53.0>,"~s","A")

在此示例中，嘗試借助字符串格式化指令 "~s" 輸出單個字符 65。