2  顺序编程

2  顺序编程

大多数操作系统都有一个命令解释器或 shell，UNIX 和 Linux 有很多，Windows 有命令提示符。Erlang 有自己的 shell，可以在其中直接编写 Erlang 代码段，并进行评估以查看结果（参见 STDLIB 中的 shell(3) 手册页）。

通过在您的操作系统中启动一个 shell 或命令解释器并键入 erl 来启动 Erlang shell（在 Linux 或 UNIX 中）。您将看到类似以下内容。

% erl
Erlang R15B (erts-5.9.1) [source] [smp:8:8] [rq:8] [async-threads:0] [hipe] [kernel-poll:false]

Eshell V5.9.1  (abort with ^G)
1>

在 shell 中键入“2 + 5.”，然后按 Enter（回车键）。请注意，您通过以句点“.”和回车键结束来告诉 shell 您已完成代码输入。

1> 2 + 5.
7
2>

如所示，Erlang shell 对可以输入的行进行编号（如 1> 2>），并且它正确地表示 2 + 5 等于 7。如果您在 shell 中输入错误，可以使用退格键进行删除，就像在大多数 shell 中一样。shell 中还有更多编辑命令（参见 ERTS 用户指南中的 tty - 命令行界面）。

（请注意，以下示例中 shell 给出的许多行号是不连续的。这是因为本教程是在单独的会话中编写和代码测试的）。

以下是一个更复杂的计算

2> (42 + 77) * 66 / 3.
2618.0

请注意方括号、乘法运算符“*”和除法运算符“/”的使用，就像在普通算术中一样（参见 表达式）。

按 Ctrl-C 关闭 Erlang 系统和 Erlang shell。

将显示以下输出

BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
       (v)ersion (k)ill (D)b-tables (d)istribution
a
%

键入“a”退出 Erlang 系统。

另一种关闭 Erlang 系统的方法是输入 halt()

3> halt().
%

如果您只能从 shell 中运行代码，那么编程语言就没有多大用处。所以这里有一个小型的 Erlang 程序。使用合适的文本编辑器将其输入到名为 tut.erl 的文件中。文件名 tut.erl 非常重要，并且它也必须与您启动 erl 的目录相同）。如果您幸运的话，您的编辑器有 Erlang 模式，可以让您更轻松地输入和格式化代码（参见工具用户指南中的 Emacs 的 Erlang 模式），但没有它您也可以完全正常地操作。以下是需要输入的代码

-module(tut).
-export([double/1]).

double(X) ->
    2 * X.

不难猜到，该程序将数字的值加倍。代码的前两行将在后面介绍。让我们编译该程序。这可以在 Erlang shell 中完成，如下所示，其中 c 表示编译

3> c(tut).
{ok,tut}

{ok,tut} 表示编译成功。如果显示“error”，则表示您输入的文本中存在错误。附加的错误消息会提示错误所在，以便您可以修改文本，然后再次尝试编译程序。

现在运行该程序

4> tut:double(10).
20

正如预期的那样，10 的两倍是 20。

现在让我们回到代码的前两行。Erlang 程序被写入文件。每个文件都包含一个 Erlang 模块。模块中的第一行代码是模块名称（参见 模块）

-module(tut).

因此，该模块称为 tut。请注意行末的句点“.”。用于存储模块的文件必须与模块具有相同的名称，但扩展名为“.erl”。在本例中，文件名是 tut.erl。在使用另一个模块中的函数时，使用语法 module_name:function_name(arguments)。因此，以下表示调用模块 tut 中的函数 double，并带有一个参数“10”。

4> tut:double(10).

第二行表示模块 tut 包含一个名为 double 的函数，该函数接受一个参数（在本例中为 X）

-export([double/1]).

第二行还表示可以从模块 tut 之外调用此函数。稍后将详细介绍。同样，请注意行末的“.”。

现在来介绍一个更复杂的示例，即一个数字的阶乘。例如，4 的阶乘是 4 * 3 * 2 * 1，等于 24。

将以下代码输入到名为 tut1.erl 的文件中

-module(tut1).
-export([fac/1]).

fac(1) ->
    1;
fac(N) ->
    N * fac(N - 1).

所以这是一个名为 tut1 的模块，它包含一个名为 fac> 的函数，该函数接受一个参数 N。

第一部分表示 1 的阶乘为 1。

fac(1) ->
    1;

请注意，这部分以分号“;”结尾，表示函数 fac> 还有更多内容。

第二部分表示 N 的阶乘等于 N 乘以 N - 1 的阶乘

fac(N) ->
    N * fac(N - 1).

请注意，这部分以句点“.”结尾，表示该函数没有更多部分。

编译该文件

5> c(tut1).
{ok,tut1}

现在计算 4 的阶乘。

6> tut1:fac(4).
24

这里调用了模块 tut1 中的函数 fac>，参数为 4。

一个函数可以有多个参数。让我们用一个函数来扩展模块 tut1，该函数用来乘以两个数字

-module(tut1).
-export([fac/1, mult/2]).

fac(1) ->
    1;
fac(N) ->
    N * fac(N - 1).

mult(X, Y) ->
    X * Y.

请注意，还需要扩展 -export 行，以包含有关另一个函数 mult 的信息，该函数有两个参数。

编译

7> c(tut1).
{ok,tut1}

试用新的函数 mult

8> tut1:mult(3,4).
12

在本例中，这些数字是整数，代码中的函数参数 N、X 和 Y 被称为变量。变量必须以大写字母开头（参见 变量）。变量示例包括 Number、ShoeSize 和 Age。

原子是 Erlang 中的另一种数据类型。原子以小写字母开头（参见 原子），例如，charles、centimeter 和 inch。原子只是名称，仅此而已。它们不像变量，变量可以有值。

将下一个程序输入到名为 tut2.erl 的文件中）。它可以用于在英寸和厘米之间进行转换

-module(tut2).
-export([convert/2]).

convert(M, inch) ->
    M / 2.54;

convert(N, centimeter) ->
    N * 2.54.

编译

9> c(tut2).
{ok,tut2}

测试

10> tut2:convert(3, inch).
1.1811023622047243
11> tut2:convert(7, centimeter).
17.78

请注意，这里引入了小数（浮点数），但没有进行解释。希望您能理解这一点。

让我们看看如果在 convert 函数中输入了除 centimeter 或 inch 之外的其他内容，会发生什么

12> tut2:convert(3, miles).
** exception error: no function clause matching tut2:convert(3,miles) (tut2.erl, line 4)

convert 函数的两个部分被称为其子句。如所示，miles 不属于任何一个子句。Erlang 系统无法匹配任何一个子句，因此返回错误消息 function_clause。shell 会很好地格式化错误消息，但错误元组会保存在 shell 的历史记录列表中，可以通过 shell 命令 v/1 输出

13> v(12).
{'EXIT',{function_clause,[{tut2,convert,
                                [3,miles],
                                [{file,"tut2.erl"},{line,4}]},
                          {erl_eval,do_apply,6,
                                    [{file,"erl_eval.erl"},{line,677}]},
                          {shell,exprs,7,[{file,"shell.erl"},{line,687}]},
                          {shell,eval_exprs,7,[{file,"shell.erl"},{line,642}]},
                          {shell,eval_loop,3,
                                 [{file,"shell.erl"},{line,627}]}]}}

现在，tut2 程序的编程风格不太好。考虑一下

tut2:convert(3, inch).

这是否意味着 3 是以英寸为单位？或者它是否意味着 3 是以厘米为单位，并且需要转换为英寸？Erlang 有一种方法可以将事物组合在一起，使其更易于理解。这些组合称为元组，并用花括号“{”和“}”括起来。

因此，{inch,3} 表示 3 英寸，{centimeter,5} 表示 5 厘米。现在让我们编写一个新的程序，用于将厘米转换为英寸，反之亦然。将以下代码输入到名为 tut3.erl 的文件中）

-module(tut3).
-export([convert_length/1]).

convert_length({centimeter, X}) ->
    {inch, X / 2.54};
convert_length({inch, Y}) ->
    {centimeter, Y * 2.54}.

编译和测试

14> c(tut3).
{ok,tut3}
15> tut3:convert_length({inch, 5}).
{centimeter,12.7}
16> tut3:convert_length(tut3:convert_length({inch, 5})).
{inch,5.0}

请注意第 16 行，5 英寸被转换为厘米，然后又转换回英寸，令人放心的是，最终得到原始值。也就是说，函数的参数可以是另一个函数的结果。考虑一下第 16 行（上面）是如何工作的。传递给函数 convert_length 的参数 {inch,5} 首先与 convert_length 的第一个头部子句匹配，即 convert_length({centimeter,X})。可以看出，{centimeter,X} 与 {inch,5} 不匹配（头部是“->”之前的部分）。由于匹配失败，让我们尝试下一个子句的头部，即 convert_length({inch,Y})。这匹配成功，Y 获得了值 5。

元组可以包含两个以上的部分，实际上可以包含任意数量的部分，并且可以包含任何有效的 Erlang 项。例如，要表示世界各地不同城市的温度

{moscow, {c, -10}}
{cape_town, {f, 70}}
{paris, {f, 28}}

元组中的项数是固定的。元组中的每个项都称为元素。在元组 {moscow,{c,-10}} 中，元素 1 是 moscow，元素 2 是 {c,-10}。这里 c 代表摄氏度，f 代表华氏度。

元组可以将事物组合在一起，但还需要表示事物的列表。Erlang 中的列表用方括号“["和"]”括起来。例如，世界各地不同城市的温度列表可以为

[{moscow, {c, -10}}, {cape_town, {f, 70}}, {stockholm, {c, -4}},
 {paris, {f, 28}}, {london, {f, 36}}]

请注意，此列表很长，无法在一行中显示。这没关系，Erlang 允许在所有“合理的位置”换行，但不允许在原子、整数和其他内容的中间换行。

查看列表部分的一个有用方法是使用“|”。这最好用 shell 中的示例来解释

17> [First |TheRest] = [1,2,3,4,5].
[1,2,3,4,5]
18> First.
1
19> TheRest.
[2,3,4,5]

为了将列表的第一个元素与列表的其余部分分开，使用 |。 First 的值为 1，TheRest 的值为 [2,3,4,5]。

另一个示例

20> [E1, E2 | R] = [1,2,3,4,5,6,7].
[1,2,3,4,5,6,7]
21> E1.
1
22> E2.
2
23> R.
[3,4,5,6,7]

这里您看到了使用 | 从列表中获取前两个元素。如果您尝试从列表中获取比列表中的元素更多的元素，则会返回错误。请注意，列表没有元素的特殊情况，即 []

24> [A, B | C] = [1, 2].
[1,2]
25> A.
1
26> B.
2
27> C.
[]

在前面的示例中，使用了新的变量名，而不是重复使用旧的变量名：First、TheRest、E1、E2、R、A、B 和 C。这样做的原因是，变量在其上下文（作用域）中只能赋值一次。稍后将详细介绍。

以下示例展示了如何查找列表的长度。将以下代码输入到名为 tut4.erl 的文件中）

-module(tut4).

-export([list_length/1]).

list_length([]) ->
    0;    
list_length([First | Rest]) ->
    1 + list_length(Rest).

编译和测试

28> c(tut4).
{ok,tut4}
29> tut4:list_length([1,2,3,4,5,6,7]).
7

解释

list_length([]) ->
    0;

空列表的长度显然是 0。

list_length([First | Rest]) ->
    1 + list_length(Rest).

包含第一个元素 First 和剩余元素 Rest 的列表的长度为 1 加上 Rest 的长度。

(仅供高级读者参考：这不是尾递归，有更好的方法来编写此函数。)

通常，元组用于其他语言中使用“记录”或“结构体”的地方。另外，列表用于表示大小可变的事物，即在其他语言中使用链表的地方。

Erlang 没有字符串数据类型。相反，字符串可以通过 Unicode 字符列表来表示。例如，这意味着列表 [97,98,99] 等效于 "abc"。Erlang shell 很“聪明”，它会猜测你指的是哪个列表，并以它认为最合适的形式输出它，例如

30> [97,98,99].
"abc"

地图是一组键值关联。这些关联用 "#{" 和 "}" 封装起来。要创建从 "key" 到值 42 的关联

> #{ "key" => 42 }.
#{"key" => 42}

让我们直接从使用一些有趣功能的示例开始。

以下示例展示了如何使用地图引用颜色和 alpha 通道来计算 alpha 混合。将代码输入名为 color.erl 的文件中。

-module(color).

-export([new/4, blend/2]).

-define(is_channel(V), (is_float(V) andalso V >= 0.0 andalso V =< 1.0)).

new(R,G,B,A) when ?is_channel(R), ?is_channel(G),
                  ?is_channel(B), ?is_channel(A) ->
    #{red => R, green => G, blue => B, alpha => A}.

blend(Src,Dst) ->
    blend(Src,Dst,alpha(Src,Dst)).

blend(Src,Dst,Alpha) when Alpha > 0.0 ->
    Dst#{
        red   := red(Src,Dst) / Alpha,
        green := green(Src,Dst) / Alpha,
        blue  := blue(Src,Dst) / Alpha,
        alpha := Alpha
    };
blend(_,Dst,_) ->
    Dst#{
        red   := 0.0,
        green := 0.0,
        blue  := 0.0,
        alpha := 0.0
    }.

alpha(#{alpha := SA}, #{alpha := DA}) ->
    SA + DA*(1.0 - SA).

red(#{red := SV, alpha := SA}, #{red := DV, alpha := DA}) ->
    SV*SA + DV*DA*(1.0 - SA).
green(#{green := SV, alpha := SA}, #{green := DV, alpha := DA}) ->
    SV*SA + DV*DA*(1.0 - SA).
blue(#{blue := SV, alpha := SA}, #{blue := DV, alpha := DA}) ->
    SV*SA + DV*DA*(1.0 - SA).

编译和测试

> c(color).
{ok,color}
> C1 = color:new(0.3,0.4,0.5,1.0).
#{alpha => 1.0,blue => 0.5,green => 0.4,red => 0.3}
> C2 = color:new(1.0,0.8,0.1,0.3).
#{alpha => 0.3,blue => 0.1,green => 0.8,red => 1.0}
> color:blend(C1,C2).
#{alpha => 1.0,blue => 0.5,green => 0.4,red => 0.3}
> color:blend(C2,C1).
#{alpha => 1.0,blue => 0.38,green => 0.52,red => 0.51}

此示例需要一些解释

-define(is_channel(V), (is_float(V) andalso V >= 0.0 andalso V =< 1.0)).

首先定义一个宏 is_channel 来帮助进行守卫测试。这仅仅是为了方便，并减少语法混乱。有关宏的更多信息，请参阅 预处理器。

new(R,G,B,A) when ?is_channel(R), ?is_channel(G),
                  ?is_channel(B), ?is_channel(A) ->
    #{red => R, green => G, blue => B, alpha => A}.

函数 new/4 创建一个新的地图项，并让键 red、green、blue 和 alpha 与初始值关联。在这种情况下，只允许介于 0.0 和 1.0 之间（包括 0.0 和 1.0）的浮点值，如每个参数的 ?is_channel/1 宏所确保的。创建新地图时，只允许 => 运算符。

通过调用 blend/2 对 new/4 创建的任何颜色项，可以根据两个地图项计算出结果颜色。

blend/2 的第一步是计算结果 alpha 通道

alpha(#{alpha := SA}, #{alpha := DA}) ->
    SA + DA*(1.0 - SA).

使用 := 运算符获取与键 alpha 关联的值，用于两个参数。地图中的其他键将被忽略，只需要键 alpha 并对其进行检查。

函数 red/2、blue/2 和 green/2 也一样。

red(#{red := SV, alpha := SA}, #{red := DV, alpha := DA}) ->
    SV*SA + DV*DA*(1.0 - SA).

不同之处在于，它会检查每个地图参数中的两个键。其他键将被忽略。

最后，让我们在 blend/3 中返回结果颜色

blend(Src,Dst,Alpha) when Alpha > 0.0 ->
    Dst#{
        red   := red(Src,Dst) / Alpha,
        green := green(Src,Dst) / Alpha,
        blue  := blue(Src,Dst) / Alpha,
        alpha := Alpha
    };

使用 := 运算符，用新的通道值更新 Dst 地图。更新现有键的新值的语法是使用 := 运算符。

Erlang 有许多标准模块可以帮助你完成任务。例如，模块 io 包含许多有助于进行格式化输入/输出的函数。要查找有关标准模块的信息，可以在操作系统 shell 或命令提示符（启动 erl 的地方）中使用命令 erl -man。尝试以下操作系统 shell 命令

% erl -man io
ERLANG MODULE DEFINITION                                    io(3)

MODULE
     io - Standard I/O Server Interface Functions

DESCRIPTION
     This module provides an  interface  to  standard  Erlang  IO
     servers. The output functions all return ok if they are suc-
     ...

如果你的系统无法运行，则文档包含在 Erlang/OTP 版本中，以 HTML 格式提供。你也可以从 www.erlang.se（商业 Erlang）或 www.erlang.org（开源）网站上以 HTML 格式阅读文档或以 PDF 格式下载文档。例如，对于 Erlang/OTP 版本 R9B

https://erlang.org.cn/doc/r9b/doc/index.html

能够在示例中进行格式化输出是件好事，因此下一个示例展示了如何使用 io:format 函数的简单方法。与所有其他导出函数一样，你可以在 shell 中测试 io:format 函数

31> io:format("hello world~n", []).
hello world
ok
32> io:format("this outputs one Erlang term: ~w~n", [hello]).
this outputs one Erlang term: hello
ok
33> io:format("this outputs two Erlang terms: ~w~w~n", [hello, world]).
this outputs two Erlang terms: helloworld
ok
34> io:format("this outputs two Erlang terms: ~w ~w~n", [hello, world]).
this outputs two Erlang terms: hello world
ok

函数 format/2（即带有两个参数的 format）接受两个列表。第一个列表几乎总是用 " " 括起来的列表。此列表按原样打印出来，但每个 ~w 会被从第二个列表中按顺序获取的项替换。每个 ~n 会被换行符替换。io:format/2 函数本身在一切按计划进行时会返回原子 ok。与 Erlang 中的其他函数一样，它会在发生错误时崩溃。这不是 Erlang 的错误，而是故意的策略。Erlang 拥有复杂的错误处理机制，将在后面介绍。作为练习，尝试让 io:format 崩溃，这应该并不难。但请注意，尽管 io:format 崩溃了，但 Erlang shell 本身并没有崩溃。

现在让我们来看一个更大的示例，来巩固你到目前为止学到的知识。假设你有一个来自世界各地多个城市的温度读数列表。其中一些以摄氏度表示，一些以华氏度表示（如前面的列表）。首先让我们将它们全部转换为摄氏度，然后让我们整齐地打印数据。

%% This module is in file tut5.erl

-module(tut5).
-export([format_temps/1]).

%% Only this function is exported
format_temps([])->                        % No output for an empty list
    ok;
format_temps([City | Rest]) ->
    print_temp(convert_to_celsius(City)),
    format_temps(Rest).

convert_to_celsius({Name, {c, Temp}}) ->  % No conversion needed
    {Name, {c, Temp}};
convert_to_celsius({Name, {f, Temp}}) ->  % Do the conversion
    {Name, {c, (Temp - 32) * 5 / 9}}.

print_temp({Name, {c, Temp}}) ->
    io:format("~-15w ~w c~n", [Name, Temp]).
35> c(tut5).
{ok,tut5}
36> tut5:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},
{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).
moscow          -10 c
cape_town       21.11111111111111 c
stockholm       -4 c
paris           -2.2222222222222223 c
london          2.2222222222222223 c
ok

在查看此程序的工作原理之前，请注意代码中添加了一些注释。注释以 %-字符开头，一直持续到行尾。还要注意 -export([format_temps/1]). 行只包含函数 format_temps/1。其他函数是 **局部** 函数，即它们在模块 tut5 之外不可见。

还要注意，从 shell 测试程序时，输入分布在两行上，因为行太长了。

第一次调用 format_temps 时，City 获取值 {moscow,{c,-10}}，而 Rest 是列表的其余部分。因此，调用函数 print_temp(convert_to_celsius({moscow,{c,-10}}))。

以下是一个函数调用，convert_to_celsius({moscow,{c,-10}}) 作为函数 print_temp 的参数。当函数调用 **嵌套** 起来时，它们会从内到外执行（计算）。也就是说，首先计算 convert_to_celsius({moscow,{c,-10}})，它会给出值 {moscow,{c,-10}}，因为温度已经是摄氏度了。然后计算 print_temp({moscow,{c,-10}})。函数 convert_to_celsius 的工作原理类似于前一个示例中的 convert_length 函数。

print_temp 只是以类似于上面描述的方式调用 io:format。请注意，~-15w 表示以 15 的字段长度（宽度）打印“项”，并向左对齐。（参见 io(3)）STDLIB 中的手册页。

现在用列表的其余部分作为参数调用 format_temps(Rest)。这种做法类似于其他语言中的循环结构。（是的，这是递归，但不要担心。）因此，再次调用相同的 format_temps 函数，这一次 City 获取值 {cape_town,{f,70}}，并重复之前的过程。重复此过程，直到列表变为空，即 []，这会导致第一个子句 format_temps([]) 匹配。这只是简单地返回（结果是）原子 ok，因此程序结束。

在这样的列表中找到最大温度和最小温度可能很有用。在扩展程序以执行此操作之前，让我们看看用于查找列表中元素的最大值的函数

-module(tut6).
-export([list_max/1]).

list_max([Head|Rest]) ->
   list_max(Rest, Head).

list_max([], Res) ->
    Res;
list_max([Head|Rest], Result_so_far) when Head > Result_so_far ->
    list_max(Rest, Head);
list_max([Head|Rest], Result_so_far)  ->
    list_max(Rest, Result_so_far).
37> c(tut6).
{ok,tut6}
38> tut6:list_max([1,2,3,4,5,7,4,3,2,1]).
7

首先请注意，两个函数具有相同的名称，即 list_max。但是，它们每个都接受不同数量的参数（参数）。在 Erlang 中，它们被认为是完全不同的函数。如果你需要区分这些函数，请编写 Name/Arity，其中 Name 是函数名称，Arity 是参数数量，在本例中是 list_max/1 和 list_max/2。

在这个示例中，你遍历一个列表，并“携带”一个值，在本例中是 Result_so_far。list_max/1 只假设列表的最大值为列表的头部，并调用 list_max/2，并将列表的其余部分和头部值作为参数。在上面的示例中，这将是 list_max([2,3,4,5,7,4,3,2,1],1)。如果你尝试使用空列表来使用 list_max/1，或者尝试使用根本不是列表的东西来使用它，你将会导致错误。请注意，Erlang 的理念不是在发生此类错误的函数中处理这些错误，而是在其他地方处理它们。稍后将详细介绍。

在 list_max/2 中，你向下遍历列表，当 Head > Result_so_far 时，使用 Head 而不是 Result_so_far。when 是一个特殊词，用于在函数中的 -> 之前，用于表示只有在后面的测试为真时，才使用函数的这一部分。此类测试称为 **守卫**。如果守卫为假（即守卫失败），则尝试函数的下一部分。在本例中，如果 Head 不大于 Result_so_far，那么它必须小于或等于它。这意味着不需要在函数的下一部分上设置守卫。

守卫中一些有用的运算符是

  • < 小于
  • > 大于
  • == 等于
  • >= 大于或等于
  • =< 小于或等于
  • /= 不等于

（参见 守卫序列）。

要将上面的程序更改为一个计算列表中元素的最小值的程序，你只需要编写 < 而不是 >。（但最好将函数名称更改为 list_min。）

前面提到过，一个变量在其作用域内只能赋值一次。在上面的示例中，你看到 Result_so_far 被赋值了几次。这是可以的，因为每次调用 list_max/2 时，你都会创建一个新的作用域，可以将 Result_so_far 视为每个作用域中的一个不同的变量。

另一种创建和赋值变量的方法是使用匹配运算符 =。因此，如果你编写 M = 5，将创建一个名为 M 的变量，其值为 5。如果在同一个作用域中，你随后编写 M = 6，则会返回错误。在 shell 中尝试一下

39> M = 5.
5
40> M = 6.
** exception error: no match of right hand side value 6
41> M = M + 1.
** exception error: no match of right hand side value 6
42> N = M + 1.
6

匹配运算符的使用对于拆分 Erlang 项和创建新项特别有用。

43> {X, Y} = {paris, {f, 28}}.
{paris,{f,28}}
44> X.
paris
45> Y.
{f,28}

这里 X 获取值 paris，而 Y{f,28}。

如果你尝试使用另一个城市再次执行相同的操作，则会返回错误

46> {X, Y} = {london, {f, 36}}.
** exception error: no match of right hand side value {london,{f,36}}

变量还可以用于提高程序的可读性。例如，在上面的函数 list_max/2 中，你可以编写

list_max([Head|Rest], Result_so_far) when Head > Result_so_far ->
    New_result_far = Head,
    list_max(Rest, New_result_far);

这可能更清晰一些。

请记住，可以使用 | 运算符获取列表的头部

47> [M1|T1] = [paris, london, rome].
[paris,london,rome]
48> M1.
paris
49> T1.
[london,rome]

| 操作符也可以用于在列表前面添加一个头部。

50> L1 = [madrid | T1].
[madrid,london,rome]
51> L1.
[madrid,london,rome]

现在举一个在处理列表时的例子——反转列表的顺序。

-module(tut8).

-export([reverse/1]).

reverse(List) ->
    reverse(List, []).

reverse([Head | Rest], Reversed_List) ->
    reverse(Rest, [Head | Reversed_List]);
reverse([], Reversed_List) ->
    Reversed_List.
52> c(tut8).
{ok,tut8}
53> tut8:reverse([1,2,3]).
[3,2,1]

考虑 Reversed_List 是如何构建的。它最初为空列表 `[]`，然后依次从要反转的列表中取出头部并添加到 Reversed_List 中，如下所示。

reverse([1|2,3], []) =>
    reverse([2,3], [1|[]])

reverse([2|3], [1]) =>
    reverse([3], [2|[1])

reverse([3|[]], [2,1]) =>
    reverse([], [3|[2,1]])

reverse([], [3,2,1]) =>
    [3,2,1]

模块 lists 包含许多用于操作列表的函数，例如用于反转列表的函数。所以在编写列表操作函数之前，最好先检查一下是否已经为你编写了这样的函数（请参阅 STDLIB 中的 lists(3) 手册页）。

现在让我们回到城市和温度，但这次采用更结构化的方式。首先，我们将整个列表转换为摄氏度，如下所示。

-module(tut7).
-export([format_temps/1]).

format_temps(List_of_cities) ->
    convert_list_to_c(List_of_cities).

convert_list_to_c([{Name, {f, F}} | Rest]) ->
    Converted_City = {Name, {c, (F -32)* 5 / 9}},
    [Converted_City | convert_list_to_c(Rest)];

convert_list_to_c([City | Rest]) ->
    [City | convert_list_to_c(Rest)];

convert_list_to_c([]) ->
    [].

测试函数。

54> c(tut7).
{ok, tut7}.
55> tut7:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},
{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).
[{moscow,{c,-10}},
 {cape_town,{c,21.11111111111111}},
 {stockholm,{c,-4}},
 {paris,{c,-2.2222222222222223}},
 {london,{c,2.2222222222222223}}]

解释

format_temps(List_of_cities) ->
    convert_list_to_c(List_of_cities).

这里 format_temps/1 调用了 convert_list_to_c/1。 convert_list_to_c/1 从 List_of_cities 中取出头部，如果需要将其转换为摄氏度。| 操作符用于将（可能已经）转换后的头部添加到已转换的剩余列表中。

[Converted_City | convert_list_to_c(Rest)];

或者

[City | convert_list_to_c(Rest)];

这将一直进行，直到列表的结尾，即列表为空。

convert_list_to_c([]) ->
    [].

现在，当列表转换完成后，添加一个函数来打印它。

-module(tut7).
-export([format_temps/1]).

format_temps(List_of_cities) ->
    Converted_List = convert_list_to_c(List_of_cities),
    print_temp(Converted_List).

convert_list_to_c([{Name, {f, F}} | Rest]) ->
    Converted_City = {Name, {c, (F -32)* 5 / 9}},
    [Converted_City | convert_list_to_c(Rest)];

convert_list_to_c([City | Rest]) ->
    [City | convert_list_to_c(Rest)];

convert_list_to_c([]) ->
    [].

print_temp([{Name, {c, Temp}} | Rest]) ->
    io:format("~-15w ~w c~n", [Name, Temp]),
    print_temp(Rest);
print_temp([]) ->
    ok.
56> c(tut7).
{ok,tut7}
57> tut7:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},
{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).
moscow          -10 c
cape_town       21.11111111111111 c
stockholm       -4 c
paris           -2.2222222222222223 c
london          2.2222222222222223 c
ok

现在，必须添加一个函数来查找具有最高温度和最低温度的城市。下面的程序不是执行此操作最有效的方式，因为您需要遍历城市列表四次。但是，最好首先追求清晰度和正确性，只有在需要时才提高程序效率。

-module(tut7).
-export([format_temps/1]).

format_temps(List_of_cities) ->
    Converted_List = convert_list_to_c(List_of_cities),
    print_temp(Converted_List),
    {Max_city, Min_city} = find_max_and_min(Converted_List),
    print_max_and_min(Max_city, Min_city).

convert_list_to_c([{Name, {f, Temp}} | Rest]) ->
    Converted_City = {Name, {c, (Temp -32)* 5 / 9}},
    [Converted_City | convert_list_to_c(Rest)];

convert_list_to_c([City | Rest]) ->
    [City | convert_list_to_c(Rest)];

convert_list_to_c([]) ->
    [].

print_temp([{Name, {c, Temp}} | Rest]) ->
    io:format("~-15w ~w c~n", [Name, Temp]),
    print_temp(Rest);
print_temp([]) ->
    ok.

find_max_and_min([City | Rest]) ->
    find_max_and_min(Rest, City, City).

find_max_and_min([{Name, {c, Temp}} | Rest], 
         {Max_Name, {c, Max_Temp}}, 
         {Min_Name, {c, Min_Temp}}) ->
    if 
        Temp > Max_Temp ->
            Max_City = {Name, {c, Temp}};           % Change
        true -> 
            Max_City = {Max_Name, {c, Max_Temp}} % Unchanged
    end,
    if
         Temp < Min_Temp ->
            Min_City = {Name, {c, Temp}};           % Change
        true -> 
            Min_City = {Min_Name, {c, Min_Temp}} % Unchanged
    end,
    find_max_and_min(Rest, Max_City, Min_City);

find_max_and_min([], Max_City, Min_City) ->
    {Max_City, Min_City}.

print_max_and_min({Max_name, {c, Max_temp}}, {Min_name, {c, Min_temp}}) ->
    io:format("Max temperature was ~w c in ~w~n", [Max_temp, Max_name]),
    io:format("Min temperature was ~w c in ~w~n", [Min_temp, Min_name]).
58> c(tut7).
{ok, tut7}
59> tut7:format_temps([{moscow, {c, -10}}, {cape_town, {f, 70}},
{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).
moscow          -10 c
cape_town       21.11111111111111 c
stockholm       -4 c
paris           -2.2222222222222223 c
london          2.2222222222222223 c
Max temperature was 21.11111111111111 c in cape_town
Min temperature was -10 c in moscow
ok

函数 find_max_and_min 计算出最高温度和最低温度。这里引入了新的结构 if。 If 的工作方式如下。

if
    Condition 1 ->
        Action 1;
    Condition 2 ->
        Action 2;
    Condition 3 ->
        Action 3;
    Condition 4 ->
        Action 4
end

请注意，end 之前没有分号 "；"。 条件的作用与守卫相同，即测试成功或失败。 Erlang 从顶部开始，直到找到一个成功的条件。然后，它评估（执行）条件后面的操作，并忽略所有其他条件和操作，直到 end。如果没有任何条件匹配，则会发生运行时错误。始终成功的条件是原子 true。这通常用在 if 的最后，这意味着，如果所有其他条件都失败，则执行 true 后面的操作。

以下是一个简短的程序，用于展示 if 的工作原理。

-module(tut9).
-export([test_if/2]).

test_if(A, B) ->
    if 
        A == 5 ->
            io:format("A == 5~n", []),
            a_equals_5;
        B == 6 ->
            io:format("B == 6~n", []),
            b_equals_6;
        A == 2, B == 3 ->                      %That is A equals 2 and B equals 3
            io:format("A == 2, B == 3~n", []),
            a_equals_2_b_equals_3;
        A == 1 ; B == 7 ->                     %That is A equals 1 or B equals 7
            io:format("A == 1 ; B == 7~n", []),
            a_equals_1_or_b_equals_7
    end.

测试该程序将得到以下结果。

60> c(tut9).
{ok,tut9}
61> tut9:test_if(5,33).
A == 5
a_equals_5
62> tut9:test_if(33,6).
B == 6
b_equals_6
63> tut9:test_if(2, 3).
A == 2, B == 3
a_equals_2_b_equals_3
64> tut9:test_if(1, 33).
A == 1 ; B == 7
a_equals_1_or_b_equals_7
65> tut9:test_if(33, 7).
A == 1 ; B == 7
a_equals_1_or_b_equals_7
66> tut9:test_if(33, 33).
** exception error: no true branch found when evaluating an if expression
     in function  tut9:test_if/2 (tut9.erl, line 5)

请注意，tut9:test_if(33,33) 没有导致任何条件成功。这会导致运行时错误 if_clause，这里由 shell 友好地格式化。有关可用守卫测试的详细信息，请参见 守卫序列。

case 是 Erlang 中的另一个结构。回想一下，convert_length 函数的写法是。

convert_length({centimeter, X}) ->
    {inch, X / 2.54};
convert_length({inch, Y}) ->
    {centimeter, Y * 2.54}.

同一个程序也可以写成这样。

-module(tut10).
-export([convert_length/1]).

convert_length(Length) ->
    case Length of
        {centimeter, X} ->
            {inch, X / 2.54};
        {inch, Y} ->
            {centimeter, Y * 2.54}
    end.
67> c(tut10).
{ok,tut10}
68> tut10:convert_length({inch, 6}).
{centimeter,15.24}
69> tut10:convert_length({centimeter, 2.5}).
{inch,0.984251968503937}

case 和 if 都有 **返回值**，即在上面的例子中，case 返回 {inch,X/2.54} 或 {centimeter,Y*2.54}。 case 的行为也可以通过使用守卫来修改。以下示例对此进行了说明。它告诉我们一个月的长度，给定年份。必须知道年份，因为闰年的 2 月有 29 天。

-module(tut11).
-export([month_length/2]).

month_length(Year, Month) ->
    %% All years divisible by 400 are leap
    %% Years divisible by 100 are not leap (except the 400 rule above)
    %% Years divisible by 4 are leap (except the 100 rule above)
    Leap = if
        trunc(Year / 400) * 400 == Year ->
            leap;
        trunc(Year / 100) * 100 == Year ->
            not_leap;
        trunc(Year / 4) * 4 == Year ->
            leap;
        true ->
            not_leap
    end,  
    case Month of
        sep -> 30;
        apr -> 30;
        jun -> 30;
        nov -> 30;
        feb when Leap == leap -> 29;
        feb -> 28;
        jan -> 31;
        mar -> 31;
        may -> 31;
        jul -> 31;
        aug -> 31;
        oct -> 31;
        dec -> 31
    end.
70> c(tut11).
{ok,tut11}
71> tut11:month_length(2004, feb).
29
72> tut11:month_length(2003, feb).
28
73> tut11:month_length(1947, aug).
31

2.13  内置函数 (BIFs)

BIFs 是由于某种原因而内置到 Erlang 虚拟机中的函数。BIFs 通常实现 Erlang 中不可能或效率太低才能实现的功能。一些 BIFs 可以只使用函数名调用，但默认情况下它们属于 erlang 模块。例如，下面对 BIF trunc 的调用等效于对 erlang:trunc 的调用。

如所示，首先检查年份是否是闰年。如果年份可以被 400 整除，那么它就是闰年。为了确定这一点，首先将年份除以 400，然后使用 BIF trunc（稍后将详细介绍）来截断所有小数。然后再次乘以 400，看看是否返回了相同的值。例如，年份 2004

2004 / 400 = 5.01
trunc(5.01) = 5
5 * 400 = 2000

2000 与 2004 不相同，因此 2004 不能被 400 整除。年份 2000

2000 / 400 = 5.0
trunc(5.0) = 5
5 * 400 = 2000

也就是说，闰年。接下来的两个 trunc 测试以相同的方式评估年份是否可以被 100 或 4 整除。第一个 if 返回 leap 或 not_leap，它们最终存储在变量 Leap 中。该变量用于以下 case 的守卫中，该守卫告诉我们月份的长度。

此示例演示了 trunc 的用法。使用 Erlang 运算符 rem 更容易，它返回除法后的余数，例如

74> 2004 rem 400.
4

所以，与其写

trunc(Year / 400) * 400 == Year ->
    leap;

不如写成这样

Year rem 400 == 0 ->
    leap;

还有许多其他 BIFs，例如 trunc。只有少数 BIFs 可用于守卫，您不能在守卫中使用自己定义的函数。（请参阅 守卫序列）（对于高级读者：这是为了确保守卫没有副作用。）让我们在 shell 中玩一玩这些函数。

75> trunc(5.6).
5
76> round(5.6).
6
77> length([a,b,c,d]).
4
78> float(5).
5.0
79> is_atom(hello).
true
80> is_atom("hello").
false
81> is_tuple({paris, {c, 30}}).
true
82> is_tuple([paris, {c, 30}]).
false

所有这些函数都可以在守卫中使用。现在，让我们来看一些不能在守卫中使用的 BIFs。

83> atom_to_list(hello).
"hello"
84> list_to_atom("goodbye").
goodbye
85> integer_to_list(22).
"22"

这三个 BIFs 执行了在 Erlang 中很难（或不可能）执行的转换。

2.14  高阶函数 (Funs)

与大多数现代函数式编程语言一样，Erlang 也具有高阶函数。以下是一个使用 shell 的示例。

86> Xf = fun(X) -> X * 2 end.
#Fun<erl_eval.5.123085357>
87> Xf(5).
10

这里定义了一个将数字值加倍的函数，并将该函数分配给一个变量。因此，Xf(5) 返回值 10。在处理列表时，有两个有用的函数是 foreach 和 map，它们定义如下。

foreach(Fun, [First|Rest]) ->
    Fun(First),
    foreach(Fun, Rest);
foreach(Fun, []) ->
    ok.

map(Fun, [First|Rest]) -> 
    [Fun(First)|map(Fun,Rest)];
map(Fun, []) -> 
    [].

这两个函数在标准模块 lists 中提供。 foreach 接受一个列表，并对列表中的每个元素应用一个 fun。 map 通过对列表中的每个元素应用一个 fun 来创建一个新列表。回到 shell，使用 map 和一个 fun 为列表的每个元素添加 3

88> Add_3 = fun(X) -> X + 3 end.
#Fun<erl_eval.5.123085357>
89> lists:map(Add_3, [1,2,3]).
[4,5,6]

让我们（再次）打印城市列表中的温度。

90> Print_City = fun({City, {X, Temp}}) -> io:format("~-15w ~w ~w~n",
[City, X, Temp]) end.
#Fun<erl_eval.5.123085357>
91> lists:foreach(Print_City, [{moscow, {c, -10}}, {cape_town, {f, 70}},
{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).
moscow          c -10
cape_town       f 70
stockholm       c -4
paris           f 28
london          f 36
ok

现在让我们定义一个 fun，它可以用于遍历城市和温度列表，并将它们全部转换为摄氏度。

-module(tut13).

-export([convert_list_to_c/1]).

convert_to_c({Name, {f, Temp}}) ->
    {Name, {c, trunc((Temp - 32) * 5 / 9)}};
convert_to_c({Name, {c, Temp}}) ->
    {Name, {c, Temp}}.

convert_list_to_c(List) ->
    lists:map(fun convert_to_c/1, List).
92> tut13:convert_list_to_c([{moscow, {c, -10}}, {cape_town, {f, 70}},
{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).
[{moscow,{c,-10}},
 {cape_town,{c,21}},
 {stockholm,{c,-4}},
 {paris,{c,-2}},
 {london,{c,2}}]

函数 convert_to_c 与以前相同，但这里它用作一个 fun

lists:map(fun convert_to_c/1, List)

当在其他地方定义的函数用作 fun 时，它可以被称为 Function/Arity（记住 Arity = 参数数量）。因此，在 map 调用中，写的是 lists:map(fun convert_to_c/1, List)。如所示，convert_list_to_c 变得更短，更容易理解。

标准模块 lists 还包含一个函数 sort(Fun, List)，其中 Fun 是一个具有两个参数的 fun。如果第一个参数小于第二个参数，则该 fun 返回 true，否则返回 false。将排序添加到 convert_list_to_c 中

-module(tut13).

-export([convert_list_to_c/1]).

convert_to_c({Name, {f, Temp}}) ->
    {Name, {c, trunc((Temp - 32) * 5 / 9)}};
convert_to_c({Name, {c, Temp}}) ->
    {Name, {c, Temp}}.

convert_list_to_c(List) ->
    New_list = lists:map(fun convert_to_c/1, List),
    lists:sort(fun({_, {c, Temp1}}, {_, {c, Temp2}}) ->
                       Temp1 < Temp2 end, New_list).
93> c(tut13).
{ok,tut13}
94> tut13:convert_list_to_c([{moscow, {c, -10}}, {cape_town, {f, 70}},
{stockholm, {c, -4}}, {paris, {f, 28}}, {london, {f, 36}}]).
[{moscow,{c,-10}},
 {stockholm,{c,-4}},
 {paris,{c,-2}},
 {london,{c,2}},
 {cape_town,{c,21}}]

在 sort 中，fun 的用法如下。

fun({_, {c, Temp1}}, {_, {c, Temp2}}) -> Temp1 < Temp2 end,

这里引入了 **匿名变量** "_" 的概念。这只是用于接收值的变量的简写，但该值会被忽略。它可以在任何合适的地方使用，而不仅仅是在 fun 中。Temp1 < Temp2 如果 Temp1 小于 Temp2，则返回 true。

版权所有 © 1996-2024 Ericsson AB。保留所有权利。