没有关于erlang interface ，继续寻找吧。。。

-----------------------------------------------------------------

http://wgcode.iteye.com/blog/1018614

第二章 入门

1.所有的变量都必须以大写字母开头，如果要查看某个变量，只要输入变量的名字即可，如果一个变量被赋予值，就称为绑定变量，否则被称为自由变量，一开始所有变量都是自由的。 有一点像Java中的常量，这就是为什么用大写字母的原因。

2.  “=” 近似于一个赋值操作符，是一个模式匹配运算符，当X是自由变量未被赋值时“=”是赋值运算符，否则是模式匹配运算符。

3. “/”除号永远返回浮点数。

4. 原子用来表示不同的非数字常量值，是一串以小写字母开头，后跟数字字母 或 下划线 或 邮件符号@的字符，如：red等。

使用单引号引起来的字符也是原子，这种形式，我们就能使用大写字母做为原子，如：‘Monday‘。一个原子的值就是原子自身，如果输入的命令就是一个原子，那么Erlang会打印那个原子的值。

例如：  1> hello.

     hello

5. 若干个以逗号分隔的值用一对花括号括起来，就开成了一个元组，元组没有名字，通常使用一个原子作为元组的第一个元素来标明这个元组所代表的含义如：{point, 20, 45}，元组可以嵌套，元组中的元素可以是另一个元组。提取元组中的值，

Point = {point, 20, 45}, {point , X, Y} = Point ， 可以得出X = 20， Y = 45。

6. ”_“是一个占位符，称为匿名变量，表示那些我们不关心的变量，与常规变量不同的是，在同一个模式中的不同地方，各个_所绑定的值不必相同。

7. 若干个以逗号分隔的值用一对方括号括起来，就形成了一个列表，[point, 72, {jjj, 20, 30}]。列表的第一个元素称为列表头，剩下的元素就称为列表尾，列表的尾通常还是一个列表，访问列表头的操作非常高效，实际上所有的列表处理函数都是从提取列表头开始，往后处理。[H | T]， H是列表头，T是列表尾，还是一个列表。

  用模式匹配方式从一个列表中提取元素，[Buy1 | Thing2ToBuy2] = [{o,4}, {n, 1}, {a, 2}], Buy1 ->  {o,4},

 Thing2ToBuy2 -> [{n, 1}, {a, 2}]。[X]就是[ X | [] ]的缩写

8.字符串是用双引号（”“）将一串字符括起来就是一个字符串，不是使用单引号，单引号是原子，比如：”hello“，Erlang中其实并没有字符串，实际上就是一个整数列表，可以使用$来表示字符的整数值，$a实际上就是一个整数，表示字符a。

9. % 和 %% Erlang注释

10. 在Erlang中，任何可以被求出值的东西都被称作表达式。这意味着catch,if,try...catch等都是表达式，而类型记录和模块属性等，这些不能被求值的都不是表达式。

11. help().查看Erlang编译器的输出功能列表。

第三章 顺序型编程

模块是Erlang的最基本单元，我们编写的所有函数都存在于模块之中，模块文件通常存放在以*.erl的文件中，编译成功后为*.beam，

1. 函数，多个作用的同名函数由多个子句组成，子句间以分号分隔，最后一个以句点结束，每个子句都是一个函数，通过调用参数从上到下进行匹配，如果参数为空列表的，只能匹配空列表函数，有些首参数直接就以原子作为标识。函数调用匹配失败直接抛出一个错误。

2. pwd()可以打印当前的工作目录，cd("c:/work")可以将当前的目录切换到指定的目录

3. 分号小结：

  ”，“ ：用来分隔函数调用、数据构造器以及模式中的参数。

  ”． “  ：后跟一个空白符号，用于分隔完整的函数和表示达。

  ”； “  ：用于分隔子句，几种情况下会用到子句：分段函数的子句，case子句，if子句，try...catch子句，receive子句。

4. fun是一个匿名函数，可以赋给变量，同样支持传递参数，以end作为结尾，fun也可以有若干个不同的子句：

    TT = fun({c, C}) -> {f, 32 + C * 9 / 5};

({f, F})  -> {c, (F - 32) * 5 / 9}

   end.

   fun可以作为函数参数，也可以作为函数的结果，这些 能够返回fun 或 接受fun作为参数的函数，称谓 高阶函数

(1). Even = fun(X) -> ( X rem 2) =:= 0 end. 

  list:map( Even, [1,2,3,4,5,8]).

(2).Mult = fun(Times) -> ( fun(X) -> X * Times end ) end.

TT = Mult(3). 返回TT = fun(x) -> X * 3 end.

TT(5).  输出15

5. List的两个重点函数：

list:map( Even, [1,2,3,4,5,8]).  将Even应用到列表中的每一个元素中，完成后返回一个新的列表保存了每个列 表元素执行Even返回的值。

list:filter(Even, [1,2,3,4,5,8]).  返回一个新的列表，新列表由列表参数中每一个可能满足Event的元素组成。

list:seq(1, N)返回一个由1到N整数组成的列表

6. for循环

for(Max, Max, F) -> [F(Max)];

for(I, Max, F)   -> [F(I) | for（I + 1， Max，F)].

7. sum求和

sum([H | T]) -> H + sum(T);

sum([])     -> 0.

8. map遍历

map(_, [])  -> [];

map(F, [H | T]) -> [F(H) | map(F, T)].

9. -import(lists, [map/2, sum/1]) 引用其它模块的函数，这样就减少模块引用名如：list:map, 引用后直接用map

    -export([total/1])  输出函数，让其它模块可以调用当前函数

10. 列表解析  [ F(X) || X <- L ] 代表由F(X)组成的列表，其中X是取值于列表L。如：[ 2 * X || X <- L ].意味着列表L中 的每一个元素X乘以2后的列表。

[ {Name, 2 * Number} || {Name, Number} <- Buy], 记号（||）右边的元组{Name，Number}是用于匹配 列表Buy中的每个元素，左边的元组{Name，2 * Number}则是一个构造器。

11. [1,2,3] ++ [4] ++ [5,6] -> [1,2,3,4,5,6]. "++"是一个中缀添加操作符, ++ 和 --是对列表进行添加和删除的中缀 操作符，两边操作的均为列表，

用于模式匹配时，f("begin" ++ T) -> ...., 被扩展为[$b, $e, $g, $i, $n | T].

12. X rem Y ,X除Y取余数，6 rem 2 =:= 0

13. When  

max(X, Y) when X > Y -> X; When和判断条件是为函数头

max(X, Y)   -> Y.

max(X, Y) when is_integer(X), X > Y, Y < 6 -> X. When的多条件判断，用逗号隔开，表示逻辑与&&操作

max(X, Y) when X =:= dog; X =:=cat -> X. When的多条件判断，用分号隔开，表示逻辑或||操作

14.   and(&)【逻辑与】,

andalso(&&) 与  

or(|)    【逻辑或】 ,

orelse(||),

not B1  【逻辑非】，

B1 xor B2【逻辑异或】

15. case表达式

filter(P, [H | T]) ->

case P(H) of

true -> true;

false-> false;

filter(P, [H | T]) ->

case P(H) of

1-> true;

0-> false;

16. if表达式

if

X > Y -> X;

X < Y -> Y;

end.

17. 记录 记录就是元组，只是元组的伪装，

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

创建或更新：X1 = #todo{}. 或者 X1 = #todo{status=urgent, text="test"}.

提取：   #todo{who = W, text = Txt} = X1. 模式匹配可取得 W  和 Txt

释放：   rf(todo).

第四章 异常

1. demo1() -> [ catcher(I) || I <- [1,2,3,4,5]].

catcher(N) ->

try generate_exception(N) of

0 -> false;

1 -> true;

catch

throw:X -> {N, caught, thrown, X};

exit  :X -> {N, caught, exited,   X};

error :X -> {N, caught, error,    X}

end.

after

io:format("after").

end.

2. erlang:error的另一个用处是提高错误信息的质量，抛出一个自定义错误，等于Java的throws

3.捕获所有异常：

try generate_exception(N)

catch

_:_ -> {erlang:get_stackstrace()}

end.

第五章 顺序型编程进阶

1. BIF 内建函数，是Erlang内建的函数，启动Erlang时自动导入的函数，通常用来完成那些无法用Erlang完成的任务。如：tuple_to_list/1能将元组转换为列表， time/0返回当前时间的时、分、秒。

2. 二进制binary，以一个整数或者字符序列的形式出现，用<<>>括起来，如：<<5,10,20>>. 和 <<"hello">>.

对于字符串来说，如果其二进制数据是可打印的字符串，那么在显示 时，会将其显示为字符串的形式，否则 ，就会显示成一串整数。<<"cat">>等同于<<99,97.116>>.

3. 操作二进制数据的BIF：@spec类型文档标记

@spec list_ to_binary(IoList)  ->  binary()     将列表中的所有数据转换成二进制 数据 。

@spec split_binary(Bin, Pos)  ->   {Bin1, Bin2}.  在Pos指定的位置将二进制数据Bin分割为两个部分。

@spec term_to_binary(Term) ->  Bin.       可以将任何Erlang值转化为二进制 数据 。

@spec binary_to_term(Bin)    ->  Term.     这个是term_to_binary的逆函数

4. Byte比特语法，是模式匹配的一种扩展，Erlang的看家本领。M = <<X:3, Y:7, Z:6>>.表示X占3Bit， Y占7Bit， Z占6Bit。

操作：Red=2. Green = 61. Blue = 20. Mem = <<Red:5, Green:6, Blue:5>>. 输入<<23,180>>. 

Red占5位， Green占6位， Blue占5位，其它Red和Green、Blue分别也代表某数据

提取：<<R1:5, G1:6, B1:5>> = Mem.  可得出R1为2， G1为61， B1为20

    比特语法的表达式：无论采用哪个形式，总比特数必须恰好能被8整除，因为二进制数据每个字节都是8Bit

Ei =  Value |

Value：Size |

Value / TypeSpecifierList |

Value：Size / TypeSpecifierList

    TypeSpecifierList 列表项有以下值 @type End = big(默认) | little | native(运行时决定的字节序)

5. BIF的apply(Mod, Func, [Arg1, Arg2,......, ArgN]) 将Mod模块中的Func函数应用到参数Arg1， Arg2. . . ArgN上 去。等同于Mod：Func(Arg1, Arg2, ... , ArgN). 尽量少用。

6. - module(modname).   预定义模块属性，必须放在所有函数之前，模块名称必须是一个原子。

    - import (Mod, [Func1/1, Func2/2,......]). 从Mod模块中导入指定参数和函数名的函数。

    - export ([Func/1, Func2/2,......]). 从当前模块中导出Func指定函数，只有被导出的函数才能在模块外部调用。

    - compile(Options). 向编译器选项列表中添加Options，Options是一个编译器选项或者一个编译器选项列表。

    - vsn(Version).  指定一个模块的版本。

    - sometag(Value). 用户自定义属性，sometag必须为一个原子，Value必须是一个文字项，可在运行时提取

    - include(FileName). 包含文件如：-include("jj/file.hrl").

7. Mod：module_info() 可打印输出当前模块的信息。

8. 块表达式, 可以把一串表达式组织成一个类似子句的实体，当某处只允许使用单个表达式而实际需要使用多个表达式时， 可以使用块表达式。

begin

expr1,

expr2,

.......

end

9. Erlang没有独立的布尔类型，原子true 和 false取而代之被赋予了特殊的布尔语义，作为符号使用

10. epp, 在Erlang模块被编译之前，会被epp的预处理器进行自动处理，并且插入任何必须的包含文件，保存预处理器的 输出，用命令compile:file(M, [‘P‘])，编译M.erl文件的所有代码，在M.P中产生一个列表，存放包含文件。

11.转义字符：同Java一样

io:format("~w~n", ["\b\n"]). ~w的意思是对一个列表不做任何修饰处理，直接打印原始结果，无转义。~p是完 整打印的缩写。

12. 宏定义

-undef(Macro) 取消此宏定义，这个语句后不能再调用这个宏。

-ifdef  (Macro) 只有Macro被定义后，才对该行以下的代码进行运算。

-ifndef(Macro) 只有Macro未定义后，才对该行以下的代码进行运算。

-else . 只能在ifdef或ifndef之后出现，如果条件为false， 就会执行该语句后的代码

-endif. 标记ifdef 和 ifndef语句的结束。

例如：

-export([start/0)].

-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).

13.在模式中使用匹配操作符

func1([{tag1, A, B} = Z] | T) ->

........

f(..., Z, ...). Z在函数中重复使用，可以把{tag1, A, B}模式写成一个Z，再重复使用

14.数值类型

K进制整数：不以10进制的整数可以用语法K#Digits来表示，如：16#af6bfa23, 这种语法所能表示的最高进制为 36进制。

$语法      ：语法$表示ASCII字符的整数值，如：$a是97.

15.进程字典

Erlang的每个进程都有自己的私有数据存储，叫做进程字典，是一系列的键值对应的关联数组，一个键对应一个值

@spec put(Key, Value) -> OldValue. 返回值为前一个关联值，如果之前没有则返回undefined.

@spec get(Key)     -> Value. 查找Key对应的值，没有时返回undefined.

@spec get()     -> [{Key, Value}].以{Key，Value}元组列表的形式返回整个字典。

@spec get_keys(Value)->[Key]. 返回字典中值为Value的键的列表。

@spec erase(Key)     -> Value. 存在Key对应的值，返回再删除Key的值，否则返回undefined.

@spec arase()     -> [{Key, Value}]. 返回全部列表元组{Key，Value}，同时删除全部列表。

16.引用 erlang:make_ref()用于创建引用。

17.比较表达式 

/=      不等于

=:=  全等于

=/=  不全等于

=<  小于等于

>=  大于等于

_VarName 以下划线开始的变量，编译器不会产生警告信息。open(_Mode)比open(_)更具有可读性。

第八章 并发编程

1. 创建新的并发进程：Pid  =  spawn(Fun)  如：Pid = spawn(fun area_server0:loop/0). 函数内有表达式 receive，当向这个进程发送数据时，执行当前的注册函数，并找到receive进行处理。

    向进程发送消息   ：Pid ！Message  ， Pid1 ！ Pid2 ！Pid3 ！M，把消息M发送到Pid1 和 Pid2 和 Pid3各个进 程，“！”是一个发送符号，表示把右边的数据发送到左边的Pid去。

    接收一个发给当前进程的消息：

(1)receive

pattern1 [when Guard1] -> expressions1;

pattern2 [when Guard2] -> expressions2;

.......

end.

(2)receive   带超时的

pattern1 [when Guard1] -> expressions1;

pattern2 [when Guard2] -> expressions2;

.......

    after Time ->

Expressions

end.

(3)sleep(T)  -> 带延时的

receive

pattern1 [when Guard1] -> expressions1;

pattern2 [when Guard2] -> expressions2;

.......

after T -> true

end.

(4)receive  一个越时时间为0的语句会立即触发一个超时。只有在所有消息都进行过匹配之后才会检查after段是否 需要进行运算。

pattern1 [when Guard1] -> expressions1;

pattern2 [when Guard2] -> expressions2;

.......

after 0 ->

receive

Any ->

Any

end

end.

（5）无限等待超时进行接收，人为控制超时

如果receive的超时值被设定为原子,那么系统永远都不会触发超时，

（6）可以使用接收超时来实现一个简单的计时器, 在指定Time时间后对Fun进行求值

receive   带超时的

pattern1 [when Guard1] -> expressions1;

pattern2 [when Guard2] -> expressions2;

.......

     after Time ->

Fun()

end.

（7）选择性接收

Erlang的每一个进程都有与之对应的邮箱，当向进程改送消息时，消息就被送入邮箱之中，当系统对receive 语句进行求值时，就是对进程邮箱进行检查的唯一机会。

receive 

pattern1 [when Guard1] -> expressions1;

pattern2 [when Guard2] -> expressions2;

.......

     after Time ->

ExpressionTimeOut

end.

2. Send 和 receive的工作原理：

Erlang的每一个进程都有与之对应的邮箱，当向进程改送消息时，消息就被送入邮箱之中，当系统对receive 语句进行求值时，就是对进程邮箱进行检查的唯一机会。

(1). 当进入一个receive语句时，我们启动一个计时器（只有在表达式中存在after段时才会计时)。

(2). 从邮箱中取出第一个消息，然后尝试对Pattern1、Pattern2等进行模式匹配。如果匹配成功，消息就从邮箱中 删除，对应的模式之后的表达式就会被求值。

(3). 如果邮箱中的第一个消息不能匹配receive语句的任何一个模式，那么就会将第一个消息从邮箱中删除并送往一 个“保存队列”，然后继续尝试邮箱中的第二个消息。这个过程会不断重复直到找到匹配的消息，或者邮箱中所 有的消息全都检查完毕。

(4). 如果邮箱中的所有的消息都不能匹配，那么就挂起进程，直到下一次又有新的消息进入邮箱时再对该进程进行重 新调度执行。注意，当一个新消息到达时，只对新消息进行匹配而不会对保存队列中的消息进行再次匹配。

(5).  一个消息如果被匹配，那么存入保存队列中的所有消息就会按照它们到达进程的时间先后顺序重新放回到邮箱 中。这时，如果开启了一个计时器，那么这个计时器就会被清空。

(6). 如果在我们等待一个消息时触发了计时器，那么对表达式ExpressionsTimeOut求值然后把存入保存队列中的 所有消息按照它们到达进程的时间先后顺序重新放回到邮箱中。

3.  self(). 返回当前进程的Pid.

4. erlang:system_info(process_limit) 用来查找系统允许的进程数上限，要修改Erlang虚拟机的进程数必须在启动Erlang虚拟机时带参数+P， 如：erl +P 500000， 程序内控制processes:max(20000).  但不能超出虚拟机的最大数。

5. 注册进程，Erlang中有4个BIF用于管理注册进程。

register( AnAtom, Pid ) 将一个进程Pid注册一个名为AnAtom的原子

unregister( AnAtom ) 移除与AnAtom相对应进程的所有注册信息。

whereis( AnAtom ) -> Pid【存在时】 | undefined【不存在时】

registered()       -> [ AnAtom :: atom() ] 返回一个系统中所有已经注册的名称列表。

1>Pid  =  spawn(fun area_server0:loop/0).

2>register(area, Pid).

3>area ! { rectangle, 4, 5 }.

6. 尾递归技术 在receive里面不断调用当前的函数，这个过程叫做尾递归

7. 使用MFA启动进程

我们想要编写那些可以运行时更新的代码，如果想要确保代码可以被很好地进行动态更新，那么就必须使用不同形式的spawn, spawn(Mod, FuncName, Args). MFA分别代表三个参数，Args是一个参数列表，可以进行热更新。

第九章 并发编译错误处理

1.当一个进程退出时想执行某些动作。可以编写一个函数如：on_exit(Pid, Fun), 它会创建一个指向Pid进程的链接。如果Pid由于消亡（其原因在变量Why中），那么这个函数就会执行函数Fun（Why）。这样可以在一个与当前进程无关的进程中进行这些处理，这些进程甚至不需要在同一台机器上，分布式的Erlang会用到。

on_exit(Pid, Fun) -> 

spawn(fun() ->

process_flag(trap_exit, true), 把创建的进程变为一个系统进程

link(Pid), 把新建的进程与Pid进程相链接（监视）

receive 当Pid消亡时，收到信号，执行处理

{‘EXIT‘, Pid, Why} -> Fun(Why）

end

end).

link：是一种在两个进程之间的传播路径，如果两个进程被链接在一起，若其中一个进程消亡，那么系统就会向另一 个进程改送一个退出信号，一群与某个给定的进程进行链接的进程集合称为该进程的链接集。

exit signal：当一个进程消亡时，它会产生一个叫做退出信号的东西，系统会向这个濒死进程的链接集的所有进程发 送退出信号。

system process：当进程接收到一个非正常的退出信号时它自己也会消亡，除非它是特殊类型的进程即系统进程。 我们可以用BIF process_flag(trap_exit, true)来把一个普通进程转换为一个可以捕获退出信号的系统进程。

2. 捕获退出的编程模式

(1). 不管创建的进程是否崩溃   Pid  =  spawn（fun()  ->  ...  end).

(2). 新创建的进程崩溃我也跟着自行消亡  Pid  =  spawn_link(fun()  ->  ...  end).  并行进程

(3). 新创建的进程崩溃我需要处理错误。  这种情况就要使用spawn_link 和 trap_exits

process_flag(trap_exit, true).

Pid = spawn_link(fun() -> ... end),

......

loop(...).

loop(State) -> 

receive

{‘EXIT‘, SomePid, Reason} ->

%% do something with the error

end

3. 错误处理原语

@spec spawn_link(Fun) -> Pid 是一个原子操作，它除了创建进程外，还会在这两个进程之间创建链接。

@spec process_flag(trap_exit, true)   这个把当前进程转换为系统进程，系统进程可以接收和处理退出信号。

@spec link(Pid)  ->  true 如果Pid所指定的进程还没有链接，那么给这个进程创建一个链接，链接是双向的，如 果一个进程A运行了Link(B), 那么它自身也会被链接到B，等同于B运行了A。

@spec unlink(Pid)  ->  true   这会移除当前进程和Pid所指进程间的链接

@spec exit(Why)   ->  none() 这会导致当前进程终止，并把终止原因设为Why，向链接集中广播。

4. 存活进程  消亡的时候，立刻重启

keep_alive(Name, Fun) -> 

register(Name, Pid = spawn(Fun)),

on_exit(Pid, fun(_Why) -> keep_alive(Name, Fun) end).

第十章 分布式编程

1. 在终端上启动一个名为TT的Erlang节点，在这个节点上启动服务：erl -sname TT  , 节点显示为：TT@ZT-PC。

2. rpc:call ( Node, Mod, Func, [ Arg1, Arg2, ... , ArgN ] ) ， 在Node上执行一个远程调用，被调用的函数是

Mod：Func（Arg1, Arg2, ... , ArgN ).

3. 运行于不同节点的客户端和服务器架构

在bilbo节点上

erl -sname bilbo.

rpc:call ( gandalf@localhost, kvs, store, [weather, fine] ).

在gandalf节点上

kvs.lookup ( weather ) .  输入 {ok, fine}

4. 运行于同一局域网内的不同机器上, 确保再点之间使用相同的Cookie

在gandalf 上启动一个Erlang节点，以提供其它服务器调用

erl -name gandalf -setcookie abc

标记符号变为：(gandalf@doris. myerl. example. com) 

在bilbo上启动一个Erlang节点并向gandalf发送一些命令

erl -name bilbo -setcookie abc

(bilbo@george. myerl. example. com) 1>

rpc:call ( gandalf@doris.myerl.example.com, kvs, store,[weather, cold]). 

返回true.

5. 分布式的原语

@spec spawn ( Node, Fun ) -> Pid 这个原语和spawn(Fun)没有多大的区别，但新创建的进程位于Node节 点上。

@spec spawn ( Node, Mod, Func, ArgList) -> Pid  新创建的节点MFA进程位于Node节点上。

@spec spawn_link ( Node, Fun ) -> Pid     和spawn_link(Fun)没大区别，新创建的进程会Node节点上。

@spec spawn_link ( Node, Mod, Func, ArgList ) -> Pid  和spawn(Node, Mod, Func, ArgList)没多大的 区别，只是新创建的进程与当前进程互相链接。

@spec disconnect_node(Node) -> bool() | ignored 强制断开一个节点的链接。

@spec monitor_node(Node, Flag) -> true Flag为true就会打开监视，Flag为false就会关闭监视。

@spec node() -> Node  返回本地节点的名称。

@spec node(Arg) -> Node  这个原语会返回Arg所指定的节点，Arg可以是Pid、一个引用 或者一个端口，本地节点不是分布式返回nonode@nonode

@spec nodes()   -> [Node]  返回网络上与当前节点连接的所有其它节点列表。

@spec is_alive()  -> bool() 本地节点状态正常而且是分布式的系统，则返回true.

6. 分布式库

rpc模块提供了一系列远程调用服务。

global模块提供了名称注册函数和分布式系统中的锁定功能，完整的网络连接维护函数。

7. cookie设置

(1). 把cookie存放在$HOME/.erlang.cookie文件中。这个文件包含了一个随机的字符串，在你每一次运行该机器 Erlang时自动生成的。

(2).  启动时设置Cookie， erl -setcookie ASDFSDFSADFASDFSREWRWER....

(3).   使用BIF erlang:set_cookie(node(), C)把本地节点的cookie设置为原子C .

第十二章 接口技术

1. 创建端口：Port = open_port ( PortName, PortSettings) // 多种参数方式

    发送数据：Port ！{PidC， {command, Data}}

    接收数据：receive  {Port, {data, Data}} -> ...... Data comes from the external process .... 

    关闭端口：Port ！{PidC， close}

第十三章   文件编程

1. Erlang把操作文件的函数编排在4个不同的模块中

(1). file。 这个模块包含了用于文件打开、关闭、读取、写入和目录列表等功能的函数。

(2). filename：一套操作文件名的函数。

(3). filelib：file模块的扩展，提供了一套辅助函数用于生成文件列表、检验文件类型等操作。

(4). io：提供了一系列对已打开的文件进行操作的函数。

2.读取文件

(1). file:consult ( "data1.dat" ).  全部读取,读取成功返回{ok, [Term]}, 否则，就会返回{error, Reason}。

(2). 顺序一次读一项

{ok, S} = file:open ( "data1.dat", read ).

io:read(S, ‘‘ ). 读出一项,结束时返回eof

file:close(S).

(3). 从文件中一次读取一行数据

{ok, S} = file:open ( "data1.dat", read ).

io:get_line(S, ‘‘). 结束时返回eof。

file:close(S).

(4). 将整个文件读入到一个二进制数据中

file:read_file ( "data1.dat" ).   

把新的数据存回到文件中去file:write_file ().

成功返回{ok, Bin}， 失败返回{error, Why}.

(5). 随机读取一个文件

{ok , S} = file:open("data1.dat", [read, binary, raw]).

file:pread(S, 22, 46). 从22个字节开始，读取长度为46字节的数据

file:pread(S, 1, 10).

file:close(S).

3. 写入文件的方法

(1). 向一个文件中写入一串Erlang数据项  @spec io:format(IoDevice, Format, Args) -> ok.

{ok, S} = file:open(File, write),

lists:foreach ( fun(X) -> io:format(S, "~p.~n", [X]) end, L ) ,

file:close(S).

(2). 向文件中写入一行

{ok, S} = file:open("test2.dat", write).

io:format(S, "~s~n", ["Hello readers"]).

file:close(S).

(3). 一步写入整个文件

writefiles(File, Data) ->  file:write_file(File, Data).

(4). 在随机访问模式下写入文件

{ok, S} = file:open("...", [raw, write, binary]).

file:pwrite(S, 10, <<"new">>).

file:close(S).

4.目录操作

(1). list_dir(Dir) 用于生成Dir目录下的文件列表。

(2). make_dir(Dir) 用来创建一个新的目录

(3). del_dir(Dir) 用来删除目录。

5. 查询文件属性 file:read_file_info(F). F是一个合法的文件名或者目录名，那么这个函数会返回{ok, Info},Info是一个 类型为#file_info的记录。

6.复制和删除文件

file:copy(Source, Des) 将源文件Source复制到目标文件Des

file:delete(File).     删除文件

第十四章 Socket编程

1. 打开：{ok, Socket} = gen_tcp:connect ( Address, Port, Options ), 或 gen_tcp:listen ( Port, Options ) Options是模式 如：[ binary, {packet, 0} ], 以binary的模式打开，打开二进制传输格式。

    发送： ok = gen_tcp:send ( Socket , "asdfasdfasdf"), receive_data(Socket, []).  把消息发送到Socket上， 然后等待回应，回应消息通常 不会在一个数据包内全部返回，而是会一帧一帧地返回，每帧一部分数 据。程序以顺序型消息的方式收到这些数据帧并把它转发给打开Socket的进程。

    回应： {tcp, Socket, Bin} 第三个参数为二进制类型，这是我们为何以二进制模型打开套接字的原因所在，这个消息 只是Web服务器发送过来的数据帧之一，程序会把它添加到一个列表中，然后继续接收下一帧。

    关闭：{tcp_closed, Socket}, 这表明Web服务器已经停止向程序发送数据

nano_get_url() ->

{ok, Socket}  =  gen_tcp:connect ( "www.google.com", 80, [binary, {packet, 0}]),

ok = gen_tcp:send ( Socket, "sdfsdfsdf"),

receive_data ( Socket, [] ).

receive_data ( Socket, SoFar ) ->

receive

{tcp, Socket, Bin } -> 

receive_data( Socket, [Bin | SoFar] );

{tcp_closed, Socket} ->

list_to_binary ( reverse(SoFar))

end.

2. 一个二进制数据如果太长会被截断，可以使用io:format  或   string:tokens  来将它们切成小的片段

3. 一个完整的TCP服务器

start_nano_server()  ->

{ok, Listen} = gen_tcp:accept(2345，

[binary, {packet, 4}, {reuseaddr, true}, {active, true}]).

{ok, Socket} = gen_tcp:accept(Listen),

gen_tcp:close(Listen),

loop(Socket).

loop(Socket) ->

receive

{tcp, Socket, Bin} ->

str = binary_to_temp(Bin),

gen_tcp:send(Socket, term_to_binary ( str )),

loop(Socket);

{tcp_closed, Socket} ->

io:format ( "Server socket closed~n" )

end.

4. 顺序型服务器

start_seq_server() ->

{ok, Listen} = gen_tcp:listen( ... ),

seq_loop(Listen).

seq_loop(Listen) ->

{ok, Socket} = gen_tcp:accept ( Listen ),

loop ( Socket ),

seq_loop(Listen).

loop(...) -> %% as before

5.并发服务器  当接收到一个新的连接的时候启动一个新进程处理。

start_parallel_server() ->

{ok, Listen} = gen_tcp:listen( ... ),

spawn ( fun() -> par_connect(Listen) end ).

par_connect(Listen) ->

{ok, Socket} = gen_tcp:accept(Listen),

spawn( fun() -> par_connect(Listen) end).

loop(Socket).

loop(...) -> %% as before

6.Erlang的套接字打开模式

(1). acitve 主动型消息接收(非阻塞)  {active, true}

(2). active once 被动型消息接收(阻塞) {active, false}

(3). passive 混合型消息接收(半阻塞) {active, once}, 需要调用inet:setopts重新激活下一个消息。

7. Socket的错误处理 

每个Socket都有一个控制进程，如果控制进程消亡，那么Socket会自动关闭。

8.UDP的服务器和客户机

server(Port) ->

{ok, Socket}  ->  gen_udp:open(Port, [ binary ] ),

loop(Socket).

loop(Socket)  ->

receive

{udp, Socket, Host, Port, Bin} -> 

BinReply = ... ,

gen_udp:send( Socket, Host, Port, BinReply ),

loop(Socket)

end.

client(Request) ->

{ok, Socket} = gen_udp:open(0, [binary]),

ok = gen_udp:send(Socket, "localhost", 4000, Request),

Value = http://www.mamicode.com/receive

{udp, Socket, _, _, Bin } ->  {ok, Bin}

     after 2000 ->  error

     end.

gen_udp:close(Socket),

Value

UDP的协议传输是不可靠的，有可能会收不到来自服务器的回应。

9. 一个Udp的数据报可能被传输再次，加其加入一个唯一的引用，然后在服务器返回时去校验这个引用。Erlang的BIF  make_ref可以保证引用的唯一性，这个保证会返回全球唯一的引用。

client(Request) ->

{ok, Scoket} = gen_udp:open(0, [binary] ),

Ref  = make_ref(),

B1   = term_to_binary({Ref, Request}),

ok   = gen_udp:send(Socket, "localhost", 4000, B1),

wait_for_ref(Socket, Ref).

wait_for_ref(Socket, Ref) ->

receive

{udp, Socket, _, _, Bin} ->

case binary_to_term(Bin) of

{Ref, Val} -> Val;

{_SomeOtherRef, _} -> wait_for_ref(Socket, Ref)

end;

after 1000 -> .......

end.

10. 向多台机器广播消息

send(IoList) ->

case inet:ifget("eth0", [broadaddr]) of

{ok, [{broadaddr, Ip}]} ->

{ok, S} = gen_udp:open(5010, [{broadcast, true}]),

gen_udp:send(S, Ip, 6000, IoList),

gen_udp:close(S);

_ ->

io:format("Bad interface name, or\nbroadcasting not supported\n")

end.

listen() ->

{ok, S} = gen_udp:open(6000),

loop(S).

loop(S) ->

receive

Any ->

io:format("receive:~p~n", [Any]),

loop(S)

end.

第十五章 ETS 和 DETS 大量数据的存储机制

ETS 和 DETS是Erlang用于高效存储大量Erlang数据条目的系统模块，ETS是Erlang Term Storage 的缩写，而

DETS是Disk Ets的缩写，它们提供大型的“键 - 值” 搜索表，ETS所不同的是留在内存，DETS驻留在磁盘上。

1. 创建：ets : new(name, [Opt]).  name是一个原子， Opts是表的类型

    插入：insert(Tablename, X)  X可以是一个元组或者元组的列表。在ETS和DETS中，insert的参数和行为都一样

    查找：lookup(Tablename, Key), 其返回的结果是匹配Key的元组列表。返回元组是因为可以有多个元组使用相同的 键，如果没有匹配，则返回一个空列表。

    释放：用完一个表，可以调用dets：close(TableId) 或 ets:delete（TableId）来告诉系统释放这个表。

2.表的类型，总共有4种：set 、ordered set、bag、duplicate bag 和 private 、public 、protected、 named_table、{keypos, K}

set： 表中每一个元组的键值都不能相同。

ordered set：   在Set的基础上，元组会进行排序。

bag： 多个元组可以用相同的键值，但不能有两个完全相同的元组。

duplicate bag：不仅多个元组可以有相同的键值，同一个元组也可以在表中出现多次。

3. ETS小程序

start() ->

lists:foreach( fun test_ets/1, [set, ordered_set, bag, duplicate_bag]).

test_ets(Mode) ->

TableId = ets:new(test, [Mode]),

ets:insert(TableId, {a, 1}),

List = ets:tab2list(TableId),

io:format("~-13W => ~p~n", [Mode, List]),

ets:delete(TableId).

第十六章 OTP概述 【框架】 —Erlang的进化

OTP即Open Telecom Platform 电信开放平台， 它是一个应用程序操作系统，包括了大量库和程序用来构建大规模的分布式容错系统。OTP的设计目标是用来构造容错系统。

OTP最核心的概念是行为，一个行为封装某种常见的行为模式，这些行为可以理解为某种应用程序框架，可以通过回调模块来定制这些框架。

首先来仔细研究行为中的一种—gen_server。

（1）用Erlang写一个小的客户/服务器程序。

（2）慢慢抽离这个程序的通用部分，并增加一些特性。

erlang note