当前位置: 首页>>代码示例 >>用法及示例精选 >>正文


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


format(Format) -> ok
format(Format, Data) -> ok
format(IoDevice, Format, Data) -> ok
fwrite(Format) -> ok
fwrite(Format, Data) -> ok
fwrite(IoDevice, Format, Data) -> ok
类型:
IoDevice = device()
Format = format()
Data = [term()]

根据 FormatData ([]) 中的项目写入标准输出 (IoDevice)。 Format 包含复制到输出设备的纯字符以及用于格式化的控制序列,请参见下文。如果 Format 是原子或二进制,则首先借助 atom_to_list/1binary_to_list/1 将其转换为列表。例子:

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

控制序列的一般格式为~F.P.PadModC

字符C 确定要使用的控制序列的类型。这是唯一必填字段。 FPPadMod 都是可选的。例如,要将 # 用于 Pad 但使用 FP 的默认值,您可以编写 ~..#C

  • F 是打印参数的field width。负值意味着参数在字段内左对齐,否则右对齐。如果未指定字段宽度,则使用所需的打印宽度。如果指定的字段宽度太小,则整个字段将填充* 字符。

  • P 是打印参数的precision。如果未指定精度,则使用默认值。精度的解释取决于控制序列。除非另有说明,否则参数 within 用于确定打印宽度。

  • Pad 是填充字符。这是用于填充参数的打印表示形式的字符,以便它符合指定的字段宽度和精度。只能指定一个填充字符,并且只要适用,它就会用于字段宽度和精度。默认填充字符是' '(空格)。

  • Mod 是控制序列修饰符。这是一个或多个更改 Data 解释的字符。

    当前的修改器是:


    t

    用于 Unicode 翻译。


    l

    用于阻止 pP 检测可打印字符。


    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

如果 FPPad* 字符,则 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。

相关用法


注:本文由纯净天空筛选整理自erlang.org大神的英文原创作品 format(Format) -> ok。非经特殊声明,原始代码版权归原作者所有,本译文未经允许或授权,请勿转载或复制。