io - stdlib - Erlang 20教程 - 在线文档教程

io

模块

模块摘要

标准I / O服务器接口功能。

描述

该模块为标准的Erlang I / O服务器提供接口。输出函数ok如果成功则全部返回，否则退出。

该模块中的所有功能都有一个可选参数IoDevice。如果包含，它必须是处理I / O协议的进程的PID。通常情况下，它是由IoDevice返回的file:open/2。

有关I / O协议的说明，请参见The Erlang I/O Protocol用户指南中的部分。

警告

从Erlang / OTP R13A开始，提供给函数的数据put_chars/2应该是unicode:chardata()格式。这意味着为该函数提供二进制文件的程序在尝试在I / O设备上输出数据之前必须将它们转换为UTF-8。

如果I / O设备以二进制模式，功能设置get_chars/2,3和get_line/1,2可以返回二进制文件，而不是列表。从Erlang / OTP R13A开始，二进制文件以UTF-8编码。

要在ISO Latin-1编码中使用二进制文件，请改用该file模块。

对于字符编码之间的转换函数，请参阅unicode模块。

数据类型

device() = atom() | pid()

一个I / O装置，或者standard_io，standard_error（从返回的注册名称，或PID处理I / O协议file:open/2）。

opt_pair() =

{binary, boolean()} |

{echo, boolean()} |

{expand_fun, expand_fun()} |

{encoding, encoding()}

expand_fun() =

fun((term()) -> {yes | no, string(), [string(), ...]})

encoding() =

latin1 |

unicode |

utf8 |

utf16 |

utf32 |

{utf16, big | little} |

{utf32, big | little}

setopt() = binary | list | opt_pair()

format() = atom() | string() | binary()

location() = erl_anno:location()

prompt() = atom() | unicode:chardata()

server_no_data() = {error, ErrorDescription :: term()} | eof

当没有数据时，I / O服务器发送什么信息。

输出

columns() -> {ok, integer() >= 1} | {error, enotsup}

columns(IoDevice) -> {ok, integer() >= 1} | {error, enotsup}

类型

检索IoDevice（即终端宽度）的列数。终端设备的功能成功，{error, enotsup}所有其他I / O设备的返回功能也成功。

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）上写入数据（[]）中的项目。格式包含复制到输出设备的纯字符以及用于格式化的控制序列，请参见下文。如果格式是原子或二进制文件，则首先借助atom_to_list / 1或binary_to_list / 1将其转换为列表。例：

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

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

字符C确定要使用的控制序列的类型，F和P是可选的数字参数。如果F，P或Pad为*，则将Data中的下一个参数用作F或P的数值。

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

可用的控制序列：

~

字符~被写入。

c

参数是一个被解释为ASCII码的数字。精度是字符打印的次数，默认为字段宽度，默认值为1.示例：

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

如果Unicode转换修饰符（t）是有效的，那么integer参数可以是表示有效的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

参数是一个写成float的浮点数，[-]d.ddde+-ddd其精度是写入的位数。默认精度为6，不能小于2。

g

该参数是写入的浮点数f，如果大于等于0.1且小于等于10000.0。否则，它以e格式写入。精度是有效位数。它的默认值为6，不能小于2.如果float的绝对值不允许以f具有所需有效数字的e格式写入，则它也以格式写入。

s

用字符串语法打印参数。参数是，如果没有Unicode转换修饰符存在，iolist（），二进制（）或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 exit: {badarg,[{io,format,[<0.26.0>,"~s~n",[[1024]]]},
   ...

w

用标准语法写入数据。这用于输出Erlang条款。如果原子包含嵌入的不可打印字符，则原子将打印在引号内。除非使用Unicode转换修饰符（t），否则原子字符> 255会被转义。花车准确地打印为最短的，正确的圆形字符串。

p

以与标准语法相同的方式写入数据~w，但将打印表示长于一行的术语拆分为许多行，并合理缩进每行。左对齐不受支持。它还会尝试检测可打印字符的列表并将它们输出为字符串。Unicode转换修饰符用于确定可打印的字符，例如：

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

如果l指定了修饰符，则不会检测可打印的字符列表，例如：

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

如果指定了Unicode转换修饰符，那么看起来像UTF-8编码字符串的二进制文件将与字符串语法一起输出：

9> io:fwrite("~p~n",[[1024]]).
[1024]
10> io:fwrite("~tp~n",[[1024]]).
"\x{400}"
11> io:fwrite("~tp~n", [<<128,128>>]).
<<128,128>>
12> io:fwrite("~tp~n", [<<208,128>>]).
<<"\x{400}"/utf8>>
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.打印一个前导短划线用于负整数。

精度字段选择基地，例如：

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 exit: {badarg,[{io,format,[<0.22.0>,"~s","A"]},
                            {erl_eval,do_apply,5},
                            {shell,exprs,6},
                            {shell,eval_exprs,6},
                            {shell,eval_loop,3}]}
     in function  io:o_request/2

在这个例子中，试图借助字符串格式指令输出单个字符65 "~s"。

fread(Prompt, Format) -> Result

fread(IoDevice, Prompt, Format) -> Result

类型

从标准输入（IoDevice）读取字符，用提示提示。根据格式解释字符。格式包含指导输入解释的控制序列。

Format 可以包含以下内容：

空格字符（空格，制表符和换行符）会导致输入被读入下一个非空白字符。

-  Character `*` is an optional return suppression character. It provides a method to specify a field that is to be omitted.

-  `F` is the `field width` of the input field.

-  `M` is an optional translation modifier (of which `t` is the only supported, meaning Unicode translation).

-  `C` determines the type of control sequence.

除非另有说明，否则所有控制序列都忽略前导空白。输入字段不能超过一行。

可用的控制序列：

~ 单个~预计在输入。

d 预计有一个十进制整数。

u 预计基数为2-36的无符号整数。字段宽度参数用于指定基数。领先的空白字符不会被跳过。

- 预计可选的符号字符。符号字符-给出返回值-1。标志字符+或没有给出1。字段宽度参数被忽略。领先的空白字符不会被跳过。

#"16#ffff"预计将使用基于Erlang风格的基本前缀（例如，）的基础2-36中的整数。

f 预计浮点数。它必须遵循Erlang浮点数语法。

s 读取一串非空白字符。如果指定了字段宽度，则会读取该字符数，并删除所有尾随的空白字符。一个Erlang字符串（字符列表）被返回。

如果Unicode转换生效（~ts），则接受字符> 255，否则不接受。使用翻译修饰符时，返回的列表可能因此也包含整数> 255：

1> io：fread（“Prompt>”，“〜s”）。提示> <在latin1范围之外的字符不能在此介质中打印> {error，{fread，string}} 2> io：fread（“Prompt>”，“〜ts”）。提示> <超出latin1范围的字符不能在此媒体中打印> {ok，[1091,1085,1080,1094,1086,1076,1077]}

a 与s类似，但生成的字符串被转换为原子。

c 读取等于字段宽度的字符数（默认值为1）并以Erlang字符串形式返回。但是，前导和尾随空白字符不会像它们一样被省略s。所有字符都会返回。

Unicode转换修饰符的工作原理如下s：

1> io:fread("Prompt> ","~c"). Prompt> <Character beyond latin1 range not printable in this medium> {error,{fread,string}} 2> io:fread("Prompt> ","~tc"). Prompt> <Character beyond latin1 range not printable in this medium> {ok,[1091]}

l 返回到此为止扫描的字符数，包括空格字符。

该函数返回：

{ok, Terms} 读取成功并且Terms是成功匹配和读取项目的列表。

eof 遇到文件结尾。

{error, FreadError} 阅读失败且FreadError给出错误提示。

{error, ErrorDescription} 读取操作失败，参数ErrorDescription给出错误提示。

例子：

20> io:fread('enter>', "~f~f~f").
enter>1.9 35.5e3 15.0
{ok,[1.9,3.55e4,15.0]}
21> io:fread('enter>', "~10f~d").
enter>     5.67899
{ok,[5.678,99]}
22> io:fread('enter>', ":~10s:~10c:").
enter>:   alan   :   joe    :
{ok, ["alan", "   joe    "]}

get_chars(Prompt, Count) -> Data | server_no_data()

get_chars(IoDevice, Prompt, Count) -> Data | server_no_data()

类型

从标准输入（IoDevice）读取计数字符，用提示提示。

该函数返回：

Data

输入的字符。如果I / O设备支持Unicode，则数据可以表示代码点> 255（latin1范围）。如果I / O服务器设置为传递二进制文件，则它们使用UTF-8编码（无论I / O设备是否支持Unicode）。

eof

遇到文件结尾。

{error, ErrorDescription}

其他（罕见）错误情况，如{error, estale}从NFS文件系统读取。

get_line(Prompt) -> Data | server_no_data()

get_line(IoDevice, Prompt) -> Data | server_no_data()

类型

从标准输入（IoDevice）读取一行，并用提示提示。

该函数返回：

Data

行中的字符由换行符（或文件结尾）终止。如果I / O设备支持Unicode，则数据可以表示代码点> 255（latin1范围）。如果I / O服务器设置为提供二进制文件，则它们以UTF-8编码（无论I / O设备是否支持Unicode）。

eof

遇到文件结尾。

{error, ErrorDescription}

其他（罕见）错误情况，如{error, estale}从NFS文件系统读取。

getopts() -> [opt_pair()] | {error, Reason}

getopts(IoDevice) -> [opt_pair()] | {error, Reason}

类型

请求特定I / O设备的所有可用选项及其当前值，例如：

1> {ok,F} = file:open("/dev/null",[read]).
{ok,<0.42.0>}
2> io:getopts(F).
[{binary,false},{encoding,latin1}]

这里文件I / O服务器返回一个文件的所有可用选项，它们是预期的选项，encoding和binary。但是，标准shell有更多的选择：

3> io:getopts().
[{expand_fun,#Fun<group.0.120017273>},
 {echo,true},
 {binary,false},
 {encoding,unicode}]

可以看出，这个例子是在终端支持Unicode输入和输出的环境中运行的。

nl() -> ok

nl(IoDevice) -> ok

类型

将新行写入标准输出（IoDevice）。

parse_erl_exprs(Prompt) -> Result

parse_erl_exprs(IoDevice, Prompt) -> Result

parse_erl_exprs(IoDevice, Prompt, StartLocation) -> Result

parse_erl_exprs(IoDevice, Prompt, StartLocation, Options) ->

结果

类型

从标准输入（IoDevice）读取数据，并用Prompt提示。从位置StartLocation（1）开始阅读。参数选项作为参数传递给函数erl_scan的选项：tokens / 4。数据被标记并解析，就好像它是一系列Erlang表达式，直到达到最终点（。）。

该函数返回：

{ok, ExprList, EndLocation}

解析是成功的。

{eof, EndLocation}

标记器遇到文件结尾。

eof

I / O服务器遇到文件结尾。

{error, ErrorInfo, ErrorLocation}

标记或分析时发生错误。

{error, ErrorDescription}

其他（罕见）错误情况，如{error, estale}从NFS文件系统读取。

例：

25> io:parse_erl_exprs('enter>').
enter>abc(), "hey".
{ok, [{call,1,{atom,1,abc},[]},{string,1,"hey"}],2}
26> io:parse_erl_exprs ('enter>').
enter>abc("hey".
{error,{1,erl_parse,["syntax error before: ",["'.'"]]},2}

parse_erl_form(Prompt) -> Result

parse_erl_form(IoDevice, Prompt) -> Result

parse_erl_form(IoDevice, Prompt, StartLocation) -> Result

parse_erl_form(IoDevice, Prompt, StartLocation, Options) -> Result

类型

从标准输入（IoDevice）读取数据，并用Prompt提示。从位置StartLocation（1）开始阅读。参数选项作为参数传递给函数erl_scan的选项：tokens / 4。将数据标记并解析，就好像它是Erlang格式（Erlang源文件中的有效Erlang表达式之一），直到达到最终点（。）。

该函数返回：

{ok, AbsForm, EndLocation}

解析是成功的。

{eof, EndLocation}

标记器遇到文件结尾。

eof

I / O服务器遇到文件结尾。

{error, ErrorInfo, ErrorLocation}

标记或分析时发生错误。

{error, ErrorDescription}

其他（罕见）错误情况，如{error, estale}从NFS文件系统读取。

printable_range() -> unicode | latin1

返回用户请求的可打印Unicode字符范围。

用户可以请求一系列字符，这些字符在被shell和格式化函数启发式检测字符串时被认为是可打印的。这是通过在启动Erlang时提供+ pc <range>来完成的。

唯一有效的值<range>是latin1和unicode。latin1意味着只有代码点<256（除了控制字符等）被认为是可打印的。unicode意味着所有Unicode字符范围内的所有可打印字符都被I / O功能视为可打印的。

默认情况下，Erlang被启动，只有latin1字符范围表示整数列表是一个字符串。

使用该设置最简单的方法是调用io_lib:printable_list/1，该函数使用此函数的返回值来确定列表是否是可打印字符的字符串。

注意

在未来的版本中，该函数可能会返回更多值和范围。为避免兼容性问题，建议使用功能io_lib:printable_list/1。

put_chars(CharData) -> ok

put_chars(IoDevice, CharData) -> ok

类型

将字符写入CharDataI / O服务器（IoDevice）。

read(Prompt) -> Result

read(IoDevice, Prompt) -> Result

类型

从标准输入（IoDevice）中读取一个术语术语，用Prompt提示。

该函数返回：

{ok, Term}

解析是成功的。

eof

遇到文件结尾。

{error, ErrorInfo}

解析失败。

{error, ErrorDescription}

其他（罕见）错误情况，如{error, estale}从NFS文件系统读取。

read(IoDevice, Prompt, StartLocation) -> Result

read(IoDevice, Prompt, StartLocation, Options) -> Result

类型

从IoDevice中读取术语Term，并用Prompt提示。阅读从位置StartLocation开始。参数选项作为参数传递给函数erl_scan的选项：tokens / 4。

该函数返回：

{ok, Term, EndLocation}

解析是成功的。

{eof, EndLocation}

遇到文件结尾。

{error, ErrorInfo, ErrorLocation}

解析失败。

{error, ErrorDescription}

其他（罕见）错误情况，如{error, estale}从NFS文件系统读取。

rows() -> {ok, integer() >= 1} | {error, enotsup}

rows(IoDevice) -> {ok, integer() >= 1} | {error, enotsup}

类型

检索行数IoDevice（即终端的高度）。该功能只对终端设备成功，对于该功能返回的所有其他I / O设备{error, enotsup}。

scan_erl_exprs(Prompt) -> Result

scan_erl_exprs(Device, Prompt) -> Result

scan_erl_exprs(Device, Prompt, StartLocation) -> Result

scan_erl_exprs(Device, Prompt, StartLocation, Options) -> Result

类型

从标准输入（IoDevice）读取数据，并用Prompt提示。阅读从位置StartLocation（1）开始。参数选项作为参数传递给函数erl_scan的选项：tokens / 4。数据被标记为好像它是一系列Erlang表达式，直到达到最终点（。）。该令牌也被返回。

该函数返回：

{ok, Tokens, EndLocation}

标记化成功。

{eof, EndLocation}

标记器遇到文件结尾。

eof

I / O服务器遇到文件结尾。

{error, ErrorInfo, ErrorLocation}

标记化时发生错误。

{error, ErrorDescription}

其他（罕见）错误情况，例如从NFS文件系统读取时出现{error，estale}。

例：

23> io:scan_erl_exprs('enter>').
enter>abc(), "hey".
{ok,[{atom,1,abc},{'(',1},{')',1},{',',1},{string,1,"hey"},{dot,1}],2}
24> io:scan_erl_exprs('enter>').
enter>1.0er.
{error,{1,erl_scan,{illegal,float}},2}

scan_erl_form(Prompt) -> Result

scan_erl_form(IoDevice, Prompt) -> Result

scan_erl_form(IoDevice, Prompt, StartLocation) -> Result

scan_erl_form(IoDevice, Prompt, StartLocation, Options) -> Result

类型

从标准输入（IoDevice）读取数据，并用Prompt提示。从位置StartLocation（1）开始阅读。参数选项作为参数传递给函数erl_scan的选项：tokens / 4。将数据标记为好像它是Erlang格式（Erlang源文件中的有效Erlang表达式之一），直到达到最终点（。）。最后一个标记也被返回。

返回值与scan_erl_exprs / 1,2,3,4相同。

setopts(Opts) -> ok | {error, Reason}

setopts(IoDevice, Opts) -> ok | {error, Reason}

类型

设置标准I / O设备的选项（IoDevice）。

可能的选项和值取决于I / O设备。有关特定I / O设备上支持的选项及其当前值的列表，请使用函数getopts/1。

OTP I / O设备支持的选项和值如下所示：

binary**,** list**, or** {binary, boolean()}

如果以二进制模式（二进制或{binary，true}）设置，I / O服务器会发送二进制数据（以UTF-8编码）作为get_line，get_chars和get_until请求的答案（有关详细信息，请参阅部分Erlang I / O协议）在用户指南）。即时效果是get_chars / 2,3和get_line / 1,2返回UTF-8二进制文件而不是受影响的I / O设备的字符列表。

默认情况下，OTP中的所有I / O设备均设置为list模式。但是，I / O函数可以处理这些模式中的任何一种，因此其他用户编写的模块也应该像I / O服务器的客户端一样运行。

标准shell（group.erl），“oldshell”（user.erl）和文件I / O服务器支持此选项。

{echo, boolean()}

表示终端是否回显输入。仅支持标准外壳I / O服务器（group.erl）

{expand_fun, expand_fun()}

提供一个像Erlang shell一样的tab完成（扩展）功能。当用户按Tab键时调用此函数。在调用行读功能时，扩展处于活动状态，例如get_line/1,2。

该函数被调用当前行，直到光标，作为反向字符串。它是返回一个三元组：{yes|no, string(), [string(), ...]}。如果第一个元素发出嘟嘟声no，否则扩展是无声的; 第二个是将在光标位置输入的字符串; 第三个是可能的扩展列表。如果这个列表不是空的，它将被打印并且当前输入行再次被写入。

简单的例子（除了空行外的任何东西都会发出哔哔声"quit"）

fun("") -> {yes, "quit", []};
   (_) -> {no, "", ["quit"]} end

该选项仅被标准shell（group.erl）支持。

{encoding, latin1 | unicode}

指定如何从I / O设备输入或输出字符，这意味着，例如，终端设置为处理Unicode输入和输出或设置文件以处理UTF-8数据编码。

该选项不影响从I / O函数返回数据的方式，也不影响I / O协议如何发送数据，它只影响I / O设备如何处理Unicode字符到“物理”设备。

标准shell 在系统启动时设置unicode或latin1编码。编码设置与的帮助下LANG或LC_CTYPE在类Unix系统环境变量或其他系统上的其他手段。因此，{encoding, unicode}如果I / O设备支持，用户可以输入Unicode字符并且I / O设备处于模式。如果运行系统的假设是错误的，则可以通过设置此选项来更改模式。

Erlang以“-oldshell”或“-noshell”标志启动时使用的I / O设备默认设置为latin1编码，这意味着任何字符> codepoint 255都会被转义，并且该输入应该是普通的8位ISO Latin-1的。如果编码更改为Unicode，则标准文件描述符的输入和输出采用UTF-8格式（不论操作系统如何）。

文件也可以被{encoding, unicode}设置，这意味着数据被写入并读取为UTF-8。更多的编码是可能的文件，见下文。

{encoding, unicode | latin1}由标准shell（group.erl包括werlWindows），'oldshell'（user.erl）和文件I / O服务器支持。

{encoding, utf8 | utf16 | utf32 | {utf16,big} | {utf16,little} | {utf32,big} | {utf32,little}}

对于磁盘文件，可以将编码设置为各种UTF变体。这具有这样的效果，即预期数据将作为文件中的指定编码读取，并且数据以指定的编码写入磁盘文件。

{encoding, utf8}与{encoding, unicode}文件具有相同的效果。

扩展编码仅支持磁盘文件（由函数打开file:open/2）。

write(Term) -> ok

write(IoDevice, Term) -> ok

类型

将术语写入Term标准输出（IoDevice）。

标准输入/输出

所有的Erlang进程都有一个默认的标准I / O设备。当在此模块的函数调用中未指定IoDevice参数时使用此设备。但是，有时需要使用引用默认I / O设备的显式IoDevice参数。可以访问文件或默认I / O设备的功能就是这种情况。原子standard_io有这个特殊的含义。以下示例说明了这一点：

27> io:read('enter>').
enter>foo.
{ok,foo}
28> io:read(standard_io, 'enter>').
enter>bar.
{ok,bar}

总是有一个过程注册下的名字user。这可以用于将输出发送给用户。

标准错误

在某些情况下，特别是当标准输出重定向时，访问特定于错误消息的I / O服务器可能很方便。I / O设备standard_error可用于将输出引导至当前操作系统认为适合的错误输出的I / O设备。类Unix操作系统上的示例：

$ erl -noshell -noinput -eval 'io:format(standard_error,"Error: ~s~n",["error 11"]),'\
'init:stop().' > /dev/null
Error: error 11

错误信息

在ErrorInfo该模块中提到的是标准ErrorInfo是从所有的I / O模块返回的结构。它有以下格式：

{ErrorLocation, Module, ErrorDescriptor}

通过以下调用获取描述错误的字符串：

Module:format_error(ErrorDescriptor)