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

在本例中,这些数字是整数,代码中的函数参数 NXY 被称为变量。变量必须以大写字母开头(参见 变量)。变量示例包括 NumberShoeSizeAge

原子是 Erlang 中的另一种数据类型。原子以小写字母开头(参见 原子),例如,charlescentimeterinch。原子只是名称,仅此而已。它们不像变量,变量可以有值。

将下一个程序输入到名为 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 函数中输入了除 centimeterinch 之外的其他内容,会发生什么

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.
[]

在前面的示例中,使用了新的变量名,而不是重复使用旧的变量名:FirstTheRestE1E2RABC。这样做的原因是,变量在其上下文(作用域)中只能赋值一次。稍后将详细介绍。

以下示例展示了如何查找列表的长度。将以下代码输入到名为 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 创建一个新的地图项,并让键 redgreenbluealpha 与初始值关联。在这种情况下,只允许介于 0.0 和 1.0 之间(包括 0.0 和 1.0)的浮点值,如每个参数的 ?is_channel/1 宏所确保的。创建新地图时,只允许 => 运算符。

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

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

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

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

函数 red/2blue/2green/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/1list_max/2

在这个示例中,你遍历一个列表,并“携带”一个值,在本例中是 Result_so_farlist_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_farwhen 是一个特殊词,用于在函数中的 -> 之前,用于表示只有在后面的测试为真时,才使用函数的这一部分。此类测试称为 **守卫**。如果守卫为假(即守卫失败),则尝试函数的下一部分。在本例中,如果 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/1convert_list_to_c/1List_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}

caseif 都有 **返回值**,即在上面的例子中,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

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 返回 leapnot_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 中很难(或不可能)执行的转换。

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

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

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

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