《Erlang程序设计》

越精简的代码, 越复杂, erlang语言是精简中的精简.

就由这本书作为我的Erlang入门吧！

配置Erlang环境看这里：https://blog.csdn.net/weixin_38044597/article/details/118194771

另外我选用IDEA作为开发环境。

这本书有非常多未填的坑，等待机会以后填。

学习感悟

1. 学习这本书时领会到笔记应该和书有所区别，笔记的结构应当是消化后的结构，而不是按照书上来，做笔记的时机至少应当等到一章的结束，甚至可以一本书的结束，这样才有全局的结构感。才方便作复习用笔记，而不是一个精简版书目。书目是循序渐进的，而笔记应当是全面的，大体上有顺序的。而且这么做有助于提高阅读效率和知识印象。
2. 笔记不是查阅全书

第1章 什么是并发

并发建模

1-module(person).
2-export([init/1]).
3
4init(Name) -> ...

第1行-module(person).的意思是此文件包含用于person模块的代码。它应该与文件名一致（除了.erl这个文件扩展名） 。模块名必须以一个小写字母开头。从技术上说，模块名是一个原子（atom）。

模块声明之后是一条导出声明。导出声明指明了模块里哪些函数可以从模块外部进行调用。它们类似于许多编程语言里的public声明。没有包括在导出声明里的函数是私有的，无法在模块外调用

-export([init/1]).语法的意思是带有一个参数（/1指的就是这个意思，而不是除以1）的函数init可以在模块外调用。如果想要导出多个函数，就应该使用下面这种语法：

1-export([FuncName1/N1, FuncName2/N2, ...])

方括号[ … ]的意思是“列表”，因此这条声明的意思是我们想要从模块里导出一个函数列表。

创建进程

 1-module(world).
 2-export([start/0]).
 3
 4start() ->
 5	Joe	     = spawn(person, init, ["Joe"]),
 6	Susannah = spawn(person, init, ["Susannah"]),
 7	Dave	 = spawn(person, init, ["Dave"]),
 8	Andy	 = spawn(person, init, ["Andy"]),
 9	Rover	 = spawn(dog, init, ["Rover"]),
10	...
11	Rabbit1	 = spawn(rabbit, init, ["Flopsy"]),
12	...
13

spawn是一个Erlang基本函数，它会创建一个并发进程并返回一个进程标识符。spawn可以这样调用：

1spawn(ModName, FuncName, [Arg1, Arg2, ..., ArgN])

当Erlang运行时系统执行spawn时，它会创建一个新进程（不是操作系统的进程，而是一个由Erlang系统管理的轻量级进程）。当进程创建完毕后，它便开始执行参数所指定的代码。ModName是包含想要执行代码的模块名。FuncName是模块里的函数名，而[Arg1, Arg2, …]是一个列表，包含了想要执行的函数参数。因此，下面这个调用的意思是启动一个执行函数person:init(“Joe”)的进程：

1spawn(person, init, ["Joe"])

spawn的返回值是一个进程标识符（PID，Process IDentifier），可以用来与新创建的进程交互。

Erlang里的模块类似于面向对象编程语言（OOPL，Object-Oriented Programming Language）里的类，进程则类似于OOPL里的对象（或者说类实例）。在Erlang里，spawn通过运行某个模块里定义的函数创建一个新进程。而在Java里，new通过运行某个类中定义的方法创建一个新对象。在OOPL里可以用一个类创建数千个类实例。类似地，在Erlang里我们可以用一个模块创建数千甚至数百万个执行模块代码的进程。

发送消息

启动模拟之后，我们希望在程序的不同进程之间发送消息。在Erlang里，各个进程不共享内存，只能通过发送消息来与其他进程交互。

Joe想要对Susannah说些什么。在程序里我们会编写这样一行代码：

1Susannah ! {self(), "Hope the dogs dont chase the rabbits"}

Pid ! Msg 语法的意思是发送消息Msg到进程Pid。大括号里的self()参数标明了发送消息的进程（在此处是Joe）。

接收消息

为了让Susannah的进程接收来自Joe的消息，要这样写：

1receive
2	{From, Message} ->
3		...
4end

当Susannah的进程接收到一条消息时，变量From会绑定为Joe，这样Susannah就知道消息来自何处，变量Message则会包含此消息。

并发程序和并行计算机

Erlang里的并发程序是由互相通信的多组顺序进程组成的。一个Erlang进程就是一个小小的虚拟机，可以执行单个Erlang函数。别把它和操作系统的进程相混淆。

顺序和并发编程语言

在Erlang里，并发性由Erlang虚拟机提供，而非操作系统或任何的外部库。在大多数顺序编程语言里，并发性都是以接口的形式提供，指向主机操作系统的内部并发函数。区分基于操作系统的并发和基于语言的并发很重要，因为如果使用基于操作系统的并发，那么程序在不同的操作系统上就会有不同的工作方式。Erlang的并发在所有操作系统上都有着相同的工作方式。要用Erlang编写并发程序，只需掌握Erlang，而不必掌握操作系统的并发机制。在Erlang里，进程和并发是我们可以用来定型和解决问题的工具。这让细粒度控制程序的并发结构成为可能，而用操作系统的进程是很难做到的。

第2章 Erlang速览

Shell初探

Erlang shell以横幅信息和计数提示符1>作为响应。然后输入一个表达式，并得到了执行和显示。请注意每一条表达式都必须以一个句号后接一个空白字符结尾。在这个上下文环境里，空白是指空格、制表（Tab）或者回车符。

• 可以用=操作符给变量赋值（严格来说是给变量绑定一个值）。不能重新绑定变量。Erlang是一种函数式语言，所以一旦定义了X = 123，那么X永远就是123，不允许改变！=不是一个赋值操作符，它实际上是一个模式匹配操作符。与其他函数式编程语言一样，Erlang的变量只能绑定一次。绑定变量的意思是给变量一个值，一旦这个值被绑定，以后就不能改动了。
• Erlang的变量以大写字母开头。所以X、This和A_long_name都是变量。以小写字母开头的名称（比如monday或friday）不是变量，而是符号常量，它们被称为原子（atom）。

编译与调用

Erlang程序是由许多并行的进程构成的。进程负责执行模块里定义的函数。模块则是扩展名为.erl的文件，运行前必须先编译它们。编译某个模块之后，就可以在shell或者直接从操作系统环境的命令行里执行该模块中的函数了。

1.shell编译hello.erl文件

1-module(hello).
2-export([start/0]).
3
4start() ->
5	io:format("Hellow world~n")/

1$erl
2>c(hello).
3{ok, hello}
4>hello:start().
5Hello world
6ok
7>halt().

c(hello)命令编译了hello.erl文件里的代码。{ok, hello}的意思是编译成功。现在代码已准备好运行了。第2行里执行了hello:start()函数。第3行里停止了Erlang shell。

在shell里进行操作的优点是只要平台为Erlang所支持，这种编译和运行程序的方法就一定可用。在操作系统的命令行里的操作可能会因平台的不同而有所差别。

2.shell外编译

1$ erlc hello.erl
2$ erl -noshell -s hello start -s init stop
3Hello world

erlc 从命令行启动了Erlang编译器。编译器编译了 hello.erl 里的代码并生成一个名为hello.beam的目标代码文件。

$erl -noshell …命令加载了 hello模块并执行 hello:start()函数。随后，它执行了init:stop()，这个表达式终止了Erlang会话。

在Erlang shell之外运行Erlang编译器（erlc）是编译Erlang代码的首选方式。可以在Erlang shell里编译模块，但要这么做必须首先启动Erlang shell。使用erlc的优点在于自动化。我们可以在rakefile或makefile内运行erlc来自动化构建过程。

并发实例

1.文件服务器进程

afile_server.erl:

 1-module(afile_server).
 2-export([start/1, loop/1]).
 3
 4start(Dir) -> spawn(afile_server, loop, [Dir]).
 5
 6loop(Dir) ->
 7	receive
 8		{Client, list_dir} ->
 9			Client ! {self(), file:list_dir(Dir)};
10		{Client, {get_file, File}} ->
11            % 获取绝对路径
12			Full = filename:join(Dir, File),
13            % 调用read_file读文件
14			Client ! {self(), file:read_file(Full)}
15	end,
16	loop(Dir).

• Erlang编写无限循环的方法：

  1loop(Dir) ->
  2	receive
  3      Command ->
  4          .....
  5	end,
  6	loop(Dir)
  

  不用担心最后的自身调用，这不会耗尽栈空间。Erlang对代码采用了一种所谓“尾部调用”的优化，意思是此函数的运行空间是固定的。这是用Erlang编写循环的标准方式，只要在最后调用自身即可。

• 模式匹配：

  1receive
  2	Pattern1 ->
  3      Actions1;
  4	Pattern2 ->
  5      Actions2 ->
  6      ...
  7	...
  8end
  

  Erlang编译器和运行时系统会正确推断出如何在收到消息时运行适当的代码。不需要编写任何的if-then-else或switch语句来设定该做什么。

• shell测试：

   11> c(afile_server).
   2{ok, afile_server}
   3% 编译afile_server.erl文件所包含的afile_server模块。
   4  
   52> FileServer = afile_server:start(".").
   6<0.47.0>
   7% afile_server:start(Dir)调用spawn(afile_server, loop, [Dir])。
   8% 这就创建出一个新的并行进程来执行函数afile_server:loop(Dir)并返回一个进程标识符
   9% <0.47.0>是文件服务器进程的进程标识符。它的显示方式是尖括号内由句号分隔的三个整数。
  10  
  113> FileServer ! {self(), list_dir}.
  12{<0.31.0>, list_dir}.
  13% 这里给文件服务器进程发送了一条{self(), list_dir}消息。Pid ! 
  14% Message的返回值被规定为Message，因此shell打印出{self(),list_dir}的值，即{<0.31.0>, list_dir} 
  15  
  164> receive X -> X end.
  17{<0.47.0>, 
  18	{ok, ["afile_server.beam", ...]}
  19}
  20% receive X -> X end接收文件服务器发送的回复。它返回元组{<0.47.0>, {ok, ...}。
  21% 该元组的第一个元素<0.47.0>是文件服务器的进程标识符。
  22% 第二个参数是file:list_dir(Dir)函数的返回值
  

2.客户端代码

afile_client.erl:

 1-module(afile_client).
 2-export([ls/1, get_file/2]).
 3
 4ls(Server) ->
 5	Server ! {self(), list_dir},
 6	receive
 7		{Server, FileList} ->
 8			FileList
 9	end.
10
11get_file(Server, File) ->
12	Server ! {self(), {get_file, File}},
13	receive
14		{Server, Content} ->
15			Content
16	end.

3.测试

 11> c(afile_server).
 2{ok, afile_server}
 32> c(afile_client).
 4{ok, afile_client}
 53> FileServer = afile_server:start(".").
 6<0.43.0>
 74> afile_client:get_file(FileServer, "missing").
 8{error, enoent}
 95> afile_client:get_file(FileServer, "afile_server.erl").
10{ok, <<"-modle(afile_server).\n-export...."}

练习

(4)

运行文件客户端和服务器代码。加入一个名为put_file的命令。你需要添加何种消息？学习如何查阅手册页。查阅手册页里的file模块。

write_file/2：https://www.erlang.org/doc/apps/kernel/file.html#write_file/2

客户端应发送文件名及文件内容：

 1-module(afile_client).
 2-export([ls/1, get_file/2, put_file/3]).
 3
 4ls(Server) ->
 5	Server ! {self(), list_dir},
 6	receive
 7		{Server, FileList} ->
 8			FileList
 9	end.
10
11get_file(Server, File) ->
12	Server ! {self(), {get_file, File}},
13	receive
14		{Server, Content} ->
15			Content
16	end.
17
18put_file(Server, FileName, Content) ->
19    Server ! {self(), {FileName, Content}},
20    receive
21        {Server, response} ->
22            response
23    end.

对应的Server接收文件名和内容，写入文件，并返回操作结果：

 1-module(afile_server).
 2-export([start/1, loop/1]).
 3
 4start(Dir) -> spawn(afile_server, loop, [Dir]).
 5
 6loop(Dir) ->
 7	receive
 8		{Client, list_dir} ->
 9			Client ! {self(), file:list_dir(Dir)};
10		{Client, {get_file, File}} ->
11			Full = filename:join(Dir, File),
12			Client ! {self(), file:read_file(Full)};
13        {Client, {FileName, Content}} ->
14            Full = filename:join(Dir, FileName),
15           	response = file:write_file(Full, list_to_binary(Content)),
16            Client ! {self(), response}
17	end,
18	loop(Dir).

测试失败：目前暂时不去解决，不过要写的文件还是写上去了。

 11> c(afile_server).
 2{ok,afile_server}
 32> c(afile_client).
 4{ok,afile_client}
 53> FileServer = afile_server:start(".").
 6<0.94.0>
 74> afile_client:put_file(FileServer, "test.txt", "Erlang file test").
 8=ERROR REPORT==== 4-Dec-2024::14:44:33.629142 ===
 9Error in process <0.94.0> with exit value:
10{{badmatch,ok},[{afile_server,loop,1,[{file,"afile_server.erl"},{line,14}]}]}

第3章 基本概念

Erlang shell

退出：

1ctrl+c
2
3a 可能导致数据损坏
4q() 是init:stop()命令在shell里的别名。以一种受控的方式停止了系统。所有打开的文件都被刷入缓存并关闭，数据库（如果正在运行的话）会被停止，所有的应用程序都以有序的方式关停
5erlang:halt() 立即停止系统

编写命令快捷键：

1^A 行首
2^D 删除当前字符
3^E 行尾
4^F或右箭头键 向前的字符
5^B或左箭头键 向后的字符
6^P或上箭头键 前一行
7^N或下箭头键 下一行
8^T 调换最近两个字符的位置
9Tab 尝试扩展当前模块或函数的名称

整数运算

16进制乘32进制：

116#cafe * 32#sugar.

变量

• 所有变量名都必须以大写字母开头。
• 想知道一个变量的值，只需要输入变量名。
• 如果试图给变量X指派一个不同的值，就会得到一条错误消息。
• 在Erlang里怎样表达X = X + 1这类概念？Erlang的方式是创建一个名字未被使用过的新变量（比方说X1），然后编写X1 = X + 1。

Erlang的变量是一次性赋值变量（single-assignment variable）。已被指派一个值的变量称为绑定变量，否则称为未绑定 变量。=是一个模式匹配操作符，它在X为未绑定变量时的表现类似于赋值。

第一次说X=SomeExpression时，Erlang对自己说：“我要做些什么才能让这条语句为真？”因为X还没有值，它可以绑定X到SomeExpression这个值上，这条语句就成立了。如果后期我们说X=AnotherExpression，那么只有在SomeExpression和Another-Expression相等的情况下匹配才会成功：

11> X = (2+4).
26
32> Y = 10.
410
5% 在计算这个表达式之前，X等于6，因此匹配成功
63> X = 6.
76
84> X = Y.
9exception...

变量的作用域是它定义时所处的语汇单元。因此，如果X被用在一条单独的函数子句之内，它的值就不会“逃出”这个子句。没有同一函数的不同子句共享全局或私有变量这种说法。如果X出现在许多不同的函数里，那么所有这些X的值都是不相干的。(这一点让编程变得非常困难)

浮点数

• 用/给两个整数做除法时，结果会自动转换成浮点数。
• 要从除法里获得整数结果，我们必须使用操作符div和rem：N div M是让N除以M然后舍去余数。N rem M是N除以M后剩下的余数。
• Erlang在内部使用64位的IEEE 754-1985浮点数，因此使用浮点数的程序会存在和C等语言一样的浮点数取整与精度问题。

11> 5/3.
21.666666666666666667
32> 4/2.
42.0
53> 5 div 3.
61
74> 5 rem 3.
82

原子

• 原子以小写字母开头，后接一串字母、数字、下划线（_）或at（@）符号，例如：

  1red
  2december
  3cat
  4meters
  5yards
  6joe@somehost
  7a_long_name
  

• 原子还可以放在单引号（'）内。可以用这种引号形式创建以大写字母开头（否则会被解释成变量）或包含字母数字以外字符的原子，例如'Monday'、'Tuesday'、'+'、'*'和'an atomwith spaces'。甚至可以给无需引号的原子加上引号，因此’a’和a的意思完全一致。

• 在某些语言里，单引号和双引号可以互换使用。Erlang里不是这样。单引号的用法如前面所示，双引号用于给字符串字面量（string literal）定界。

• 一个原子的值就是它本身。可以充当全局常量的效果，只不过不需要再定义数字了，它本身就有含义。

• true和false也是原子

元组

1.创建：

• Erlang没有类型声明，元组里的字段没有名字。
• 为了更容易记住元组的用途，一种常用的做法是将原子作为元组的第一个元素，用它来表示元组是什么。
• 元组还可以嵌套。
• 元组用于保存固定数量的元素。

1>P = {10, 45}.
2>P = {point, 10, 45}.
3>Person = {person, {name, job}, {height, 1.82}, {footsize, 42}, {eyecolour, brown}}.

• 如果在构建新元组时用到变量，那么新的元组会共享该变量所引用数据结构的值；
• 如果试图用未定义的变量创建数据结构，就会得到一个错误。

1>F = {firstName, joe}.
2{firstName, joe}
3>L = {lastName, armstrong}.
4{lastName, armstrong}
5>P = {person, F, L}.
6{person, {firstName, joe}, {firstName, joe}}
7
8>{true, Q, 23, Costs}
9** 1.variable 'Q' is unbound**

2.提取元组的值：

• 如果想从某个元组里提取一些值，就会使用模式匹配操作符=。在待提取值的位置加入未绑定变量来提取该元组的值。
• 等号两侧的元组必须有相同数量的元素，而且两侧的对应元素必须绑定为相同的值。原子对应原子。
• 可以用匿名变量表示不感兴趣的值。
• 将_作为占位符，用于表示不感兴趣的那些变量。符号_被称为匿名变量。与正规变量不同，同一模式里的多个_不必绑定相同的值。

 1>P = {point, 10, 45}.
 2{point,10,45}.
 3>{point, X, Y} = Point.
 4{point,10,45}
 5>X.
 610
 7>Y.
 845
 9% X绑定了10，Y绑定了45。根据规定，表达式Lhs = Rhs的值是Rhs，因此shell打印出{point,10,45}。
10
11>{point, C, C} = Point.
12** exception error....
13% 模式{point, C, C}与{point, 10, 45}不匹配，因为C不能同时是10和45。因此，这次模式匹配失败，系统打印出了错误消息。
14
15>Person={person, {firstName, joe}, {firstName, joe}}.
16>{_,{_,First}.{_,_}} = Person.
17>First.
18joe
19% 如果有一个复杂的元组，就可以编写一个与该元组形状（结构）相同的模式，并在待提取值的位置加入未绑定变量来提取该元组的值。

列表

• 列表（list）被用来存放任意数量的事物。创建列表的方法是用中括号把列表元素括起来，并用逗号分隔它们。
• 列表里的各元素可以是任何类型
• 列表的第一个元素被称为列表头（head）。假设把列表头去掉，剩下的就被称为列表尾（tail）。
• 无论何时，只要用[…|T]语法构建一个列表，就应该确保T是列表。可以给T的开头添加不止一个元素，写法是[E1,E2,..,En|T]。
• 列表用于保存可变数量的元素。

1.定义列表：

1[1+7, hello, 2-2, {cost, apple, 30-20}, 3].
2ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].
3ThingsToBuy1 = [{oranges, 4}, {newspaper,1}|ThingsToBuy].

2.提取列表元素：

可以用模式匹配操作来提取某个列表里的元素。如果有一个非空列表L，那么表达式[X|Y] = L（X和Y都是未绑定变量）会提取列表头作为X，列表尾作为Y。

1[Buy1|ThingsToBuy2] = ThingsToBuy1.
2% 操作成功，绑定如下：Buy1 = {oranges,4} ，ThingsToBuy2 = [{newspaper,1},然后可以继续拆出{apples,10}, {pears,6}, {milk,3}]。于是我们先去买橙子（oranges）下一对商品。

字符串

1.用字符串字面量来创建一个列表

• 严格来说，Erlang里没有字符串。要在Erlang里表示字符串，可以选择一个由整数组成的列表或者一个二进制型。当字符串表示为一个整数列表时，列表里的每个元素都代表了一个Unicode代码点（codepoint）。
  • 可以把“美元符号语法”用于这个目的。举个例子，$a实际上就是代表字符a的整数

 1>Name = "Hello".
 2"Hello"
 3
 4
 5> I = $s.
 6115
 7> [I-32, $u, $r, $p, $r, $i, $s, $e].
 8"Surprise"
 9% 可以把“美元符号语法”用于这个目的。举个例子，$a实际上就是代表字符a的整数
10
11> X = "a\x{221e}b"
12> io:format("~ts~n", [X]).
13a。。b
14% 用列表来表示字符串时，它里面的各个整数都代表Unicode字符。必须使用特殊的语法才能输入某些字符，在打印列表时也要选择正确的格式惯例。
15% 在第1行里，我们创建了一个包含三个整数的列表。第一个整数97是字符a的ASCII和Unicode编码。\x{221e}这种记法的作用是输入一个代表Unicode无穷大字符的十六进制整数。98是字符b的ASCII和Unicode编码。
16% 在第2行里，我们用一个格式化I/O语句打印出这个字符串，里面使用了代表无穷大字符的正确字符图案。

2.整数列表的打印：

• 如果列表内的所有整数都代表可打印字符，它就会将其打印成字符串字面量
• 否则，打印成列表记法
• 如果shell将某个整数列表打印成字符串，而你其实想让它打印成一列整数，那就必须使用格式化的写语句

 1>[1,2,3]
 2[1,2,3]
 3>[83,117]
 4"Su"
 5>[1,83,117]
 6[1,83,117]
 7
 8% 列表[1,2,3]在打印时未做转换。这是因为1、2和3不是可打印字符。
 9% 列表里的所有项目都是可打印字符，因此它被打#这个列表以1开头，而1不是可打印字符。因此，这个列表在打印时未做转换。印成字符串字面量。
10% 这个列表以1开头，而1不是可打印字符。因此，这个列表在打印时未做转换。
11
12
13>X = [97,98,99].
14"abc"
15>io:format("~w~n,["abc"]).
16[97,98,99]

模式匹配再探

1[A,B,C,D] = [a,b,c,d,e,f] 
2% 成功

f()命令让shell忘记现有的任何绑定。在这个命令之后，所有变量都会变成未绑定状态。

help()命令提示一些函数。

练习

(3)

试着用一个元组来表示一座房子，再用一个房子列表来表示一条街道。请确保你能向这些结构中加入数据或从中取出数据。

 14> House1 = {house, {location,10,20}, {owner, joe}}.
 2{house,{location,10,20},{owner,joe}}
 35> House2 = {house, {location, -10, 40}, {owner, peter}}.
 4{house,{location,-10,40},{owner,peter}}
 56> Street = [House1, House2].
 6[{house,{location,10,20},{owner,joe}},
 7 {house,{location,-10,40},{owner,peter}}]
 87> [{_,_,{_,House1Owner}},_] = Street.
 9[{house,{location,10,20},{owner,joe}},
10 {house,{location,-10,40},{owner,peter}}]
118> House1Owner.
12joe

第4章 模块与函数

模块介绍

1.示例程序

1-module(geometry).
2-export([area/1]).
3
4area({rectangle, Width, Height}) -> Width * Height;
5area({circle, Radius}) -> 3.14159 * Radius * Radius;
6area({square, Side}) -> Side * Side.

1>c(geometry).
2{ok,geometry}
3>geometry:area({rectangle, 10, 5}).
450
5>geometry:area({square, 3}).
69

• 第一行是模块声明。声明里的模块名必须与存放该模块的主文件名相同。
• 第二行是导出声明。Name/N这种记法是指一个带有N个参数的函数Name，N被称为函数的元数（arity）。export的参数是由Name/N项目组成的一个列表。
• 未从模块里导出的函数只能在模块内调用。
• area函数有三个子句。这些子句由一个分号隔开，最后的子句以句号加空白结束。每条子句都有一个头部和一个主体，两者用箭头（->）分隔。头部包含一个函数名，后接零个或更多个模式，主体则包含一列表达式，它们会在头部里的模式与调用参数成功匹配时执行。这些子句会根据它们在函数定义里出现的顺序进行匹配。
• 命令c(geometry)，它的作用是编译geometry.erl文件里的代码。编译器返回了{ok,geometry}，意思是编译成功，而且geometry模块已被编译和加载。编译器会在当前目录创建一个名为geometry.beam的目标代码模块。
• 在第2行和第3行调用了geometry模块里的函数。请注意，需要给函数名附上模块名，这样才能准确标明想调用的是哪个函数。
• 我们的函数并不处理模式匹配失败的情形，程序会以一个运行时错误结束。这是有意而为的，是在Erlang里编程的方式。
• Erlang代码里，我们只需要编写模式，Erlang编译器就会生成最佳的模式匹配代码，用它来选择正确的程序入口点。
• 逗号（,）分隔函数调用、数据构造和模式中的参数。
• 分号（ ; ）分隔子句。我们能在很多地方看到子句，例如函数定义，以及 case 、 if 、try..catch和receive表达式
• 句号（.）（后接空白）分隔函数整体，以及shell里的表达式。

2.Erlang shell内建命令

• pwd()打印当前工作目录。
• ls()列出当前工作目录里所有的文件名。
• cd(Dir)修改当前工作目录至Dir。

结算程序

shop.erl:

1-module(shop).
2-export([cost/1]).
3
4cost(oranges) -> 5;
5cost(newspaper) -> 8;
6cost(apples) -> 2;
7cost(pears) -> 9;
8cost(milk) -> 7;

shop1.erl:

1-module(shop1).
2-export([total/1]).
3
4total([What, N]|T) -> shop:cost(What) * N + total(T);
5total([]) -> 0.

1>c(shop).
2>c(shop1).
3>shop1:total([milk,3]).
421
5>shop1:total([{pears,6},{milk,3}]).
675

有点像递归调用地处理列表中的每个元组，其他的没有什么知识。这样可以创造for循环

基本的抽象单元fun

• 函数式编程语言表示函数可以被用作其他函数的参数，也可以返回函数。操作其他函数的函数被称为高阶函数（higher-order function），而在Erlang中用于代表函数的数据类型被称为fun。
• funs是“匿名的”函数。其他编程语言称它们为lambda抽象。
• fun可以有多个不同的子句。
• 括号里的东西就是返回值。也可以说->后面的东西。

1.基本概念

 1> Double = fun(X) -> 2*X end.
 2#Fun<erl_eval.6.56006584>
 3> Double(2).
 44
 5
 6> Hypot = fun(X,Y) -> math:sqrt(X*X, Y*Y) end.
 7> Hypot(3,4).
 85.0	
 9> Hypot(3).
10** exception 元数不正确
11
12> TempConvert = fun({c,C}) -> {f, 32 + C*9/5};
13				   ({f,F}) -> {c, (F-32)*5/9}
14				end.
15>TempConvert({c,100}).
16{f,212.0}

2.以fun作为参数的函数示例

• lists:map(F,L)。这个函数返回的是一个列表，它通过给列表L里的各个元素应用fun F生成。
• lists:filter(P, L)，它返回一个新的列表，内含L中所有符合条件的元素（条件是对元素E而言P(E)为true）。
• =:=用来测试是否相等。

1> L = [1,2,3,4].
2> lists:map(fun(X) -> 2*X end, L).
3[2,4,6,8]
4
5> Even = fun(X) -> (X rem 2) =:= 0 end.
6> lists:filter(Even, [1,2,3,4,5,6,8]).
7[2,4,6,8]

3.返回fun的函数示例

对于给定列表，生成函数，用于判断单个变量是否在这个列表里面：

1> Fruit = [apple,pear,orange].
2> MakeTest = fun(L) -> (fun(X) -> lists:member(X,L) end) end.
3> IsFruit = MakeTest(Fruit).
4> IsFruit(pear).
5true
6> IsFruit(dog).
7false

指定倍数生成一个函数，这个函数的返回值是参数的指定倍数：

1> Mult = fun(Times) -> ( fun(X) -> X * Times end) end.
2> Triple = Mult(3).
3> Triple(5).
415

4.自定义for循环

• 创建自己的控制结构能大大降低程序的大小，有时还能让它们更加清晰。这是因为你能精确地创建出解决问题所需要的控制结构，同时还不受编程语言自带的少量固定控制结构所限。

lib_misc.erl:

1% 执行for(1,10,F)会创建列表[F(1), F(2), ..., F(10)]
2for(Max, Max, F) -> [F(Max)];
3for(I, Max, F) -> [F(I)|for(I+1, Max, F)].

1lib_misc:for(1,10,fun(I) -> I end).
2lib_misc:for(1,10,fun(I) -> I*I end).

优化结算程序

mylists.erl:

1-module(mylists)
2-export([map/2, sum/1]).
3
4sum([H|T]) -> H + sum(T);
5sum([]) -> 0.
6
7map(_,[]) ->[];
8map(F, [H|T]) -> [F(H)|map(F,T)].

shop2.erl:

1-module(shop2).
2-export([total/1]).
3-import(mylists, [map/2,sum/1]).
4
5total(L) ->
6	sum(map(fun({What,N}) -> shop:cost(What) * N end, L)).

列表推导

1.基础概念

• 列表推导（list comprehension）是无需使用fun、map或filter就能创建列表的表达式。它让程序变得更短，更容易理解。

• 列表推导最常规的形式是下面这种表达式：

  1[X || Qualifier1, Qualifier2, ...]
  

  X是任意一条表达式，后面的限定符（Qualifier）可以是生成器、位串生成器或过滤器。

  • 生成器（generator）的写法是Pattern <- ListExpr，其中的ListExp必须是一个能够得出列表的表达式。
  • 位 串 （ bitstring ）生成器的写法是 BitStringPattern <= BitStringExpr ， 其 中 的BitStringExpr必须是一个能够得出位串的表达式。
  • 过滤器（filter）既可以是判断函数（即返回true或false的函数），也可以是布尔表达式。

• 这个限定符的运算顺序是从左往右的。

 1> L = [1,2,3,4,5].
 2> lists:map(fun(X) -> 2*X end, L).
 3> [2*X || X <- L].
 4[2,4,6,8,10]
 5
 6% 列表推导的购物结算程序
 7> Buy=[{oranges,4}.{newspaper,1},{apples,10},{pears,6},{milk,3}].
 8> [{Name, 2*Number} || {Name, Number} <- Buy].
 9[{oranges,8}, {newspaper,2},{apples,20},{pears,12},{milk,6}]
10% ||符号右侧的元组{Name, Number}是一个模式
11% 左侧的元组{Name, 2*Number}则是一个构造器（constructor）。
12> [{shop:cost(A)* B} || {A, B} <- Buy].
13[20,8,20,54,21]
14> lists:sum([shop:cost(A) * B || {A,B} <- Buy]).
15123

2.几个例子：

归并排序：

1qsort([]) -> [];
2qsort([Pivot|T]) ->
3		qsort([X || X <- T, X < Pivot])
4		++ [Pivot] ++
5		qsort([X || X <- T, X >= Pivot]).

• ++是中缀插入操作符。
• 将T分成两个列表，一个包含T里所有小于Pivot（中位数）的元素，另一个包含所有大于或等于Pivot的元素。所以这里第二个限定符就是过滤器。

查找勾股数（暴力遍历）：

1pythag(N) ->
2	[ {A,B,C} ||
3		A <- lists:seq(1,N),
4		B <- lists:seq(1,N),
5		C <- lists:seq(1,N),
6		A+B+C =< N,
7		A*A+B*B =:= C*C
8	].

• lists:seq(1, N)返回一个包含从1到N所有整数的列表。

单词字母的所有组合：

1perms([]) -> [[]];
2perms(L) -> [[H|T] || H <- L, T <- perms(L--[H])].

• X -- Y是列表移除操作符，它从X里移除Y中的元素。
• 穷尽一切可能从L里提取H（单个字母），然后穷尽一切可能从perms(L – [H])（即列表L移除H后的所有排列形式）里提取T，最后返回[H|T]。

内置函数

• 内置函数简称为BIF（built-in function），是那些作为Erlang语言定义一部分的函数。有些内置函数是用Erlang实现的，但大多数是用Erlang虚拟机里的底层操作实现的。

• 所有内置函数都表现得像是属于 erlang模块，但那些最常用的内置函数（例如 list_to_tuple）是自动导入的

• 内置函数文档：http://www.erlang.org/doc/man/erlang.html

  (在erts/erlang模块里面)

• 内置函数list_to_tuple/1能将一个列表转换成元组

• time/0以{时，分，秒}的格式返回当前的时间。

关卡

• 关卡（guard）是一种结构，可以用它来增加模式匹配的威力。通过使用关卡，可以对某个模式里的变量执行简单的测试和比较。
• 关卡序列（guard sequence）是指单一或一系列的关卡，用分号（;）分隔。对于关卡序列G1;G2; …; Gn，只要其中有一个关卡（G1、G2……）的值为true，它的值就为true。
• 关卡由一系列关卡表达式组成，用逗号（,）分隔。关卡GuardExpr1, GuardExpr2, … ,GuardExprN只有在所有的关卡表达式（GuardExpr1、GuardExpr2……）都为true时才为true。
• 合法的关卡表达式是所有合法Erlang表达式的一个子集。
• 关卡不能调用用户定义的函数，因为要确保它们没有副作用并能正常结束。
• 合法的关卡表达式：
  • 原子true；
  • 其他常量（各种数据结构和已绑定变量）它们在关卡表达式里都会成为false；
  • 调用后面表1里的关卡判断函数和表2里的内置函数；
  • 数据结构比较（参见表6）；
  • 算术表达式（参见表3）；
  • 布尔表达式（参见8.7节）；
  • 短路布尔表达式（参见8.23节）。
• 短路布尔表达式：orelse和andalso
• orelse和andalso操作符存在的原因是布尔操作符and/or原本的定义是两侧参数都需要求值。在关卡里，（and与andalso）之间和（or与orelse）之间可能会存在差别。
• 原子true可以被当作“来者不拒”的关卡

表1 关卡判断函数:

表2 关卡内置函数：

 1max(X,Y) when X > Y -> X;
 2max(X,Y) -> Y.
 3% 子句1会在X大于Y时匹配，结果是X。如果子句1不匹配，系统就会尝试子句2。
 4% 子句2总是返回第二个参数Y。Y必然是大于或等于X的，否则子句1就已经匹配了。
 5
 6f(X,Y) when is_integer(T), X>Y, Y<6 -> ...
 7% 当X是一个整数，X大于Y并且Y小于6时
 8is_tuple(T), tuple_size(T) =:= 6, abs(element(3,T)) > 5
 9% T是一个包含六个元素的元组，并且T中第三个元素的绝对值大于5
10element(4,X) =:= hd(L)
11% 元组X的第4个元素与列表L的列表头相同
12A >= -1.0 andalso A+1>B
13is_atom(L) orelse (is_list(L) andalse length(L) > 2)
14                                      
15f(X) when (X == 0) or (1/X > 2) -> ...
16g(X) when (X == 0) orelse (1/X > 2) -> ...
17% 当X为0时，f(X)里的关卡会失败，但g(X)里的关卡会成功。

case和if表达式

• case表达式的语法如下：

  1case Expression of
  2	Pattern1 [when Guard1] -> Expr_seq1;
  3	Pattern2 [when Guard2] -> Expr_seq2;
  4	...
  5end
  

  首先，Expression被执行，假设它的值为Value。随后，Value轮流与Pattern1（带有可选的关卡Guard1）、Pattern2等模式进行匹配，直到匹配成功。一旦发现匹配，相应的表达式序列就会执行，而表达式序列执行的结果就是case表达式的值。如果所有模式都不匹配，就会发生异常错误（exception）。

• 条件句式if，语法如下：

  1if Guard1 ->
  2	Expr_seq1;
  3   Guard2 ->
  4      Expr_seq2;
  5   ...
  6end
  

  首先执行Guard1。如果得到的值为true，那么if的值就是执行表达式序列Expr_seq1所得到的值。如果Guard1不成功，就会执行Guard2，以此类推，直到某个关卡成功为止。if表达式必须至少有一个关卡的执行结果为true，否则就会发生异常错误。

• if是一种表达式，而所有的表达式都应该有值。为了避免可能的异常错误，Erlang程序员经常会在if表达式的最后添加一个true关卡。当然，如果他们想让异常错误生成，就会省略额外的true关卡。

• if的最后一个分支不需要加符号.

使用case定义filter:

1filter(P, [H|T]) ->
2	case P(H) of
3		true -> [H|filter(P,T)];
4		false -> filter(P,T)
5	end;
6	
7filter(P, []) ->
8	[].

只使用模式匹配定义filter:

1filter(P, [H|T]) -> filter1(P(H), H, P, T);
2filter(P, []) -> [].
3
4filter1(true, H, P, T) -> [H|filter(P,T)];
5filter1(false,H, P, T) -> filter(P, T);

if例子:

1if
2	A>0 ->
3		do_this();
4	true ->
5		do_that();
6end

构建列表的方式

• 构建列表最有效率的方式是向某个现成列表的头部添加元素，因此经常能看到包含以下模式的代码：

  1some_function([H|T],...,Result,...) ->
  2	H1 = ... H ...,
  3	some_function(T, ..., [H1|Result], ...);
  4some_function([], ..., Result, ...) ->
  5	{..., Result, ...}.
  

  这段代码会遍历一个列表，提取出列表头H并根据函数的算法计算出某个值（可以称之为H1），然后把H1添加到输出列表Result里。当输入列表被穷尽后，最后的子句匹配成功，函数返回输出变量Result。

• 建议：

  • 总是向列表头添加元素。
  • 从输入列表的头部提取元素，然后把它们添加到输出列表的头部，形成的结果是与输入列表顺序相反的输出列表。
  • 如果顺序很重要，就调用lists:reverse/1这个高度优化过的函数。

归集器

两种将列表中的元素分为奇数和偶数的代码：

1.列表推导

1odds_and_evens1(L) ->
2    Odds = [X || X <- L, (X rem 2) =:= 1],
3    Evens = [X || X <- L, (X rem 2) =:= 0],
4    {Odds, Evens}.

2.归集器

 1odds_and_evens2(L) ->
 2    odds_and_evens_acc(L, [], []).
 3
 4odds_and_evens_acc([H|T], Odds, Evens) ->
 5    case (H rem 2) of
 6        1 -> odds_and_evens_acc(T,[H|Odds],Even);
 7        0 -> odds_and_evens_acc(T,Odds,[H|Even])
 8    end;
 9odds_and_evens_acc([],Odds,Evens) ->
10    {Odds, Evens}.

• 第一段代码遍历了两次
• 第二段程序只遍历列表一次，把奇偶参数分别添加到合适的列表里。这些列表被称为归集器（accumulator）。
• 这段代码还有一个不太明显的额外的优点：带归集器的版本比[H || filter(H)]类型结构的版本更节省空间。
• 第二段奇偶列表里的元素顺序是反转的。这是列表的构建方式所导致的结果。

练习

(1)

扩展geometry.erl。添加一些子句来计算圆和直角三角形的面积。添加一些子句来计算各种几何图形的周长。

 1-module(geometry).
 2-export([area/1, perimeter/1]).
 3
 4% 面积
 5area({rectangle, Width, Height}) -> Width * Height;
 6area({circle, Radius}) -> 3.14159 * Radius * Radius;
 7area({square, Side}) -> Side * Side;
 8area({right_triangle, Width, Height}) -> 0.5 * Width * Height.
 9
10% 周长
11perimeter({rectangle, Width, Height}) -> 2 * (Width + Height);
12perimeter({circle, Radius}) -> 2 * 3.14159 * Radius;
13perimeter({square, Side}) -> 4 * Side;
14perimeter({right_triangle, Width, Height}) -> Width + Height + math:sqrt(Width*Width + Height*Height).

(2)

内置函数 tuple_to_list(T) 能将元组 T 里的元素转换成一个列表。请编写一个名为my_tuple_to_list(T)的函数来做同样的事，但不要使用相同功能的内置函数。

erlang程序看似人畜无害, 实则非常难以编写.

• delete_element(Index, Tuple1) : Returns a new tuple with element at Index removed from tuple Tuple1.

1-module(mylist).
2-export([my_tuple_to_list/1]).
3
4my_tuple_to_list({}) -> [];
5my_tuple_to_list(T) ->
6    [element(1,T)|my_tuple_to_list(erlang:delete_element(1,T))].

(3)

查看 erlang:now/0 、 erlang:date/0 和 erlang:time/0 的定义 。 编写一个名为my_time_func(F)的函数，让它执行fun F并记下执行时间。编写一个名为my_date_string()的函数，用它把当前的日期和时间改成整齐的格式。

• erlang:now/0已经过期, 使用erlang:timestamp/0替代, 获取当前Erlang系统时间。
• erlang:date/0将当前日期返回为{年、月、日}。
• erlang:time/0将当前时间返回为｛小时、分钟、秒｝。

由于找不到如何处理时间差, 这个问题暂时就不处理了.

(4)

高级练习：查找Python datetime模块的手册页。找出Python的datetime类里有多少方法可以通过erlang模块里有关时间的内置函数实现。在erlang的手册页里查找等价的函数。如果有明显的遗漏，就实现它。

时间开销太大, 留在这以后说.

(5)

编写一个名为math_functions.erl的模块，并导出函数even/1和odd/1。even(X)函数应当在X是偶整数时返回true，否则返回false。odd(X)应当在X是奇整数时返回true。

 1-module(math_functions).
 2-export([even/1,odd/1]).
 3
 4even(T) ->
 5    if 
 6        (T rem 2) =:= 0 andalso is_integer(T) ->
 7            true;
 8        true ->
 9            false
10    end.
11
12
13odd(T) ->
14    if
15        (T rem 2) =:= 1 andalso is_integer(T) ->
16            true;
17        true ->
18            false
19    end.

(6)

向math_functions.erl添加一个名为filter(F, L)的高阶函数，它返回L里所有符合条件的元素X（条件是F(X)为true）。

 1-module(math_functions).
 2-export([even/1,odd/1,filter/2]).
 3
 4even(T) ->
 5    if 
 6        (T rem 2) =:= 0 andalso is_integer(T) ->
 7            true;
 8        true ->
 9            false
10    end.
11
12
13odd(T) ->
14    if
15        (T rem 2) =:= 1 andalso is_integer(T) ->
16            true;
17        true ->
18            false
19    end.
20
21filter(F,L) -> 
22    [X || X <- L, F(X)].

(7)

向math_functions.erl添加一个返回{Even, Odd}的split(L)函数，其中Even是一个包含L里所有偶数的列表，Odd是一个包含L里所有奇数的列表。请用两种不同的方式编写这个函数，一种使用归集器，另一种使用在练习6中编写的filter函数。

由于归集器在教材中的写法已经满足了本题的需要, 故只编写第二种.

注意分号;是用来分隔子句的.

 1-module(math_functions).
 2-export([filter/2,split/1]).
 3
 4
 5filter(F,L) -> 
 6    [X || X <- L, F(X)].
 7
 8split(L) ->
 9    Even = fun(T) ->
10    	if 
11        	(T rem 2) =:= 0 andalso is_integer(T) ->
12            	true;
13        	true ->
14            	false
15    	end
16    end,
17
18
19	Odd = fun(T) ->
20    		if
21        		(T rem 2) =:= 1 andalso is_integer(T) ->
22           	 		true;
23        		true ->
24            		false
25            end
26    end,
27    
28    Odds = filter(Odd, L),
29    Evens = filter(Even, L),
30    {Odds, Evens}.

第5章 记录与映射组

• 记录其实就是元组的另一种形式。通过使用记录，可以给元组里的各个元素关联一个名称。
• 映射组是键值对的关联性集合。键可以是任意的Erlang数据类型。
• 与其记住某个数据项在复杂数据结构里的存放位置，不如使用该项的名称，让系统找到数据存放的位置。记录使用一组固定且预定义的名称，而映射组可以动态添加新的名称。

映射组/记录的选择

记录：

• 当你可以用一些预先确定且数量固定的原子来表示数据时；
• 当记录里的元素数量和元素名称不会随时间而改变时；
• 当存储空间是个问题时，典型的案例是你有一大堆元组，并且每个元组都有相同的结构。

映射组：

• 当键不能预先知道时用来表示键-值数据结构；
• 当存在大量不同的键时用来表示数据；
• 当方便使用很重要而效率无关紧要时作为万能的数据结构使用；
• 用作“自解释型”的数据结构，也就是说，用户容易从键名猜出值的含义；
• 用来表示键-值解析树，例如XML或配置文件；
• 用JSON来和其他编程语言通信。

记录的使用

1. 记录声明

   1-record(Name, {
   2	%% 下面两个键带有默认值
   3	key1 = Default1,
   4	key2 = Default2,
   5	...
   6	%% 相当于未定义
   7	key3,
   8	...
   9}).
   

   Name是记录名。key1、key2这些是记录所含各个字段的名称，它们必须是原子。记录里的每个字段都可以带一个默认值，如果创建记录时没有指定某个字段的值，就会使用默认值。

2. 引用记录定义

   记录的定义既可以保存在Erlang源代码文件里，也可以由扩展名为.hrl的文件保存，然后包含在Erlang源代码文件里

   文件包含是唯一能确保多个Erlang模块共享相同记录定义的方式。

   records.hrl：

   1-record(todo, {status=reminder,who=joe,text}).
   

3. shell里，必须先把记录的定义读入shell，然后才能创建记录。我们将用shell函数rr（read records的缩写，即读取记录）来实现。

   1> rr("records.hrl")
   2[todo]
   

4. 创建记录

   1   #todo{key1=Val1, ..., keyN=ValN}
   

   所有的键都是原子，而且必须与记录定义里所用的一致。

   如果省略了一个键，系统就会用记录定义里的值作为该键的默认值。

   1> #todo{}
   2#todo{status = reminder,who = joe,text = undefined}
   3> X1 = #todo{status=urgent, text="Fix errata in book"}.
   4#todo{status = urgent,who = joe,text = "Fix errata in book"}
   

5. 复制记录

   这么做生成的是原始记录的一个副本，原始记录没有变化。

   1> X2 = X1#todo{status=done}
   2%% 创建一个X1的副本（类型必须是todo），并修改字段status的值为done。
   

6. 提取记录字段

   使用模式匹配

   1> #todo{who=W, text=Txt} = X2.
   2> W.
   3joe
   4> Txt.
   5"Fix errata in book"
   

7. 函数中模式匹配记录

   以编写模式匹配记录字段或者创建新记录的函数：

   1clear_status(#todo{status=S,who=W} = R) ->
   2	R#todo{status=finished}
   3                                               
   4%% S和W绑定了记录里的字段值
   5%% R是整个记录
   

   匹配某个类型的记录：

   1do_something(X) when is_record(X, todo) ->
   2	%% ...
   

   使用is_record函数匹配todo类型的记录。

8. 记录是元组的另一种形式

   1> X2.
   2#todo{status = done,who = joe,text = "Fix errata in book"}
   3> rf(todo).
   4ok
   5> X2.
   6{todo,done,joe,"Fix errata in book"}
   

   rf(todo)命令使shell忘了todo记录的定义。现在打印X2时，shell将X2显示成一个元组

映射组的使用

1. 属性

   • 映射组的语法与记录相似，不同之处是省略了记录名，并且键值分隔符是=>或:=。
   • 映射组是键-值对的关联性集合。
   • 映射组里的键可以是任何全绑定的Erlang数据类型（即数据结构里没有任何未绑定变量）。
   • 映射组里的各个元素根据键进行排序。
   • 在不改变键的情况下更新映射组是一种节省空间的操作。
   • 查询映射组里某个键的值是一种高效的操作。
   • 映射组有着明确的顺序。

2. 创建映射组

   1#{Key1 Op Val1, Key2 Op Val2, ..., KeyN Op ValN}
   

   Op是=>或:=这两个符号的其中一个。

   键和值可以是任何有效的Erlang数据类型。

   1> F1 = #{a=>1, b=>2}.
   2#{a=>1, b=>2}.
   3> Facts = #{{wife,fred}=>"Sue", {age,fred}=>45}.
   

3. 映射组在系统内部是作为有序集合存储的，打印时总是使用各键排序后的顺序，与映射组的创建方式无关。

   1> F2 = #{b=>1, a=>2}.
   2#{a=>2, b=>1}.
   

4. 基于现有的映射组更新一个映射组：

   1NewMap = OldMap #{K1 Op V1, ..., Kn Op Vn}
   

   表达式K => V有两种用途，一种是将现有键K的值更新为新值V，另一种是给映射组添加一个全新的K-V对。这个操作总是成功的。

   表达式K := V的作用是将现有键K的值更新为新值V。如果被更新的映射组不包含键K，这个操作就会失败。

   使用映射组的最佳方式是在首次定义某个键时总是使用Key => Val，而在修改具体某个键的值时都使用Key := Val。

   （操作是深拷贝的，这两个变量是不相关的）

5. 模式匹配映射组字段

   用来编写映射组的=>语法还可以作为映射组模式使用。和之前一样，映射组模式里的键不能包含任何未绑定变量，但是值现在可以包含未绑定变量了（在模式匹配成功后绑定）。

   （TODO 我测试这段代码失败了，不管怎么匹配都是错误的，这里留一个坑。）

   1> Henry8 = #{class=>king,born=>1491,died=>1547}.
   2> #{born => B} = Henry8.
   3> B.
   41491
   5> #{ D => 1547} = Henry8.
   6unbound
   

6. 函数头部使用包含模式的映射组

   count_characters(Str)函数，让它返回一个映射组，内含某个字符串里各个字符的出现次数。

    1%% 入口
    2count_characters(Str) ->
    3	count_characters(Str, #{}).
    4   	
    5%% 核心
    6count_characters([H|T], #{ H => N}=X) ->
    7	count_characters(T,X#{ H := N+1});
    8%% 上一条没匹配成功，表明这个字母的计数是第一次
    9count_characters([H|T], X) ->
   10	count_characters(T,X#{ H => 1});
   11%% 处理完毕
   12count_characters([], X) ->
   13	X.
   

7. 映射组api：

   • map:new() -> #{} 返回一个新的空映射组。
   • erlang:is_map(M) -> bool() 如果M是映射组就返回true，否则返回false。它可以用在关卡测试或函数主体中。
   • maps:to_list(M) -> [{K1,V1, ..., {Kn,Vn}] 把映射组M里的所有键和值转换成一个键值列表。键在生成的列表里严格按升序排列。
   • maps:from_list([{K1,V1}, ..., {Kn,Vn}]) -> M把一个包含键值对的列表转换成映射组M。如果同样的键不止一次出现，就使用列表里第一个键所关联的值，后续的值都会被忽略。
   • maps:map_size(Map) -> NumberOfEntries返回映射组里的条目数量。
   • maps:is)key(Key,Map)-> bool()如果映射组包含一个键为Key的项就返回true，否则返回false。
   • maps:get(Key,Map)->Val返回映射组里与Key关联的值，否则抛出一个异常错误。
   • maps:find(Key,Map)->{ok,Value}|error返回映射组里与Key关联的值，否则返回error。
   • maps:keys(Map)->[Key1,...,KeyN]返回映射组所含的键列表，按升序排列。
   • maps:remove(Key,M)->M1返回一个新映射组M1，除了键为Key的项（如果有的话）被移除外，其他与M一致。
   • maps:without([Key1,...,KeyN],M)->M1返回一个新映射组M1，它是M的复制，但移除了带有[Key1,…,KeyN]列表里这些键的元素。
   • maps:difference(M1,M2)->M3M3是M1的复制，但移除了那些与M2里的元素具有相同键的元素。

8. 映射组排序规则

   映射组在比较时首先会比大小，然后再按照键的排序比较键和值。

   • 如果A和B是映射组，那么当maps:size(A) < maps:size(B)时A < B。
   • 如果A和B是大小相同的映射组，那么当maps:to_list(A) < maps:to_list(B)时A < B。
   • 当映射组与其他Erlang数据类型相比较时，因为我们认为映射组比列表或元组“更复杂”，所以映射组总是会大于列表或元组。

   1A = #{age => 23, person => "jim"} < B = # {email => "[email protected]", name => "sue"}
   2   
   3%% A的最小键（age）比B的最小键（email）更小。
   

9. 映射组可以通过io:format里的~p选项输出，并用io:read或file:consult读取。

10. 映射组和JSON相关api

    • maps:to_json(Map) ->Bin 把一个映射组转换成二进制型，它包含用JSON表示的该映射组。
    • maps:from_json(Bin) -> Map 把一个包含JSON数据的二进制型转换成映射组。
    • maps:safe_from_json(Bin) -> Map 把一个包含JSON数据的二进制型转换成映射组。Bin里的任何原子必须在调用此内置函数前就已存在，否则就会抛出一个异常错误。这样做是为了防止创建大量的新原子。出于效率的原因，Erlang不会垃圾回收（garbage collect）原子，所以连续不断地添加新原子会（在很长一段时间后）让Erlang虚拟机崩溃。

    上面两种定义里的Map都必须是json_map()类型的实例。

    （目前maps模块已经没有这些函数了，还是需要另外查询）

11. JSON对象与Erlang值的映射关系：json_map()类型

    1-type json_map() = [{json_key(), json_value()}].
    2    
    3-type json_key() = 
    4	atom() | binary() | io_list()
    5    	
    6-type json_value() = 
    7	integer() | binary() | float() | atom() | [json_value()] | json_map()
    

    • JSON的数字用Erlang的整数或浮点数表示。
    • JSON的字符串用Erlang的二进制型表示。
    • JSON的列表用Erlang的列表表示。
    • JSON的true和false用Erlang的原子true和false表示。
    • JSON的对象用Erlang的映射组表示，但是有限制：映射组里的键必须是原子、字符串或二进制型，而值必须可以用JSON的数据类型表示。

    当来回转换JSON数据类型时，应当注意一些特定的转换限制。Erlang对整数提供了无限的精度。所以，Erlang会很自然地把映射组里的某个大数转换成JSON数据里的大数，而解码此JSON数据的程序不一定能理解它。

练习

(1)

配置文件可以很方便地用JSON数据表示。请编写一些函数来读取包含JSON数据的配置文件，并将它们转换成Erlang的映射组。再编写一些代码，对配置文件里的数据进行合理性检查。

json:

1{
2	{username, liming},
3	{password, 123456},
4	{location, beijing},
5	{male, true}
6}

等到以后再来。

(2)

编写一个map_search_pred(Map, Pred) 函数，让它返回映射组里第一个符合条件的{Key,Value}元素（条件是Pred(Key, Value)为true）。

 1-module(map_search).
 2-export([map_search_pred/2]).
 3
 4map_search_pred(Map, Pred) ->
 5	list_search_pred(maps:to_list(Map), Pred).
 6
 7list_search_pred([H|T], Pred) -> 
 8	{K,V} = H,
 9	case Pred(K,V) of
10		true -> {K,V};
11		false -> list_search_pred(T, Pred)
12	end;
13list_search_pred([], Pred) ->
14	"None of them matchs".

测试：

1Pred = fun(a,V) -> V=:=1;
2		  (b,V) -> V=:=2
3	   end.
4	   
5M1 = #{a=>2, b=>2}.

第6章 顺序程序的错误处理

书本内容

1. 在Erlang里，单个进程的崩溃就不那么重要了，前提是其他某些进程能察觉这个崩溃，并接手崩溃进程原本应该做的事情。

2. Erlang里，防御式编程是内建的。在描述函数的行为时应该只考虑合法的输入参数，其他所有参数都将导致内部错误并自动被检测到。永远不能让函数对非法的参数返回值，而是应该抛出一个异常错误。这条规则被称为“任其崩溃”。

3. 显式生成错误：

   • exit(Why) 当你确实想要终止当前进程时就用它。如果这个异常错误没有被捕捉到，信号{‘EXIT’,Pid,Why}就会被广播给当前进程链接的所有进程。
   • throw(Why) 抛出一个调用者可能想要捕捉的异常错误。在这种情况下，我们注明了被调用函数可能会抛出这个异常错误。有两种方法可以代替它使用：可以为通常的情形编写代码并且有意忽略异常错误，也可以把调用封装在一个try…catch表达式里，然后对错误进行处理。
   • error(Why) 这个函数的作用是指示“崩溃性错误”，也就是调用者没有准备好处理的非常严重的问题。它与系统内部生成的错误差不多。

4. Erlang有两种方法来捕捉异常错误。第一种是把抛出异常错误的调用函数封装在一个try...catch表达式里，另一种是把调用封装在一个catch表达式里。

5. try catch语法

    1try FuncOrExpressionSeq of
    2	Pattern1 [when Guard1] -> Expressions1;
    3	Pattern2 [when Guard2] -> Expressions2;
    4	...
    5catch
    6	ExceptionType1: ExPattern1 [when ExGuard1] -> ExExpressions1;
    7	ExceptionType2: ExPattern2 [when ExGuard2] -> ExExpressions2;
    8	...
    9after
   10	AfterExoressuibs
   11end
   

   首先执行FuncOrExpessionSeq。如果执行过程没有抛出异常错误，那么函数的返回值就会与Pattern1（以及可选的关卡Guard1）、Pattern2等模式进行匹配，直到匹配成功。如果能匹配，那么整个try…catch的值就通过执行匹配模式之后的表达式序列得出。

   如果FuncOrExpressionSeq在执行中抛出了异常错误，那么ExPattern1等捕捉模式就会与它进行匹配，找出应该执行哪一段表达式序列。ExceptionType是一个原子（throw、exit和error其中之一），它告诉我们异常错误是如何生成的。如果省略ExceptionType，就会使用默认值throw。

   关键字after之后的代码是用来在FuncOrExpressionSeq结束后执行清理的。这段代码一定会被执行 ， 哪怕有异常错误抛出也是如此。after区块的代码会在try或catch区块里的Expressions代码完成后立即运行。AfterExpressions的返回值会被丢弃。

6. try catch简写

   1try F
   2catch
   3	...
   4end
   

7. try catch样例

   try_test.erl:

    1generate_exception(1) -> a;
    2generate_exception(2) -> throw(a);
    3generate_exception(3) -> exit(a);
    4generate_exception(4) -> {'EXIT', a};
    5generate_exception(5) -> error(a);
    6   
    7demo1() ->
    8    [catcher(I) || I <- [1,2,3,4,5]].
    9   
   10catcher(N) ->
   11    try generate_exception(N) of
   12        Val -> {N, normal, Val}
   13    catch
   14        throw:X -> {N, caught, thrown, X};
   15        exit:X -> {N, caught, exited, X};
   16        error:X -> {N, caught, error, X}
   17    end.
   

   1[{1,normal,a},
   2 {2,caught,thrown,a},
   3 {3,caught,exited,a},
   4 {4,normal,{'EXIT',a}},
   5 {5,caught,error,a}]
   

8. 用catch捕获异常

   try_test.erl:

   1demo2() ->
   2	[{I, (catch generate_exception(I))} || I <- [1,2,3,4,5]]
   

   1[{1,a},
   2 {2,a},
   3 {3,{'EXIT',a}},
   4 {4,{'EXIT',a}},
   5 {5,{'EXIT',
   6         {a,[try_test,genera....]}}}]
   

   提供了详细的栈跟踪信息。

9. 针对异常错误的代码模式

   • 改进错误消息

     1sqrt(X) when X < 0 ->
     2    error({squareRootNegativeArgument, X});
     3sqrt(X) ->
     4    math:sqrt(X).
     

   • 函数经常返回错误时该这么写：

     1case f(X) of
     2	{ok, Val} ->
     3       do_some_thing_with(Val);
     4     	
     5	{error, Why} ->
     6       %% 处理错误
     7end,
     8...
     

   • 错误罕见但可能有该这么写：

     1try my_func(X)
     2catch
     3	throw:{thisError, X} -> ...
     4	throw:{someOtherError, X} -> ...
     5end
     

   • 捕捉一切可能的异常：

     1try Expr
     2catch
     3	_:_ -> ... 处理所有异常错误的代码
     4end
     

     如果漏写了标签_ -> ...，就不会捕捉到所有的错误，因为在这种情形下系统会假设标签是默认的throw。

10. 栈跟踪信息

    捕捉到一个异常错误后，可以调用erlang:get_stacktrace()来找到最近的栈跟踪信息。

    1demo3() ->
    2	try generate_exception(5)
    3	catch
    4        error:X ->
    5            {X, erlang:get_stacktrace()}
    6	end.
    

11. 要牢记的一个重点是任其崩溃。永远不要在函数被错误参数调用时返回一个值，而是要抛出一个异常错误。要假定调用者会修复这个错误。在Erlang里，当系统内部或程序逻辑检测出错误时，正确的做法是立即崩溃并生成一段有意义的错误消息。立即崩溃是为了不让事情变得更糟。错误消息应当被写入永久性的错误日志，而且要包含足够多的细节，以便过后查明是哪里出了错。

练习

(1)

file:read_file(File)会返回{ok, Bin}或者{error, Why}，其中File是文件名，Bin则包含了文件的内容。请编写一个myfile:read(File)函数，当文件可读取时返回Bin，否则抛出一个异常错误。

 1-module(myfile).
 2-export([read/1])
 3
 4read(File) ->
 5	case file:read_file(File) of
 6		{ok, Bin} ->
 7			Bin;
 8		{error, Why} ->
 9			throw(Why)
10	end.
11

(2)

重写try_test.erl里的代码，让它生成两条错误消息：一条文明的消息给用户，另一条详细的消息给开发者。

 1generate_exception(1) -> a;
 2generate_exception(2) -> throw("遇到2,程序异常");
 3generate_exception(3) -> exit("遇到3,程序退出");
 4generate_exception(4) -> {'EXIT', a};
 5generate_exception(5) -> error("遇到5,程序错误");
 6
 7demo1() ->
 8    [catcher(I) || I <- [1,2,3,4,5]].
 9
10catcher(N) ->
11    try generate_exception(N) of
12        Val -> {N, normal, Val}
13    catch
14        throw:X -> {N, caught, thrown, X, "程序暂不可用"};
15        exit:X -> {N, caught, exited, X, "程序退出"};
16        error:X -> {N, caught, error, X, "程序错误"}
17    end.

第7章 二进制型与位语法

二进制型

• 二进制型的编写和打印形式是双小于号与双大于号之间的一列整数或字符串。

  在二进制型里使用整数时，它们必须属于0至255这个范围 。

  如果某个二进制型的内容是可打印的字符串，shell就会将这个二进制型打印成字符串，否则就打印成一列整数。

  1> <<5,10,20>>.
  2<<5,10,20>>
  3> <<"hello">>.
  4<<"hello">>
  5> <<65,66,67>>.
  6<<"ABC">>
  

• 操作二进制型的内置函数(binary模块里的函数)：

  • list_to_binary(L) -> B list_to_binary返回一个二进制型，它是通过把io列表（iolist）L里的所有元素压扁后形成的（压扁的意思是移除列表里所有的括号）。
  • split_binary(Bin, Pos) -> {Bin1, Bin2} 这个函数在Pos处把二进制型Bin一分为二。
  • term_to_binary(Term) -> Bin 这个函数能把任何Erlang数据类型转换成一个二进制型。数据类型通过term_to_binary转换成二进制型后可以被保存在文件里，作为消息通过网络发送，等等，而转换前的初始数据类型可以在稍后重建。对于在文件里保存复杂数据结构，或者向远程机器发送复杂数据结构而言，这是极其有用的。
  • binary_to_term(Bin) -> Term 这是term_to_binary的逆向函数。
  • byte_size(Bin) -> Size 这个函数返回二进制型里的字节数。

位语法

1.概念

• 位语法表达式：

  1<<>>
  2<<E1,E2,...,En>>
  

  每个Ei元素都标识出二进制型或位串里的一个片段。单个Ei元素可以有4种形式：

  1Ei = Value | 
  2   Value:Size |
  3   Value/TypeSpecifierList | 
  4   Value:Size/TypeSpecifierList
  

  如果表达式的总位数是8的整数倍，就会构建一个二进制型，否则构建一个位串。

  Size的值指明了片段的大小。它的默认值取决于不同的数据类型，对整数来说是8，浮点数则是64，如果是二进制型就是该二进制型的大小。在模式匹配里，默认值只对最后那个元素有效。如果未指定片段的大小，就会采用默认值。

• TypeSpecifierList （类型指定列表）是一个用连字符分隔的列表，形式为 End-Sign-Type-Unit。前面这些项中的任何一个都可以被省略，各个项也可以按任意顺序排列。如果省略了某一项，系统就会使用它的默认值。

  • End可以是big | little | native

    它指定机器的字节顺序。native是指在运行时根据机器的CPU来确定。默认值是big，也就是网络字节顺序（network byte order）。这一项只和从二进制型里打包和解包整数与浮点数有关。

    term_to_binary和binary_to_term可以帮你搞定打包和解包整数的工作。因此，你可以在高位优先（big-endian）的机器上创建一个包含整数的元组，然后用term_to_binary把它转换成二进制型并发送至低位优先（little-endian）的机器。最后，在低位优先的机器上运行binary_to_term，这样元组里所有整数的值都会是正确的。

  • Sign可以是signed|unsigned

    这个参数只用于模式匹配。默认值是unsigned。

  • Type可以是integer|float|binary|bytes|bitstring|bits|utf8|utf16|utf32。

    默认值是integer。

  • Unit的写法是unit:1|2|…256 integer、float和bitstring的Unit默认值是1，binary则是8。utf8、utf16和utf32类型无需提供值。

2.例子

• 寻找MPEG数据里的同步帧

  mp3_sync.erl:

   1find_sync(Bin, N) ->
   2    case is_header(N, Bin) of
   3        {ok, Len1, _} ->
   4            case is_header(N+Len1, Bin) of
   5                {ok, Len2, _} ->
   6                    case is_header(N+Len1+Len2, Bin) of
   7                        {ok,_ ,_} ->
   8                            {ok, N};
   9                        error ->
  10                            find_sync(Bin,N+1)
  11                     end;
  12                error ->
  13                    find_sync(Bin,N+1)
  14             end;
  15        error ->
  16            find_sync(Bin,N+1)
  17    end.
  18  
  19is_header(N, Bin) ->
  20    unpack_header(get_word(N, Bin)).
  21  
  22%% 提取32位数据进行分析
  23get_word(N, Bin) ->
  24    {_, <<C:4/binary,_/binary>>} = split_binary(Bin,N),
  25    C.
  26  
  27unpack_header(X) ->
  28    try decode_header(X)
  29    catch
  30      _:_ -> error
  31    end.
  32            
  33%% 2#11111111111是个二进制整数，因此这个模式匹配11个连续的1位，指派给B2位，指派给C2位，以此类推。请注意，这段代码严格遵循之前给出的位级MPEG头规范。
  34decode_header(<<2#11111111111,B:2,C:2,_D:1,E:4,F:2,G:1,Bits:9>>) ->
  35    Vsn = case B of
  36              0 -> {2,5};
  37              1 -> exit(badVsn);
  38              2 -> 2;
  39              3 -> 1
  40           end,
  41    Layer = case C of
  42                0 -> exit(badLayer);
  43                1 -> 3;
  44                2 -> 2;
  45                3 -> 1
  46             end,
  47    %% Protection = D,
  48    BitRate = bitrate(Vsn, Layer, E) * 1000,
  49    SampleRate = samplerate(Vsn, F),
  50    Padding = G,
  51    FrameLength = framelength(Layer, BitRate, SampleRate, Padding),
  52    if
  53        FrameLength < 21 ->
  54            exit(frameSize);
  55        ture ->
  56            {ok, FrameLength, {Layer,BitRate,SampleRate,Vsn,Bits}}
  57    end;
  58decode_header(_) ->
  59    exit(badHeader).
  

  这个例子中<<C:4/binary,_/binary>>需要注意，这里C是匹配了32位。

• 解包COFF数据

  要展开这些宏，需要使用?DWORD和?LONG之类的语法。举个例子，宏?DWORD会展开成文本字面量32/unsigned-little-integer。

  1-define(DWORD, 32/unsigned-little-integer).
  2-define(LONG, 32/unsigned-litter-integer).
  3-define(WORD, 16/unsigned-litter-integer).
  4-define(BYTE, 8/unsigned-litter-integer).
  5  
  6unpack_image_resource_directory(Dir) ->
  7    <<Characteristics : ?DWORD,
  8      TimeDateStamp : ?DWORD,
  9      MajorVersion: ?WORD,...
  

位串

• 没有按照8位边界对齐的数据或者可变长度数据，它们的数据长度用位而不是字节来表示。

•  1> B1 = <<1:8>>.
   2<<1>>
   3> byte_size(B1).
   41
   5  
   6> B2 = <<1:17>>.
   7<<0,0,1:1>>
   8> byte_size(B2).
   93
  10> bit_size(B2).
  1117
  12  
  13%% B1是一个二进制型，而B2是一个位串，因为它的长度是17位。
  14%% 我们用语法<<1:17>>构建了B2，它被打印成<<0,0,1:1>>，也就是说，作为一个二进制型字面量，它的第三个片段是一个长度为1的位串。
  15%% B2的位大小是17，而字节大小是3（这是包含该位串的二进制型的实际大小）。
  

• 位推导

  1> B = <<16#5f>>.
  2> [X || <<X:1>> <= B].
  3[0,1,0,1,1,1,1,1]
  4> << <<X>> || <<X:1>> <= B >>.
  5<<0,1,0,1,1,1,1,1>>
  

练习

(1)

编写一个函数来反转某个二进制型里的字节顺序。

反转的是字节顺序而不是位的顺序

 1reverseByte(Bin) ->
 2	list_to_binary(reverseByteList(Bin)).
 3	
 4reverseByteList(Bin) when size(Bin) =:= 1 ->
 5	<<Val>> = Bin,
 6	Val;
 7reverseByteList(Bin) ->
 8	{Bf, Bl} = split_binary(Bin,1),
 9	<<Val:8>> = Bf,
10	[reverseByteList(Bl) , Val]. 
11	

(2)

编写一个term_to_packet(Term) -> Packet函数，通过调用term_to_binary(Term)来生成并返回一个二进制型，它内含长度为4个字节的包头N，后跟N个字节的数据。

1term_to_packet(Term) ->
2	B = term_to_binary(Term),
3	<<Head:4/binary, Data>> = B,
4	{packet, Head, Data}.

(3)

编写一个反转函数 packet_to_term(Packet) -> Term，使它成为前一个函数的逆向函数。

1packet_to_term(Packet) ->
2	{_, Head, Data} = Packet,
3	binary_to_term(<<Head, Data>>).

(4)

按照4.1.3节的样式编写一些测试，测一下之前的两个函数是否能正确地把数据类型编码成数据包（packet），以及通过解码数据包来复原最初的数据类型。

不知道如何构造数据包，这道题就算了。

(5)

编写一个函数来反转某个二进制型所包含的位。

1reversebit(Bit) ->
2	Res = [ X || <<X:1>> <= Bit ],
3	list_to_binary(list:reverse(Res)).

第8章 Erlang顺序编程补遗

书本内容

本章知识比较杂乱，一些地方没有记，需要时翻原书。

1. 内置函数apply(Mod, Func, [Arg1, Arg2, ..., ArgN])会将模块Mod里的Func函数应用到Arg1, Arg2, … ArgN这些参数上。

   所有的Erlang内置函数也可以通过apply进行调用，方法是假定它们都属于erlang模块。

   apply的Mod参数不必非得是一个原子，也可以是一个元组。这种机制可以用来创建“有状态的模块”（将在24.3节里讨论）和“适配器模式”（将在24.4节里讨论）。

2. 算术表达式

   数字的意思是此参数可以是整数或浮点数

   操作符	描述	参数类型	优先级
   + X	+ X	数字	1
   - X	- X	数字	1
   X * Y	X * Y	数字	2
   X / Y	X / Y（浮点除法）	数字	2
   bnot X	对X执行按位取反（bitwise not）	整数	2
   X div Y	X被Y整除	整数	2
   X rem Y	X除以Y的整数余数	整数	2
   X band Y	对X和Y执行按位与（bitwise and）	整数	2
   X + Y	X + Y	数字	3
   X - Y	X - Y	数字	3
   X bor Y	对X和Y执行按位或（bitwise or）	整数	3
   X bxor Y	对X和Y执行按位异或（bitwise xor）	整数	3
   X bsl N	把X向左算术位移（arithmetic bitshift）N位	整数	3
   X bsr N	把X向右算术位移N位	整数	3

3. 一个函数的元数（arity）是该函数所拥有的参数数量。在Erlang里，同一模块里的两个名称相同、元数不同的函数是完全不同的函数。除了碰巧使用同一个名称外，它们之间毫不相关。

4. 模块属性的语法是-AtomTag(…)，它们被用来定义文件的某些属性。（注意：-record(…)和-include(…)有着类似的语法，但是不算模块属性。）

5. -compile(export_all).这个编译器选项经常会在调试程序时用到。它会导出模块里的所有函数，无需再显式使用-export标识了。

6. 块表达式用于以下情形：代码某处的Erlang语法要求单个表达式，但我们想使用一个表达式序列。

   在一个形式为[E || …]的列表推导中，语法要求E是单个表达式，但我们也许想要在E里做不止一件事情。

   1begin
   2	Expr1,
   3	Expr2,
   4	...
   5	ExprN
   6end
   

7. Erlang没有单独的布尔值类型。不过原子true和false具有特殊的含义，可以用来表示布尔值。

8. 布尔表达式not，and，or，xor

9. Erlang里的注释从一个百分号字符（%）开始，一直延伸到行尾。Erlang没有块注释。Erlang里的注释从一个百分号字符（%）开始，一直延伸到行尾。Erlang没有块注释。

10. 动态代码载入每当调用someModule:someFunction(…)时，调用的总是最新版模块里的最新版函数，哪怕当代码在模块里运行时重新编译了该模块也是如此。

    在任一时刻，Erlang允许一个模块的两个版本同时运行：当前版和旧版。重新编译某个模块时，任何运行旧版代码的进程都会被终止，当前版成为旧版，新编译的版本则成为当前版。

11. 查看some_module.erl模块的预处理结果: erlc -P some_module.erl 这会生成一个名为some_module.P的清单文件。

12. 可以在字符串和带引号的原子里使用转义序列来输入任何不可打印的字符。

    1> io:format("~w~n", ["\b\d\e\f\n\r\s\t\v"]).
    2[8,127,27,12,10,13,32,9,11]
    3% 格式字符串里的~w是指忠实地打印列表，而不对输出结果进行美化。
    

13. 在Erlang里，任何可以执行并生成一个值的事物都被称为表达式（expression）。

    表达式序列（expression sequence）是一系列由逗号分隔的表达式。它们在->箭头之后随处可见。表达式序列E1, E2,…, En的值被定义为序列最后那个表达式的值，而该表达式在计算时可以使用E1, E2等表达式所创建的绑定。

14. 包含文件-include(Filename)

    包含库的头文件-include_lib(Name)

    按照Erlang的惯例，包含文件的扩展名是.hrl。包含文件里经常会有记录的定义。如果许多模块需要共享通用的记录定义，就会把它们放到包含文件里，再由所有需要这些定义的模块包含此文件。

15. ++和–是用于列表添加和移除的中缀操作符。 A ++ B使A和B相加（也就是附加）。 A – B从列表A中移除列表B。移除的意思是B中所有元素都会从A里面去除。请注意：如果符号X在B里只出现了K次，那么A只会移除前K个X。

    ++也可以用在模式里。在匹配字符串时，可以编写如下模式：

    1f("begin" ++ T) ->...
    

    模式会扩展成[$b,$e,$g,$i,$n|T]。

16. 宏的写法：

    define(Constant, Replacement).

    define(Func(Var1, Var2,..., Var), Replacement).

    当Erlang的预处理器epp碰到一个?MacroName形式的表达式时，就会展开这个宏。宏定义里出现的变量会匹配对应宏调用位置的完整形式。

17. 还有一些预定义宏提供了关于当前模块的信息。列举如下：

    • ?FILE展开成当前的文件名；
    • ?MODULE展开成当前的模块名；
    • ?LINE展开成当前的行号。

18. 宏控制流。模块的内部支持下列指令，可以用它们来控制宏的展开。

    • -undef(Macro). 取消宏的定义，此后就无法调用这个宏了。
    • -ifdef(Macro). 仅当Macro有过定义时才执行后面的代码。
    • -ifndef(Macro). 仅当Macro未被定义时才执行后面的代码。
    • -else. 可用于ifdef或ifndef语句之后。如果条件为否，else后面的语句就会被执行。
    • -endif. 标记ifdef或ifndef语句的结尾。

19. 用宏实现DEBUG：

     1-module(m1).
     2-export([loop/1]).
     3    
     4-ifdef(debug_flag),
     5-define(DEBUG(X), io:format("DEBUG ~p:~p ~p~n"m [?MODULE,?LINE,X])).
     6% io:format(String, [Args])会根据String里的格式信息在Erlang shell 中打印出[Args]所含的变量。
     7% 格式编码用一个~符号作为前缀。
     8% ~p是美化打印（pretty print）的简称，~n则会生成一个新行。
     9-else.
    10-define(DEBUG(X), void).
    11-endif
    12    
    13loop(0) ->
    14    done;
    15loop(N) ->
    16    ?DEBUG(X),
    17    loop(N-1).
    

    为了启用这个宏，我们在编译代码时设置了debug_flag。具体做法是给c/2添加一个额外参数如下：

    1> c(m1, {d,debug_flag}).
    2{ok,m1}
    3> m1:loop(4)
    4DEBUG m1:13 4
    5DEBUG m1:13 3
    6DEBUG m1:13 2
    7DEBUG m1:13 1
    8done
    

20. 模式的匹配操作符（把这个模式指派给一个临时变量Z）

    1func([{tag, {one,A}=Z1, B}=Z2|T]) ->
    2	...
    3	...f(...,Z2,...),
    4	...g(...,Z1,...),
    

21. 整数可以有三种不同的写法：

    • 传统写法
    • K进制整数 K#Digits
    • $ 写法：$C这种写法代表了ASCII字符C的整数代码。

22. 进程字典：每个Erlang进程都有一个被称为进程字典（process dictionary）的私有数据存储区域。进程字典是一个关联数组（在其他语言里可能被称作map、hashmap或者散列表），它由若干个键和值组成。每个键只有一个值。

    API：

    • put(Key,Value) -> OldValue.

      给进程字典添加一个Key, Value组合。put的值是OldValue，也就是Key之前关联的值。如果没有之前的值，就返回原子undefined。

    • get(Key) -> Value.

      查找Key的值。如果字典里存在Key, Value组合就返回Value，否则返回原子undefined。

    • get() -> [{Key,Value}].

      返回整个字典，形式是一个由{Key,Value}元组所构成的列表。

    • get_keys(Value) ->[Key].

      返回一个列表，内含字典里所有值为Value的键。

    • erase(Key) -> Value.

      返回Key的关联值，如果不存在则返回原子undefined。最后，删除Key的关联值。

    • erase() -> [{Key,Value}].

      删除整个进程字典。返回值是一个由{Key,Value}元组所构成的列表，代表了字典删除之前的状态。

23. 引用（reference）是一种全局唯一的Erlang数据类型。它们由内置函数erlang:make_ref()创建。引用的用途是创建独一无二的标签，把它存放在数据里并在后面用于比较是否相等。

24. 短路布尔表达式（short-circuit boolean expression）是一种只在必要时才对参数求值的表达式。在对应的布尔表达式里（A or B和A and B），两边的参数总会被执行，即使表达式的真值只需要第一个表达式的值就能确定也是如此。

    1Expr1 orelse Expr2
    2% 它会首先执行Expr1。如果Expr1的执行结果是true，Expr2就不再执行。如果Expr1的执行结果是false，则会执行Expr2。
    3    
    4Expr1 andalso Expr2
    5% 它会首先执行Expr1。如果Expr1的执行结果是true，则会执行Expr2。如果Expr1的执行结果是false，Expr2就不再执行。
    

25. 比较数据类型

    • 操作符	含义
      X > Y	X大于Y
      X < Y	X小于Y
      X =< Y	X等于或小于Y
      X >= Y	X大于或等于Y
      X == Y	X等于Y
      X /= Y	X不等于Y
      X =:= Y	X与Y完全相同
      X =/= Y	X与Y不完全相同

    • 数据类型做了全排序（total ordering）的定义：

      number < atom < reference < fun < port < pid < tuple(record) < map < list < binary

    • 所有的数据类型比较操作符（除了=:=和=/=）在参数全为数字时具有以下行为:

      如果一个参数是整数而另一个是浮点数，那么整数会先转换成浮点数，然后再进行比较。

      如果两个参数都是整数或者都是浮点数，就会“按原样”使用，也就是不做转换。

    • 如果==的参数不包含任何浮点数的话，那么这两个操作符的行为就是相同的。

    • 函数的子句匹配总是意味着精确的模式匹配，所以如果定义了一个fun F =fun(12) -> … end，那么试图执行F(12.0)就会出错。

26. 下划线变量,_VarName 这种特殊语法代表一个常规变量（normalvariable），而不是匿名变量。

    下划线变量有两种主要的用途:

    • 命名一个我们不打算使用的变量。例如，相比open(File, _)，open(File, _Mode)这种写法能让程序的可读性更高。

    • 用于调试:

      1some_func(X) ->
      2	{P,Q} = some_other_func(X),
      3	%% io:format("Q = ~p~n", [Q]),
      4	P.
      5% 如果编译它，编译器就会生成一个变量Q未使用的警告。
      

      1some_func(X) ->
      2	{P,_Q} = some_other_func(X),
      3	%% io:format("_Q = ~p~n", [_Q]),
      4	P.
      5% 编译器也不会再抱怨了。
      

      一般来说，当某个变量在子句里只使用了一次时，编译器会生成一个警告，因为这通常是出错的信号。但如果这个只用了一次的变量以下划线开头，就不会有错误消息。

练习

(2)

code:all_loaded()命令会返回一个由{Mod,File}对构成的列表，内含所有Erlang系统载入的模块。使用内置函数Mod:module_info()了解这些模块。编写一些函数来找出哪个模块导出的函数最多，以及哪个函数名最常见。编写一个函数来找出所有不带歧义的函数名，也就是那些只在一个模块里出现过的函数名。

我们从code:all_loaded()开始：

 12> code:all_loaded().
 2[{erpc,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/erpc.beam"},
 3 {rpc,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/rpc.beam"},
 4 {os,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/os.beam"},
 5 {inet_parse,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/inet_parse.beam"},
 6 {prim_inet,preloaded},
 7 {erts_dirty_process_signal_handler,preloaded},
 8 {socket_registry,preloaded},
 9 {error_logger,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/error_logger.beam"},
10 {logger_proxy,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/logger_proxy.beam"},
11 {logger_backend,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/logger_backend.beam"},
12 {proplists,"/usr/lib/erlang/lib/stdlib-4.3.1.3/ebin/proplists.beam"},
13 {gb_trees,"/usr/lib/erlang/lib/stdlib-4	.3.1.3/ebin/gb_trees.beam"},
14 {logger_handler_watcher,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/logger_handler_watcher.beam"},
15 {logger_sup,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/logger_sup.beam"},
16 {erl_parse,"/usr/lib/erlang/lib/stdlib-4.3.1.3/ebin/erl_parse.beam"},
17 {init,preloaded},
18 {erl_features,"/usr/lib/erlang/lib/stdlib-4.3.1.3/ebin/erl_features.beam"},
19 {application_controller,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/application_controller.beam"},
20 {user_sup,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/user_sup.beam"},
21 {io,"/usr/lib/erlang/lib/stdlib-4.3.1.3/ebin/io.beam"},
22 {edlin,"/usr/lib/erlang/lib/stdlib-4.3.1.3/ebin/edlin.beam"},
23 {erl_distribution,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/erl_distribution.beam"},
24 {prim_socket,preloaded},
25 {logger_filters,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/logger_filters.beam"},
26 {io_lib,"/usr/lib/erlang/lib/stdlib-4.3.1.3/ebin/io_lib.beam"},
27 {error_handler,"/usr/lib/erlang/lib/kernel-8.5.4.2/ebin/error_handler.beam"},
28 {prim_buffer,preloaded},
29 {zlib,...},
30 {...}|...]

返回的以一个列表，里面都是模块名+位置组成的元组，我们只需要模块名即可。

拿到一个模块名，我们就调用Mod:module_info()：

 14> erlang:module_info().
 2[{module,erlang},
 3 {exports,[{binary_to_atom,1},
 4           {binary_to_existing_atom,1},
 5           {binary_to_integer,1},
 6           {binary_to_integer,2},
 7           {check_process_code,2},
 8           {check_process_code,3},
 9           {alias,0},
10           {garbage_collect,1},
11           {garbage_collect,2},
12           {garbage_collect_message_area,0},
13           {is_alive,0},
14           {list_to_integer,2},
15           {process_display,2},
16           {process_flag,3},
17           {setnode,3},
18           {suspend_process,2},
19           {suspend_process,1},
20           {trace_pattern,2},
21           {spawn,2},
22           {spawn_link,2},
23           {spawn_monitor,2},
24           {spawn_monitor,3},
25           {spawn_opt,2},
26           {spawn_opt,...},
27           {...}|...]},
28 {attributes,[]},
29 {compile,[]},
30 {md5,<<192,119,22,112,208,85,113,68,95,199,120,159,236,
31        64,31,14>>}]
32

所以每一个调用又返回一个列表，我们需要的是{export,[]}这个，里面全是函数名和元数，我们拿到这些东西就可以进行处理了。

三个问题：

1. 找出哪个模块导出的函数最多
2. 哪个函数名最常见
3. 找出所有不带歧义的函数名，也就是那些只在一个模块里出现过的函数名

先就做到这程度。编程里面涉及到严重的问题，普通循环和遍历到底该怎么写？还有Erlang中的变量不可再绑定这也是个问题，只能将我们想要的值输入或者输出了。

 1-module(analyse_loaded).
 2-export([get_max_count/0]).
 3
 4% code:all_loaded/0本身返回会不完全，这一点我们不处理
 5init() ->
 6	% 拿到所有模块
 7	M = [ Module || {Module, _Location} <- code:all_loaded()],
 8	% 使用apply拿到每个模块导出的函数信息
 9	get_func(M).
10	
11	
12get_func([]) ->
13	[];
14get_func(M) ->
15	[H|T] = M,
16	% 由于module_info格式是固定的，可以这样做不过有点丑
17	[_|Other]= apply(H, module_info,[]),
18	[{exports,Func} | _] = Other,
19	% 这样做会多一个列表符号
20	% Func = [ B || {A,B} <- apply(H, module_info,[]), A =:= exports],
21	[{H,Func}|get_func(T)].
22	
23	
24% 处理数目问题
25get_max_count() ->
26	Number = [size(list_to_tuple(Func)) || {Module, Func} <- init()],
27	lists:max(Number).
28		
29