HelloWorld on cnDenis的笔记

初识Erlang，Hello World（4）

Sun, 24 Mar 2013 00:00:00 +0000

前几节的Hello world都是自言自语，今天试试对着别人说。首先是在本机上各个进程之间，然后是在网络上不同机器之间。

进程间的消息：单向接收

Erlang里可以很方便地创建进程，这种进程是超轻量级的，运行于erlang虚拟机内部的，而与操作系统的进程管理无关的（也就是说你在任务管理器中只会见到一个Erlang进程）， Erlang内的进程创建开销很小，创建一个进程所需的时间仅为微秒级，内存消耗也很少，一台机上运行数以千计的进程也没问题。

进程之间使用消息进行通讯。示例如下：

 hw15srv() ->
 receive
 {name, Name} ->
 io:format("Hello ~p ~n", [Name]),
 hw15srv()
 end.

 hw15() ->
 Pid = spawn(fun hw15srv/0),
 Pid ! {name, "alice"},
 Pid ! {name, "Bob"}.

hw15/0首先是使用spawn命令启动了一个hw15srv/0进程，。这个命令会返回所启动的进程的pid，也就是进程的标识符。然后使用!向它发送消息。

spawn命令有几种用法，对于上例，以下几种方式都可以

 spawn(fun hw15srv/0)
 spawn(fun() -> hw15srv() end)
 spawn(?MODULE, hw15srv, [])

要注意的是，第三种用法（也叫MFA法，即模块、函数、参数法）进行调用的话，这个被调用的函数（即示例中的hw15srv) 必须要export出来，即便是写在同一个文件中。

hw15srv/0的作用是接收其他进程给他发的消息，并显示出来。接收消息使用receive，格式有点象case，先是对收到的消息进行模式匹配，如果匹配的话，该项->后的语句。

发送消息的进程和接收消息的进程需要协调好消息的格式，这段程序中，消息是一个元组，元组的第一个元素是原子name，（一般习惯中erlang中的元组的第一个元素用一个原子作元组的命名），第二个元素是一个字符串。

hw15srv/0用的是所谓尾递归服务器的写法，语句段的最后一行写上递归函数名，象这样的服务器一定要符合尾递归的要求，不然的话运行一段时间服务器就会把内存塞爆。

进程间的消息：相互对话

上一段程序中，hw15srv/0是只收不发的，别人对它说什么，它都没有响应。如果需要有回应的话，可以这么写：

 hw16srv() ->
 receive
 {From, {name, Name}} ->
 io:format("Server receive: ~p ~n", [Name]),
 From ! {self(), {reply, "Welcome, " ++ Name}},
 hw16srv()
 end.

 hw16() ->
 Pid = spawn(fun hw16srv/0),
 Sid = self(),
 Pid ! {Sid, {name, "alice"}},
 receive
 {Pid, {reply, Msg}} ->
 io:format("Client receive: ~p ~n", [Msg])
 end.

用到的关键字和上一段程序是一样的：创建进程spawn，发送消息!，接收消息receive，区别仅在于消息的格式。本段程序在消息的前面加上客户端进程的pid，让服务端进程知道消息是由哪个进程发过来的。Erlang似乎没有获知消息来源的机制，因此需要手工把发送方的pid写到消息中，方便接收方使用。

在hw16/0中，使用了self()来获得本进程的pid，然后本进程pid填到消息中，发给服务端，然后等待服务端发过来的消息，收到后就显示出来。

hw16srv/0中则是接收消息，然后提取对方发过来的名字，在前面加上"welcome"，然后发回给客户端。

进程间的消息：RPC

RPC是远程过程调用的缩写，也就是让另一个地方的程序帮你执行，然后把结果返回给你。 Erlang中的发送请求和等待回应可以封装为一个rpc/2的函数：

 rpc(Pid, Request) ->
 Pid ! {self(), Request},
 receive
 {Pid, Response} ->
 Response
 end.

 hw16b() ->
 Pid = spawn(fun hw16srv/0),
 {reply, Reply} = rpc(Pid, {name, "alice"}),
 io:format("Client receive: ~p ~n", [Reply]).

rpc/2把发送请求和等待回应包装起来，用起来更方便了

进程间的消息：引用

上面的rpc有个两个问题：第一个问题，是当传入的第一个参数不是一个pid，而是一个注册了的进程名，信息虽然也能发出去，返回的信息却是pid而不是注册名，无法匹配 {Pid, Response} ，因而函数会永远等待下去而不返回。第二个问题，如果本线程给远方线程发送了几个请求，对方发回了几个回复，那就搞不清哪个回复是对应哪个请求的了。解决这两个问题的方法是使用一个“引用”，如下：

 rpc2(Pid, Request) ->
 Ref = make_ref(),
 Pid ! { {self(), Ref}, Request},
 receive
 {Ref, Reply} ->
 Reply
 end.

 hw18srv() ->
 receive
 { {From, Ref}, {name, Name}} ->
 io:format("Server receive: ~p ~n", [Name]),
 From ! {Ref, {reply, "Welcome, " ++ Name}},
 hw16srv()
 end.

 hw18() ->
 Pid = spawn(fun hw18srv/0),
 {reply, Reply} = rpc2(Pid, {name, "alice"}),
 io:format("Client receive: ~p ~n", [Reply]).

rpc2/2就用了 make_ref() 来生成一个唯一的“引用”，make_ref/0生成的引用几乎是不会重复的，文档上的说明是要2E82次调用之后才会发生重复，这实际上是不可能的。

（在这里bs一下《Erlang编程指南》这本书的中文翻译，译得像机翻也就算了，错误还不少，像这个82在那本书上就被写成了28，我看书时还在怀疑，现代计算机进行2E28次运算，不就是几秒的事，这make_ref到底行不行。（在211页））

更新(2013年9月13日)

像上面写的那个rpc函数是不带超时选项的, 这在实际代码中有可能会永远都不返回, 程序就卡住了, 要尽量避免这种情况, 可以在后面加上 after 子句, 超时不候.

初识Erlang，Hello World（3）

Fri, 15 Mar 2013 00:00:00 +0000

今天不只要对World说Hello，还要对别人说Hello

 hw(Who) ->
 io:format("Hello ~p ~n", [Who]).

平平无奇的一个函数，对Who说Hello

如果要对一组人说Hello，可以这么做：

 hw10(L) ->
 [hw(X) || X <- L].

 hw10() ->
 L = ["ali", "bob", "cat"],
 hw10(L).

上面是用了列表解析的方法。

也可以用lists:map，效果和上面是一样的

 hw11(L) ->
 lists:map(fun hw/1, L).

 hw11() ->
 L = ["ali", "bob", "cat"],
 hw11(L).

另一个很相似的做法是lists:foreach：

 hw14(L) ->
 lists:foreach(fun hw/1, L).

 hw14() ->
 L = ["ali", "bob", "cat"],
 hw14(L).

这两种做法有什么区别呢？看看输出：

 2> helloworld:hw11().
 Hello "ali"
 Hello "bob"
 Hello "cat"
 [ok,ok,ok]

 10> helloworld:hw14().
 Hello "ali"
 Hello "bob"
 Hello "cat"
 ok

虽然map和foreach都是把同一个函数作用在列表的每一个元素上， map是会生成一个新的列表来存储结果并返回，（由于hw/1的值就是ok，所以会得到包含3个ok的列表）而foreach仅会返回ok。

不使用Lists模块的话，可以这么做：

 hw12([H|T]) ->
 hw(H),
 hw12(T);
 hw12([]) ->
 ok.

 hw12() ->
 L = ["ali", "bob", "cat"],
 hw12(L).

这是Erlang中最常见的Head|Tail写法了吧。

也可以用case改写上面的函数

 hw13(L) ->
 case L of
 [] -> ok;
 [H|T] -> hw(H),
 hw13(T)
 end.

 hw13() ->
 L = ["ali", "bob", "cat"],
 hw13(L).

更新(2013年9月13日)

如果数组很大, lists:foreach/1占用的内存会比lists:map/1少一些, 因为不需要生成一个同样大小的数组进行返回. 因此, 如果不需要返回值的话, 应该用lists:foreach/1, 或者lists:foldl/3, 或是自己写尾递归.

初识Erlang，Hello World (1)

Tue, 12 Mar 2013 00:00:00 +0000

这两天开始玩Erlang，咱们从Hello World开始吧。

先是要到官网http://www.erlang.org/download.html下载安装包，安装上，设置好系 PATH，然后打开命令行，输入erl，如果看到类似于

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

的话，就表示Erlang安装成功。这东西叫做Erlang的Shell。

然后就是最经典的Hello World：

随便用一个文本编辑器输入：

 -module(helloworld).
 -export([hw/0]).

 hw() -> io:format("Hello World! ~n").

保存为helloworld.erl，然后在命令行下进入该文件所在目录，进入Erlang Shell，输入>后的命令：

 1> c(helloworld).
 {ok,helloworld}
 2> helloworld:hw().
 Hello World!
 ok

Yeah，Hello World完成！（我会告诉你我用了20分钟干这事么，下面是各种坑的介绍）

 % 首先，Erlang的注释符是百分号哦
 -module(helloworld).
 % -module是必要的，这可不是Bash或Python，上来就可以Echo或Print
 % 然后，helloworld 必须与文件名相同（除了不用加.erl）
 % 然后，行末的句点是必须的，虽然好不显眼

 -export([hw/0]).
 % -export也是必须的，这是用来说明哪些函数可以在外部被调用
 % 括号中必须是一个列表，换言之，加方括号
 % hw是函数名，斜杠后面是参数的数目，两者总是组合指明一个函数。
 % 参数数目不同的，即使同名，也是两个不同的函数
 % 还是记得句尾要加点

 hw() -> io:format("Hello World! ~n").
 % 这个是函数了
 % 函数名前面不用任何修饰，类似于其他语言中的Fun，def之类在这里是不必要的
 % 函数名是一个“原子”，换言之就是一个以小写字母开头的单词，可后继大小写字母下划线和@号
 % 或是你足够蛋疼的话，可以用单引号括起来的任意东西，比方说 '*&^%hw2'
 % 还有，不要拿fun当函数名，这个词另有用途
 % 函数名后面加括号，如果有参数，写在括号中
 % 括号后是 -> 这不是C语言中的指针，而是表示后面是函数的内容了
 % io:format可以当print，其实就是io模块里的format函数
 % 看清楚模块名和函数名之间是冒号，别弄成其他语言中的点
 % 双引号中是字符串，Erlang中的字符串实质上是数组
 % ~n是换行，用波浪线转义
 % 最后还是别忘记了是句点

这个erl文件的坑说完了，然后是Erlang Shell中的。

想用erl xxxxx.erl来执行是徒劳的，这货不是sh也不是python也不是pl，这么做你会进入Erlang Shell。

然后先是要c(helloworld).编译，记得不要忘记句点。然后同一个目录下就会出现一个同名的beam文件。

然后键入helloworld:hw().，回车没反应？又忘记句点了，补上，Hello World终于蹦出来了。

初识Erlang，Hello World (2)

Tue, 12 Mar 2013 00:00:00 +0000

昨天费了老大劲终于把Hello World打出来了，今天我们继续。

说N遍Hello World，递归的使用

Hello World说一遍怎么够呢，说N遍吧。代码如下：

 -module(helloworld).
 -export([hw3/1]).

 % 打印N遍Hello world
 hw3(N) when N > 0 ->
 io:format("Hello World ~n"),
 hw3(N-1);

 hw3(0) -> ok.

这有什么好坑的呢：

 hw3(N) when N > 0 ->

when后面是一个断言(guard)，仅在它为true时函数会被执行。

断言所能使用的语句是受限的，不能用自定义的函数。

 io:format("Hello World ~n"),
 hw3(N-1);

这一个函数体有多条语句，中间需要用逗号隔开

 hw3(0) -> ok.

hw3/1这个函数有几个函数子句，根据参数的模式识别和when保护元的值来选择使用函数体。

不同的函数体之间使用分号，最后一个末尾使用句点。

啥都不干用什么好呢？stackoverflow 上说用ok. 那就用ok吧。

再说N遍Hello World，使用case

如果不想用多个函数子句的话，可以用case

 hw5(N) ->
 case N of
 X when X > 0 ->
 io:format("Hello World ~n"),
 hw5(N-1);
 0 -> ok
 end.

case的语法是：

 case 条件表达式 of ->
 模式1 -> 语句段1;
 模式2 -> 语句段2;
 ....
 模式N -> 语句段N
 end

继续一行一行看：

 case N of

N是条件表达式，也就是说运行case中的哪一条子句会根据N的值来决定。

只有一个子句会被执行，这点跟C语言不一样。

而且如果全部子句的模式匹配都失败的话，会抛出错误。所以要考虑是否使用catch all的语句。

条件表达式与子句之间是用of来分隔的，注意不要顺手打冒号了。

 X when X > 0 ->

模式后面可以接when，也可以不用。

这一行是这么运行的：首先是对X和N进行模式匹配，即X=N，匹配是成功的，因为变量X没有赋值，所以X绑定到N，然后由于保卫元X>0为true，所以执行该子句。

 io:format("Hello World ~n"),
 hw5(N-1);

注意模式与语句段之间是用 -> 分开的，中间的case语句段需要以分号结束

 0 -> ok

递归结束条件，不可忘记的。最后一个case子句，也就是end之前不需要加标点。

 end.

case语句需要以end结束，后面这个句点是表示hw5整个函数的结束，不是case语法的一部分

继续说Hello World，使用if

if可以视为没有条件表达式和of的case

 hw6(N) ->
 if
 N > 0 ->
 io:format("Hello World ~n"),
 hw5(N-1);
 N == 0 ->
 ok
 end.

if的语法格式是：

 if
 保护元1 -> 语句1;
 保护元2 -> 语句2;
 .......
 保护元N -> 语句N
 end

if会执行第一个断言为真的语句。

要注意的东西跟case没什么区别，就不啰嗦了。

继续Hello World，使用列表解析

这似乎是最简洁的做法了

 hw7(N) ->
 [hw() || _ <- lists:seq(1, N) ].

这句话换相当于Python中的 [hw() for _ in range(1, N + 1)]。

意思是把（1，2，3…N）中的每一个值都装到变量_之后，运行hw()。由于hw中不调用 seq中产生的值，所以拿_这样的一个坑来装。

lists:seq是产生一个连接序列的数组，与Python中的range不同的是，它是既包头又包尾的，也是就说产生（1，2，3…N）。

继续Hello World，山寨for

Erlang最令人觉得奇怪的是它没有循环语句，不过这不妨碍我们直接山寨一个。

 for(I, N, F) when I < N ->
 F(),
 for(I + 1, N, F);
 for(N, N, F) ->
 F().

 hw8(N) ->
 for(1, N, fun hw/0).

 hw9(N) ->
 for(1, N, fun() -> hw() end).

这个山寨的for用了高阶函数的概念，它的F参数是是一个函数。注意hw8/1和hw9/1中的写法，我碰壁了好久，后来问了程序老大才解决的。

hw8/1是把函数名当参数后用，必须要使用fun关键词，而且要指明函数的目数，这与Python不一样。Python一个函数名只能绑定一个函数，给出名字就唯一确定了绑定对象。而Erlang允许同名不同目的函数，所以要指明目数。

hw9/1则是产生一个匿名函数作为参数，注意匿名函数的写法。以fun作为函数名，其余跟一般函数没什么区别。注意fun后面的括号不要漏掉，即使没有参数。

更新(2013年9月13日)

函数匹配是有顺序的, 像这篇最开头的hw/3, 如果把hw3(0)写在前面, 就可以不需要when N > 0了. 但这么做代码并不健壮, 遇上 N<0 就会出死循环. 因此, 还是加上when N > 0吧.