1、退出,输入 haut().
2、-module
3、module_name:function_name( arguments )
例如调用tut:double(10),说明调用tut模块的double函数。
4、模块名为tut
-module(tut).
-export( [double/1, fact/1] ).
double(X)->
2 * X.
fact(1) ->
1;
fact(N) ->
N*fact(N-1).
分号表示函数还未结束。
点号表示函数已经结束。
变量必须以大写字母开头，小写开头的为字符串。
5、元组
可以返回多个值
-module(tut).
-export( [double/1] ).
double(X) ->
{X*2, X*3, X*4}.
6、
列表赋值
10> [One,Two|Rest]=[1,2,3,4,5,6].
[1,2,3,4,5,6]
11> One.
1
12> Two.
2
13> Rest.
[3,4,5,6]
14>
获取列表的长度
-module(tut).
-export( [get_length/1] ).
get_length([] ) ->
0;
get_length([First|Rest]) ->
1+get_length(Rest).
字符串输出采用ASCII表示
>[97,98,99].
"abc"
7、百分号表示注释
8、格式化输出
标准函数io:format
io:format("my name is ~w, my age is ~w~n", [biao, 20]).
9、/返回浮点数
div 整数除 rem 求余
10、'a' 等同于 a
11、元组嵌套赋值
1>F = {first, guo}.
{first,guo}
2> L = {last, biao}.
{last,biao}
3> Name = {person, F, L }.
{person,{first,guo},{last,biao}}
12、元组元素提取,采用占位符(下划线)
6> Name.
{person,{first,guo},{last,biao}}
7> {_,{_,N1},{_,N2}} = Name.
{person,{first,guo},{last,biao}}
8> N1.
guo
9> N2.
biao
10>
13、获取列表的元素值 [H|T]
10> ThingstoBuy=[{apple, 5}, {pear,10}, {orange, 20} ].
[{apple,5},{pear,10},{orange,20}]
11> [Buy1|Others] = ThingstoBuy.
[{apple,5},{pear,10},{orange,20}]
12> Buy1.
{apple,5}
13> Others.
[{pear,10},{orange,20}]
14、字符串=整数列表
Hello = "hello"
整数列表中，所有的整数都是可打印字符时，才转为字符串。
15> [1,2,3].
[1,2,3]
17> [97,98,99].
"abc"
使用$来表示一个字符的ASCII值（Latin-1)
18> [$s-32, $i, $r].
"Sir"
又例如
23> [H|T]="cat".
"cat"
24> H.
99
25> T.
"at"
18、释放所有的变量绑定。f().
19、Erlang提供的命令。
pwd()打印当前路径，
切换当前目录到C盘根目录
1> cd("e:/erlang_src").
<input type="button" e:/erlang_src
ok
20、fun定义匿名函数，并可以赋给一个变量。类似函数指针。
14> Double = fun(X)->2*X end.
#Fun<erl_eval.6.80247286>
15> Double(2).
4>
21、把fun作为参数传入
例如标准库中的lists:map(F,L).
把F应用到列表的每个元素，并返回新列表。
17> lists:map(Double, [1,2,3,4]).
[2,4,6,8]
标准库lists:filter(P, L ).
把列表的每个元素作为P的参数，返回为TRUE的，才被放到结果列表中。
小例子：查找奇数列表中的奇数。
是否等于的测试符号：" =:= "
25> Even = fun(X) -> X rem 2 /= 0 end.
#Fun<erl_eval.6.80247286>
26> Even(2).
false
27> lists:filter(Even,[1,2,3,4,5,6,7,8,9]).
[1,3,5,7,9]
22、比较操作符
全等于 =:= 例如 1=:=1.0 false
等于 == 例如 1==1.0 true
不等于 /=
23、返回fun的函数。
28> Fruits=[apple,orange,pear].
[apple,orange,pear]
29> Test=fun(L)->( fun(X) -> lists:member(X,L) end) end.
#Fun<erl_eval.6.80247286>
31> Isfruits = Test( Fruits ).
#Fun<erl_eval.6.80247286>
32> Isfruits( apple ).
true
23、for循环,Erlang中无循环控制，需要自定义的控制结构
-module(for).
-export([for/3]).
for(MAX,MAX,F) -> [F(MAX)];
for(I,MAX,F) -> [F(I) | for(I+1,MAX,F)].
39> c(for).
{ok,for}
40> for:for(1,10,fun(I)->I*2 end).
[2,4,6,8,10,12,14,16,18,20]
在模块中，
如果使用-import(for, [for/3] ) 在使用for函数时，就不需要指定模块名。
24、列表解析
L=[1,2,3,4,5,6].
[1,2,3,4,5,6]
42> [2*X || X <- L].
[2,4,6,8,10,12]
43>
例如
[2*X || X <- L]
由F(X)组成的列表，其中X是L的每个元素。
又例如
49> L=[{orange, 8}, {apple, 5}, {pear, 10} ].
[{orange,8},{apple,5},{pear,10}]
50> [{Name, Number*2} || {Name,Number} <- L].
[{orange,16},{apple,10},{pear,20}]
注意{Name,Number}用于和L中的元素进行匹配。
25、过滤器
51> [X || {a, X} <- [{a,1}, {b,2}, {a,3}] ].
[1,3]
过滤出为a的值。
过滤出奇数的另外一种实现。
53> L = [1,2,3,4,5,6,7,8,9].
[1,2,3,4,5,6,7,8,9]
54> [X || X <- L, X rem 2 /= 0].
[1,3,5,7,9]
55>
[X || QUALIFIER1,QUARLIFIER2...].
QUALIFIER1...如果是 X <- L形式则为生成器。
如果是布尔表达式则为过滤器。
26、快速排序算法
-module(qsort).
-export([qsort/1]).
qsort([]) -> [];
qsort([Head|L] ) ->
qsort([X || X <- L, X < Head])
++ [Head] ++
qsort([X || X <- L, X >= Head] ).
27、lists:seq(1,N) 返回1-N的整数列表。毕达哥拉斯三元组。
28、断言。可以用于简单的变量测试和比较。断言语句使用when关键字开头。
-module(maths).
-export([max/2]).
max(X, Y) when X > Y -> X;
max(X, Y) -> Y.
29、断言谓词。
is_atom(X)
is_integer(X)
is_list(X)
is_function(X,N)
is_tuple(X) 是否元组
is_record(X,Tag,N)
30、断言内建函数（BIF)
abs(X)
element(N,X) 元组X的第N个元素
hd(X) 列表X的头部
tl(X) 列表X的尾部,除第一个元素以外的剩余元素。
length(X) 列表的长度
node() 当前节点 node(X) 创建节点
round(X) 四舍五入为整数
self() 当前进程的进程标示符
size(X) 元组的大小
例如：
67> L=[1,2,3,4,5,6,7].
[1,2,3,4,5,6,7]
68> hd(L).
1
69> tl(L).
[2,3,4,5,6,7]
31、用分号分隔的断言表示 or
用逗号分隔的断言表示 and
assert(X,Y) when is_integer(X), X>5, X>Y -> [X,Y]; % and 操作
assert(X,Y) -> [Y,X].
32、andalso，orelse用于构建稍微复杂一些的断言。
33、记录的定义保存在.hrl文件中，这样可以被多个module共享，以保证是同一份定义。
在命令行中使用记录之前，先要读取记录hrl文件，命令为 rr("xxx.hrl").
34、record定义，表名字为todo，字段有status，who，memo
-record( todo, {status=ok, who = biao, memo=test}). -->保存在record.hrl中.
插入三条记录
76> X1=#todo{status=bad,who=zb,memo=test2}.
#todo{status = bad,who = zb,memo = test2}
77> X2=#todo{}.
#todo{status = ok,who = biao,memo = test}
78> X3=X2#todo{who=biaobiao}. %复制一条记录，然后修改who的值
#todo{status = ok,who = biaobiao,memo = test}
rf(todo).
去掉记录的定义，然后打印X2，会发现其实是元组。
35、提出RECORD记录值。
第一种方法。#todo{who=W, memo=M, status=S} = X3.
第二种方法。X3#todo.W X3#toto.M
36、case..of..end分支
例子：自定义filter
filter(P, [H|T]) ->
case P(H) of
true -> [H|filter(P, T)];
false->filter(P,T)
end;
filter(P,[]) -> [].
13> IsBig = fun(X) -> X > 10 end.
#Fun<erl_eval.6.80247286>
14> maths:filter(IsBig, [1,3,4,11,20]).
[11,20]
37、条件分支if..end
iftest(X) ->
if
X == 1 ->
"return 1";
X == 2 ->
"return 2";
true ->
"return other"
end.
38、try .of. catch.. after..end 为 case的增强版，带有异常捕捉功能。
三种类型的异常exit/throw/error
异常捕捉例子：
-module(try_test).
-export([demo1/0,generate_exception/1,catcher/1]).
generate_exception(1) -> a;
generate_exception(2) -> throw(a);
generate_exception(3) -> exit(a);
generate_exception(4) -> {'EXIT', a};
generate_exception(5) -> erlang:error(a).
demo1() ->
[catcher(I) || I <- [1,2,3,4,5]].
catcher(N) ->
try generate_exception(N) of
Val -> { N, normal, Val} %%如果没有异常，这个generate_exception(N)的值就和VAL进行匹配。
catch
throw:X -> {N, caught, throw, X };
exit:X -> {N, caught, exit, X };
error:X -> { N, caught, error, X }
after
io:format("test").
end.
运行结果：
6> try_test:demo1().
[{1,normal,a},
{2,caught,throw,a},
{3,caught,exit,a},
{4,normal,{'EXIT',a}},
{5,caught,error,a}]
39、erlang:error提高错误信息的质量。
sqrt(X) when X < 0 ->
erlang:error( { sqrtNagativeArgumentError, X } );
sqrt(X) ->
math:sqrt(X).
运行后，有如下提示:
7> maths:sqrt(-1).
** exception error: {sqrtNagativeArgumentError,-1}
in function maths:sqrt/1
40、函数返回值，
{ok, Val} 或者 {error, Why} 调用者模式匹配后进行处理。
例如：
41、erlang中的小于等于：" =< ", 大于等于: ">="
例如：
%%输出不同的结果
getValue(X) when X >= 1, X =< 100
-> {ok, 'less than 100'};
getValue(X)
-> {error, 'larger than 100' }.
%%调用getValue对结果输出
deal(X) ->
case getValue(X) of
{ok, Info } ->
io:format("ok print info: ~w~n", [Info]);
{error, Info} ->
io:format("error print info: ~w~n", [Info])
end.
42、捕获任何异常的写法 ( _:_ )。
try expr of
模式匹配 -> ...
catch
_:- -> 异常处理
end.
43、使用 erlang:get_stacktrace() 打印函数调用的栈信息。
demo2() ->
try generate_exception(2)
catch
throw:X ->
{X, erlang:get_stacktrace()}
end.
44、BIF并非erlang编写，而是虚拟机上的基本操作，包含在erlang模块中，
并自动导入,所以使用时不需要用前缀,例如 erlang:tuple_to_list/1
cat 和 'cat' 是一样的，为一个常量。
元组转化为列表
3> tuple_to_list({1, "cat", "hello"}).
[1,"cat","hello"]
获取当前时间
4> time().
{11,11,2}
45、二进制数据中的整数，必须是0-255.
超出255，会从0开始，例如256输出会变成0， 257变成1.
erlang的函数注释：@spec func( arg1, arg2 ...) -> val
46、列表转成二进制数据。
@spec list_to_binary( L ) -> binary().
11> list_to_binary([1,2,3]).
<<1,2,3>>
12> list_to_binary([<<1,2,3>>, 1,2,3,<<4,5,6>>]).
<<1,2,3,1,2,3,4,5,6>>
13>
47、列表分割
@spec split_binary(BIN, POS) -> {BIN1,BIN2}
13> split_binary(<<1,2,3,4,5,6>>, 3).
{<<1,2,3>>,<<4,5,6>>}
48、@spec term_to_binary(BIN) -> Term
把任何erlang值转成二进制，把格式也存入二进制中，用于文件传输和网络传输，
可以还原的。
17> term_to_binary({"cat", "abc"}).
<<131,104,2,107,0,3,99,97,116,107,0,3,97,98,99>>
18> binary_to_term(<<131,104,2,107,0,3,99,97,116,107,0,3,97,98,99>>).
{"cat","abc"}
49、二进制的字节长度
@spec size(BIN) -> Int
19> size(<<1,2,3,4,5,6>>).
6
50、比特语法
例子，用16位存储RGB
用16位存储，Red和Blue为5为，Green 6位
20> Red = 10.
10
21> Green = 20.
20
22> Blue = 30.
30
23> Color = <<Red:5, Green:6, Blue:5>>.
<<82,158>>
采用模式匹配提出值
24> <<R:5, G:6, B:5>> = Color.
<<82,158>>
25> R.
10
26> G.
20
27> B.
30
28>
51、比特语法表达式中的元素，有一项指明计算机系统的字节序。
big/little/native. 默认为big，运行时根据CPU来确定字节序则选native
在不同机器之间进行整数、二进制之间的解包和封包，需要使用正确的字节序。
例如<<123456:32/big, 45678:16/little>>
52、全局宏定义，使用问号获取。
-define(BUFFER, 2048).
getDefine() ->
?BUFFER * 2.
测试结果:
38> maths:getDefine().
4096
53、apply可以动态调用BIF，例如apply(erlang, atom_to_list, [hello]).
模块属性
-import( lists, [map/2] ).
引入lists:map/2, 在模块中调用就不需要指明前缀lists
-export([getDefine/2]).
只有导出函数，在模块外部才能被访问到。
-compile(export_all).
如果要把模块中的函数全部导出，可以使用-compile来代替-export.
-vsn(1.0).
表示模块的版本。
54、自定义的模块属性。
例如-author( biao ).
使用maths:module_info().可以输出所有这些信息项。
50> maths:module_info(attributes).
[{vsn,[1.0]}]
51> beam_lib:chunks("maths", [attributes]). %使用系统模块来获取。
{ok,{maths,[{attributes,[{vsn,[1.0]}]}]}}
从以上结果抽取对应的值。
beam_lib:chunks用来提取模块的属性，然后用以下函数可以提出属性值。
-module(extract).
-export([extract/2]).
extract(File, Key) ->
case beam_lib:chunks(File, [attributes]) of
{ok, {File,[{attributes,L}]}} ->
case lookup( Key, L ) of
{ok, Val} -> Val;
error -> exit(notFound)
end;
_ ->
exit( badFile )
end.
lookup(Key, [{Key,Val}|_]) -> {ok,Val};
lookup(Key, [_|T]) -> lookup(Key, T);
lookup(Key, [] ) -> error.
输出：
53> extract:extract(maths, vsn).
[1.0]
55、块表达式。
begin
expr1,
expr2
end.
返回的是最后一条expr的值。
56、布尔表达式
63> not true.
false
64> true and false.
false
65> true or false.
true
66> (2>1) or (3>4).
true
erlang的预处理器是epp
57、转义符
\b 退格
\d 删除
\s 空格 \t tab \n 换行 \r回车
\^X 代表 CTRL+X ,X为A-Z或a-z
\'单引号 \" 双引号 \\反斜杠 \C字母的ascii值。
\NNN \NN \N 表示八进制数。
58、函数引用，使用fun funcname/argnum
-module(funRef).
-export([double/1,double2/1]).
square(X) -> X*X.
double(L)->lists:map(fun square/1, L). %引用本地
double2(L) -> lists:map( fun maths:sqrt/1, L ). %引用其他模块
59、包含文件，把文件引入当前模块，例如hrl文件
-include( File ).
-include_lib("kernel/include/file.hrl"). 包含lib下最新kernel下的file.hrl.
60、中缀操作符++ --
72> [1,2,3]++[4,5,6].
[1,2,3,4,5,6]
73> [1,2,3,3,3,4,5,3]--[3,3].
[1,2,3,4,5,3]
74> [1,2,3,4,3,3]--[3,3,3,3].
[1,2,4]
61、宏定义
-define( BUFFER, 2048).
-define( Test(A, B), {A,B,A,B}).
预定义宏。
print()->
io:format("~p,~p,~p~n", [?FILE,?MODULE,?LINE]).
87> funRef:print().
"./funRef.erl",funRef,7
宏的流程控制，编译开关。
-module(macro).
-export([start/0,loop/1]).
-ifdef(debug).
-define(TRACE(X), io:format("Trace ~p~p:~p~n", [?MODULE,?LINE,X])).
-else.
-define(TRACE(X), void).
-endif.
start() -> loop(5).
loop(0) -> void;
loop(N) ->
?TRACE(N),
loop(N-1).
编译运行：
107> c(macro,{d, debug}). %%引入debug定义
{ok,macro}
108> macro:start().
Trace macro14:5
Trace macro14:4
Trace macro14:3
Trace macro14:2
Trace macro14:1
void
62、在模式中使用匹配操作符。
test({name,Name}=Z|T) ->
f(Z)...
63、K进制整数的表示方法。
15#11.
15进制，其值为16.
$a,$\^c,表示ascii值。
64、进程字典，由一系列的键值对组成。
3> get().
[]
4> put(x,20). %把x的值设置为20，并把原来的值返回。
undefined
5> put(x,30).
20
6> get(x).
30
7> put(y,40).
undefined
8> get(). %返回所有的进程字典
[{y,40},{x,30}]
9> erase(x). %删除字典x
30
10> get().
[{y,40}]
11> erase().
[{y,40}]
尽量少用进程字典，一般用于只读的一些参数设置。一次性写入的变量。
65、erlang:make_ref().创建一个唯一标签。
全局唯一。匹配时使用的。
13> Data = make_ref().
#Ref<0.0.0.64>
14> Data.
#Ref<0.0.0.64>
66、短路布尔表达式。andalso orelse 而 （and，or两个都要求值）。
比较表达式：
X =< Y 小于等于
X /= Y 不等于 仅适用于整数和浮点数的比较。
X =:= Y 全等于 适用于所有的比较。和C++中的==一样。
X =/= Y 不全等于 适用于所有的比较。和C++中的==一样。
X == Y 等于 仅适用于整数和浮点数的比较。
67、下划线变量。
只使用一次的变量，例如open(File,_Mode) 等价于 open(File, _)
退出shell 输入q().等同于init:stop().
68、加载路径：
code:add_patha(Dir).加到开头。
code:add_pathz(Dir).加到结尾。
code:all_loaded(). 已加载的路径。
code:get_path().查找路径设定值。
code:clash().检查加载错误。
命令行增加加载路径:erl -pa Dir1 -pa Dir2 ....
获取erlang所需的home目录 init:get_argument(home).
69、命令行脚本。
erl -noshell -s hello start -s init stop.
用非交互式方式，调用hello:start()，然后调用init:stop().
命令行中执行任意一个函数
erl -eval 'io:format("test").' -noshell -s init stop.
70、一个相关的makefile
.SUFFIXES: .erl .beam
.erl .beam:
erlc -W $<
ERL= erl -boot start_clean
MODS = module1 module2 module3
all: compile
${ERL} -pa './dir' -s module1 start
compile:${MODS:%=%.beam}
clean:
rm -rf *.beam erl_crash.dump
erlang虚拟机的错误信息。
webtool:start().可以看到地址。
1> webtool:start().
WebTool is available at http://localhost:8888/
Or http://127.0.0.1:8888/
{ok,<0.34.0>}
71、ERLANG中进程和操作系统是不同的，ERLANG中的进程是程序语言，并不属于操作系统。
每个进程都是独立运行的ERLANG虚拟机。
Pid = spawn(Fun).产生一个新进程对Fun求值。
Pid ! M 把消息M发送给Pid进程，返回M.
Pid1 ！ Pid2 ！ Pid3 ！ M..群发消息。
receive ... Other .. end. 接受消息。
72、创建一个求面积的服务进程。
-module(area).
-export([loop/0,rpc/2]).
%%客户端
rpc(Pid, Request) ->
Pid ! {self(), Request },
receive
{Pid, Response} ->
io:format("get response: ~p~n", [Response]);
_Other ->
_Other
end.
%%服务端
loop() ->
receive
{From, {rectangle, W, H}} ->
From ! {self(), W * H},
loop();
{From, {circle, R} } ->
From ! {self(), 3.14*R*R},
loop();
{From, _Other} ->
From ! {self(),"i don't know~~"},
loop()
end.
运行情况：
14> Pid = spawn(fun area:loop/0).
<0.62.0>
16> area:rpc(Pid, {rectangle, 4, 5}).
get response: 20
ok
17> area:rpc(Pid, {circle, 3}).
get response: 28.259999999999998
ok
注意：Pid ! M 本身是会返回消息M,所以在输出中也会体现。
self()表示当前进程的进程号
73、erlang允许的最大进程数。
18> erlang:system_info(process_limit).
32768
要增加这个上限，再启动时使用+P参数
C:\Documents and Settings\Administrator>erl +P 50000
2> erlang:system_info(process_limit).
50000
74、计算创建进程消耗的CPU时间和实际时间。
-module(elapse).
-compile(export_all).
compute(N) ->
Max = erlang:system_info( process_limit ),
io:format("max process limit is: ~p~n", [Max] ),
statistics(runtime), %%开始统计CPU消耗时间
statistics(wall_clock), %%开始统计实际消耗时间
L = for( 1, N, fun() -> spawn( fun() -> wait() end ) end ), %%启动N个进程。
io:format("in"),
{_,Time1} = statistics( runtime ), %%统计时间
{_,Time2} = statistics( wall_clock ), %%统计时间
lists:foreach( fun( Pid ) -> Pid ! die end, L ),
U1 = Time1 * 1000/N,
U2 = Time2 * 1000/N,
io:format("elapse ~p(um) CPU Time and ~p(um) Wall Time.", [U1, U2] ).
wait() ->
receive
die -> void
end.
for( N, N, F ) -> [F()];
for( I, N, F ) -> [F() | for(I+1,N,F)]. %%注意这里的for，不要写成F
75、receive 进程等待的超时时间设置。
-module(wait).
-compile( export_all ).
waiting( Time ) ->
receive
Time when Time > 100 ->
'time is larger than 100';
_ ->
'other time'
after Time ->
'no request...'
end.
等待Time毫秒后，如果没有接收到合适的请求，则执行after后面的语句。
after后面的箭头，极易遗漏！
76、只有超时的receive语句
例如让当前的进程停止T ms
-module(sleep).
-export([sleep/1]).
sleep(T) ->
receive
after
T -> void
end.
77、永远等待 infinity
sleep()->
receive
after
infinity ->
void
end.
78、注册进程：发布一个进程标示符，以便其他进程与之通信。
register(AnAtom, Pid ).
unregister(AnAtom).
whereis(AnAtom) -> Pid | undefined 判断原子AnAtom是否已被注册。
registered() -> [] 返回系统中所有已注册的名称列表。
例如：
6> Pid = spawn(fun area:loop/0).
<0.42.0>
7> register( area, Pid).
可以看做是别名，进程退出时，自动取消注册。
79、spawn( Fun) 创建一个进程、执行Fun对应的函数。
-module(clock).
-compile(export_all).
start(Time, Fun) ->
register( clock, spawn( fun() -> tick( Time, Fun) end ) ). %%创建一个进程，并给出别名，然后进程执行tick函数。
stop() ->
clock ! stop.
tick( Time, Fun ) ->
receive
stop -> void
after
Time -> %% 不断地等待，超时后打印一条记录，又接着回调tick
Fun(),
tick(Time, Fun)
end.
执行结果如下：
27>
clock:start(1000, fun()->io:format("test") end ).
true
28> test28> test28> test28> test28> test28> test28> test28
28> test28> test28> test28>
clock:stop().
teststop
80、使用MFA创建进程。
spawn( Mod, Function, Args ).
link(Pid) 把当前进程和Pid进程链接。
unlink(Pid) 取消链接
exit(Why) 退出，并广播这个Why原因内容。
exit(Pid, Why) 向Pid发送退出信号。
erlang:monitor(process, Pid) 建立一个监视器。监视器是单向的，而链接是双向。
BIF函数：process_flag( trap_exit, true).把当前进程变成系统进程。
系统进程可以捕获别的进程的退出状态。
81、
进程正常结束，发出normal信号，他的进程集合屏蔽这种信号。
进程非正常结束，他的进程集中的非系统进程都会退出，系统进程才能处理这种信号。
进程收到kill信号，不管是否是系统进程，全部退出，并且广播。
82、三种进程模式
Pid = spawn( fun() -> ... end ). 被创建的进程消亡，当前进程毫无察觉。
Pid = spawn_link( fun() -> ... end ).被创建的进程非正常消亡，当前进程也会退出。
被创建的进程退出，当前进程做错误处理。
process_flag(trap_exit, true), %先变成系统进程。
PID = spawn_link( fun() -> .. end ),
loop().
loop( State) ->
receive
{'EXIT', Pid, Reason } ->
...
loop( State1 );
...
end.
83、存活进程例子
-module(onexit).
-compile( export_all).
keep_alive( Name, Fun )-> %创建一个进程注册为Name，然后执行Fun函数。
register( Name, Pid = spawn( Fun) ),
on_exit( Pid, fun(_Why) -> keep_alive(Name, Fun) end ).
% 把当前进程和Pid链接，然后进程异常退出时，捕获并调用Fun函数处理。
on_exit(Pid, Fun) ->
process_flag( trap_exit, true),
link( Pid ),
receive
{ 'EXIT', Pid, Why } -> Fun(Why)
end.
84、创建一个名字服务。
-module(kvs).
-compile(export_all).
%启动：创建一个服务进程，循环等待处理，并给予别名kvs
start() ->
register(kvs, spawn( fun() -> loop() end )).
%向服务端发起变更请求，并接收结果
store(Key, Value) ->
kvs ! {self(), {store, Key, Value}},
receive
{kvs, Reply} -> Reply
end.
%向服务器发起查询请求，并接收结果
lookup(Key) ->
kvs ! {self(), {lookup, Key}},
receive
{kvs, Reply} -> Reply
end.
%接收客户端请求，并把结果发给客户端
loop()->
receive
{From, {store, Key,Value} } ->
put( Key, Value ),
From ! {kvs, true},
loop();
{From, {lookup, Key} } ->
From ! {kvs, get(Key) },
loop()
end.
运行结果：
18> kvs:start().
true
19> kvs:store(money, 100).
true
20> kvs:store(name, biao).
true
21> kvs:lookup(name).
biao
22> kvs:lookup(money).
100
85、启动节点时，给予名字。同一台机器。
erl -sname Name
C:\Documents and Settings\Administrator>erl -sname biao1
Eshell V5.8.4 (abort with ^G)
(biao1@biao)1> cd ("e:/erlang_src").
e:/erlang_src
ok
在第一个节点上运行服务
(biao1@biao)2> kvs:start().
true
在第二个节点上，远程发送消息来调用
(biao2@biao)3> rpc:call(biao1@biao, kvs, store, [sex, male]).
true
(biao2@biao)4> rpc:call(biao1@biao, kvs, lookup, [name]).
biao
86、在局域网内的不同机器之间。
erl -name biao1 -setcookie abc
运行在两个不同的网络上，需要用全名。需要DNS服务。
两个节点之间需要使用相同的cookie。
在/etc/hosts可以添加域名入口，内容格式为 网络IP地址 主机名或者域名 [主机名别名]。
erl -sname biao1
表示短名，在同一台机器或者在局域网内，直接用短名即可。
87、判断节点（NODE)之间是否连通。
net_adm:ping(Node).
设置erlang节点的cookie
erlang:set_cookie(node(), abc).
spawn( Node, Fun ) -> Pid
spawn( Node, Mod, Func, Arg ) -> Pid
spawn_link( Node, Fun ) -> Pid
spawn_link( Node, Mod, Func, Arg) -> Pid.
node()->Node. 返回本地节点的名字。
nodes() ->Node[] 返回与当前节点连接的所有节点。
monitor_node(Node, Flag ) 当前进程监视Node，如果Flag为true则打开，Flag为false则关闭。
当前进程会收到信号{nodeup, Node}, {nodedown, Node }
is_alive() -> bool() 本地节点状态是否正常。
{RegName,Node} ! Msg 向节点Node的RegName进程发消息。
88、在因特网上两个节点通信
A、确保4396端口是通的，Erlang的epmd会使用这个端口。
B、ERLANG端口使用。启动时erl -name .. -setcookie .. -kernel inet_dist_listen_min Min inet_dist_listen_max Max.
C、节点之间必须拥有相同的cookie，具有相同cookie的相连接的节点群称为ERLANG集群。
89、apply(M,F,A),这个可以实现，模块函数的配置化。
rpc:call(Node, Mod, Function, Args) -> Result | {badrpc, Reason}
erl -setcookie ABCEDEF
90、lib_chan模块，用来控制能够启动哪些进程。这个应该是第三方的包。
start_server()->true 启动一个服务。
start_server( Conf) -> 按照配置启动一个服务。
配置文件内容是一系列的元组，
{port, NNN } 服务器的监听端口为NNN
{service, S,password, P, mfa, SomeMod,SomeFunc,SomeArgs}
定义由密码P保护的服务S,如果服务启动，则由SomeMod:SomeFunc(MM,ArgsC,SomeArgs}创建的进程会出处理来自客户端的消息。
MM: 代理进程Pid，用于向客户端发消息
ArgC:来自客户机的调用参数。
connect(Host, port, S, P, ArgC) -> {ok, Pid} | {error, Why}
91、Socket套接字
-module(socket_test).
-compile(export_all).
get_url() ->
get_url( "www.google.com" ).
get_url( Host ) ->
%% 调用connect连接Host:80,产生一个套接字，
%% 采用二级制传输，{packet, 0}意味着原封不动地返回TCP数据。
{ok, Socket} = gen_tcp:connect( Host, 80, [binary, {packet, 0}] ),
%% 把消息发送到套接字
gen_tcp:send( Socket, "Get/HTTP/1.0\r\n\r\n"),
%% 进程接收套接字返回的消息
receive_data( Socket, [] ).
receive_data( Socket, Result ) ->
receive
%% 每次收到的Bin消息都放到列表的头部
{tcp, Socket, Bin } ->
receive_data( Socket, [Bin|Result] );
%%接收完毕，把数据反转并转化为二级制数据
{tcp_closed, Socket } ->
list_to_binary( lists:reverse(Result) )
end.
运行情况：
8> socket_test:get_url().
<<"HTTP/1.0 405 Method Not Allowed\r\nContent-Type: text/html; charset=UTF-8\r\n
Content-Length: 11815\r\nDate: Fri, 19 Aug 20"...>>
9>
92、创建一个监听8888端口的服务
服务端
-module(compute_server).
-compile(export_all).
start_server() ->
%% 监听8888端口，并返回一个监听套接字Listen
%% 字节流中的头部是4个字节
{ok,Listen} = gen_tcp:listen(8888, [binary, {packet, 4}, {reuseaddr, true}, {active, true}]),
%%开始监听8888端口，等待连接
%%有新连接进来，产生一个新的连接套接字Socket
{ok, Socket} = gen_tcp:accept(Listen),
%%连接成功后，关掉监听器,新建的Socket不会受到影响。
gen_tcp:close( Listen ),
loop( Socket ).
loop( Socket ) ->
receive
{tcp, Socket, Bin } ->
io:format("receive binary: ~p~n", [Bin]),
Str = binary_to_term( Bin ),
io:format("receive value: ~p~n", [Str]),
Reply = Str,
io:format("server reply: ~p~n", [Reply]),
gen_tcp:send(Socket, term_to_binary(Reply) ),
loop( Socket );
{tcp_closed, Socket } ->
io:format("server socket closed.~n")
end.
客户端：
-module(compute_client).
-compile(export_all).
send( Str ) ->
{ok, Socket} = gen_tcp:connect("localhost", 8888, [binary, {packet, 4}]),
ok = gen_tcp:send(Socket, term_to_binary( Str) ),
receive
{tcp, Socket, Bin } ->
io:format("client receive binary: ~p~n", [Bin] ),
Val = binary_to_term( Bin ),
io:format("client receive value: ~p~n", [Val] ),
gen_tcp:close( Socket )
end.
运行情况
客户端
2> compute_client:send("abc").
client receive binary: <<131,107,0,3,97,98,99>>
client receive value: "abc"
ok
服务端
7> compute_server:start_server().
receive binary: <<131,107,0,3,97,98,99>>
receive value: "abc"
server reply: "abc"
server socket closed.
ok
93、主动套接字
创建时设置{active, true}
数据到达时，系统向控制进程发送{ tcp, Socket, Data }
控制进程无法控制流量。
用于异步服务器，客户端不会被阻塞。
94、被动套接字
{actvie, false}
gen_tcp:recv(Socket, N) 接收来自套接字的数据。N为接收的字节数，如果N=0，则接收所有的
调用recv时，客户端会被阻塞。
只能等待一个套接字的消息。
95、混合型Socket
{active, once }
主动接收一条消息，然后系统处于阻塞状态，
必须调用inet:setopts(Socket, [{active, once}] )
96、inet:peername(Socket) ->{ok, {Ip, Port}} | {error, Why} 查看连接的来源。
97、ets 表类型
set 键不能相同。
order set 排序的set
bag 可以有相同的键，但不能有两个相同的元组。
duplicate bag 可以有相同的键值，也可以有两个相同的元组。
98、set ordered_set,bag,duplicat_bag 操作
-module(ets_test).
-export([start/0]).
start() ->
%%注意第一个参数为 fun test/1，即调用test函数
lists:foreach( fun test/1, [set, ordered_set, bag, duplicate_bag]).
test( Mode ) ->
%%创建一个tab表，返回表ID
TabID = ets:new( tab, [Mode] ),
ets:insert(TabID, {a, 1}),
ets:insert(TabID, {b, 2}),
ets:insert(TabID, {a, 1}),
ets:insert(TabID, {a, 3}),
ets:insert(TabID, {a, 2}),
%% 把表数据转成列表。
List = ets:tab2list(TabID),
%% 13位宽度显示。
io:format("~13w => ~p~n", [Mode, List]),
%%删除表，释放空间
ets:delete( TabID ).
运行：
4> ets_test:start().
set => [{b,2},{a,2}]
ordered_set => [{a,2},{b,2}]
bag => [{b,2},{a,1},{a,3},{a,2}]
duplicate_bag => [{b,2},{a,1},{a,1},{a,3},{a,2}]
ok
99、@spec ets:new(Name, [Opt]) -> TabID
Name 一个原子
Opt取值有
1) set | ordered_set | bag | duplicate_bag
2) private 私有表，只有所有者进程才能读写。
3) public 公开表
4) protected 只有所有者进程能写，其余知道表名字的进程可以读。
5) named_table 命名表，后续可以使用Name来操作这个表
6) {keypos,1} 设置键的位置。在record中使用。
ets:new的默认设置为
[set,protected, {keypos, 1}]
100、把服务器的公共部分、不怎么变化的部分放在一个文件中，
然后把变化的部分(业务逻辑）放在另外一个文件中，
通过回调实现解耦。
服务端例子：
-module(server1).
-export([start/2,rpc/2]).
%% 创建一个进程，并且进程注册名是Name，传入一个Mod模块名。
start(Name, Mod ) ->
register( Name, spawn( fun() -> loop(Name, Mod, Mod:init() ) end ) ).
%% 进程Name, 循环接收消息，并调用Mod:handle(..,State)
loop( Name, Mod, State ) ->
receive
{ From, Request } ->
{Response, State1} = Mod:handle(Request, State),
From ! {Name, Response},
loop( Name, Mod, State1)
end.
%% 客户端向Name进程发送Request消息
rpc( Name, Request ) ->
Name ! {self(), Request},
receive
{Name, Response} -> Response
end.
被回调的Mod模块
-module(name_server).
-compile(export_all).
-import(server1, [rpc/2]).
%%被服务器回调的程序代码,可以把服务器代码当做一个模板
init() -> dict:new().
handle( { add, Name, Place }, Dict ) ->
{ok, dict:store( Name, Place,Dict) };
handle( { whereis, Name }, Dict ) ->
{dict:find(Name, Dict), Dict}.
被回调的部分可以看做是接口。
运行情况如下：
10> server1:start(myserver, name_server).
true
11> server1:rpc(myserver, {add, biao, 'at home'}).
ok
12> server1:rpc(myserver, {whereis, biao}).
{ok,'at home'}
101、支持事务的服务端程序
在handle处理异常时，给客户端发退出指令。
-module(server2).
-compile(export_all).
%% 创建一个进程，并且进程注册名是Name，传入一个Mod模块名。
start( Name, Mod ) ->
register( Name, spawn( fun() -> loop(Name, Mod, Mod:init())end )).
%% 进程Name, 循环接收消息，并调用Mod:handle(..,State)
loop( Name, Mod, OldState ) ->
receive
{From, Request } ->
try Mod:handle( Request, OldState ) of
{Response, NewState} ->
From ! {Name, ok, Response },
loop( Name, Mod, NewState )
catch
_:Why ->
io:format("Server ~p request ~p~n"
"caused exception ~p~n",
[Name, Request, Why] ),
From ! {Name, crash },
loop( Name, Mod, OldState )
end
end.
%% 客户端向Name进程发送Request消息
rpc( Name, Request ) ->
Name ! {self(), Request},
receive
{Name, crash} -> exit( rpc );
{Name, ok, Response} -> Response
end.
102、一个空服务器，然后根据传入的指令进行操作。
服务端
-module(server5).
-compile(export_all).
start() ->
spawn( fun() -> wait() end ).
wait() ->
receive
{become, F} -> F()
end.
rpc( Pid, Q) ->
Pid ! { self(), Q },
receive
{Pid, Reply} -> Reply
end.
具体的服务操作，把功能部分解耦出来。
-module(fac_server5).
-compile(export_all).
loop() ->
receive
{From, {fac, N} } ->
From ! {self(), fac(N)},
loop();
{become, Something} ->
Something()
end.
fac(0) -> 1;
fac(N) -> N * fac(N-1).
运行情况：
2> Pid = server5:start().
<0.33.0>
3> Pid ! {become, fun fac_server5:loop/0 }.
{become,#Fun<fac_server5.loop.0>}
4> server5:rpc(Pid, {fac, 3}).
6
5> server5:rpc(Pid, {fac, 5}).
120
103、服务器模板gen_server.
需要在开头使用 -behaviour( gen_server).
回调函数有：
init/1 初始化，返回一个状态，作为handle_call的输入
handle_call/3 回调主体，模式匹配。
handle_cast/2
handle_info/2
terminate/2
code_change/3
写个服务器程序，需要以下三步：
1、确定回调模块的名称。这里为my_bank.
2、接口说明
start() 打开银行
stop() 关闭银行
new_account(Who) 开户
deposit(Who, Amount) 存钱
withdraw(Who,Amount) 取钱
3、编写回调函数
init([]) -> {ok, State } %这里的State生成后，将传给后面的函数使用，是一个全局的对象
handle_call(_Request, _From, State) -> {reply, Reply, State}
handle_cast(_Msg, State) -> {noreply, State }
handle_info(_Info, State) -> {noreply, State}
terminate(_Reason, _State) -> ok
code_change(_OldVsn, State, Extra ) -> {ok, State }
例子：
%%第一步，确定回调模块名称
-module(my_bank).
%-behaviour(gen_server).
-compile(export_all).
%%第二步，接口实现
%% start_link启动一个本地的服务器{local,Name},第二个参数为回调模块。.
%% 首先会调用MOD:init/1
start() -> gen_server:start_link({local, ?MODULE}, ?MODULE, [], [] ).
%% gen_server:call(?MODULE,Term) 发起对Name服务器的远程调用。
stop() -> gen_server:call(?MODULE, stop ).
new_account(Who) -> gen_server:call(?MODULE,{new,Who}).
deposit(Who, Amount) -> gen_server:call(?MODULE, {add, Who, Amount}).
withdraw(Who,Amount) -> gen_server:call(?MODULE,{remove, Who, Amount}).
%%第三步 回调函数实现
%%6个回调函数
init([]) ->
{ok, ets:new(?MODULE, [set]) }.
%银行开户
handle_call({new, Who}, _From, Tab) ->
Reply = case ets:lookup(Tab, Who) of
[] -> ets:insert(Tab, {Who, 0}),
{ welcome, Who };
[_] -> {Who, you_already_in_bank}
end,
{reply, Reply, Tab};
%银行存钱
handle_call({add, Who, X}, _From, Tab) ->
Reply = case ets:lookup( Tab, Who ) of
[] -> you_are_not_in_bank;
[{Who, Balance}]->
NewBalance = Balance + X,
ets:insert(Tab, {Who, NewBalance}),
{thanks, Who, your_balance_now_is, NewBalance}
end,
{reply, Reply, Tab};
%银行取钱
handle_call( {remove, Who, X}, _From, Tab ) ->
Reply = case ets:lookup( Tab, Who) of
[] -> you_are_not_in_bank;
[{Who, Balance}] when X =< Balance ->
NewBalance = Balance - X,
ets:insert(Tab, {Who, NewBalance} ),
{thanks, Who, your_balance_now_is, NewBalance};
[{Who, _Balance}] ->
{sorry, you_havnot_enough_money}
end,
{reply, Reply, Tab };
%终止服务器程序的方法 handle_call(Stop, From, State) -> {stop,Reason,Reply,Tab}
handle_call(stop, _From, Tab ) ->
{stop, normal, stopped, Tab }.
handle_cast(_Msg, State) -> {noreply, State }.
handle_info(_Info, State) -> {noreply, State }.
terminate(_Reason, _State) -> ok.
code_change(_OldVsn, State, _Extra) -> {ok, State }.
104、gen_server:start_link(Name,Mod,InitArgs,Opts)
创建Name服务，调用Mod:init(InitArgs)启动服务。
105、gen_server:call(Name,Request).调用服务器程序，发起Request请求，会回调handle_call
106、gen_server:cast(Name,Name) 回调 hanle_cast(_Msg,State)
handle_cast(_Msg,State) -> {noreply, NewState}
106、handle_info() 用来处理服务器收到的原生消息，例如收到其他进程的{'EXIT',PID,WHAT}.
handle_info(_Info,State) -> {noreply,State}.
107、在handle_XXX()函数返回{stop, Reason, State}
或者直接终结服务器返回{'EXIT', reason},这些会回调terminate(Reason,NewState).