erlang程序设计--顺序编程

erlang模块的基本结构

基本结构
-module(filename).
-export([funname/num]).

c(filename). 编译erlang模块  .bean 结尾的文件 编译后的文件

q()  quit的别名 受控的方式停止了系统  init:stop()的别名   会提前关闭所有的资源.

elang:halt(). 立即停止系统

% 后面的内容是注释

多进制表示整数

16#cafe * 32#sugar

变量必须是大写字母开头   一次性变量赋值  否则得到 badmatch 错误

分为绑定变量和未绑定变量   erlang 没有可变状态 没有共享内存 也没有锁

整数除法的时候 自动装化成小数 然后进行运算  所以结果一定是小数
div rem

原子

被用于表示常量值  原子具有全局性 小写字母开头 字母 数字 _ @
还可以放在 单引号里面 原子的值就是它本身  'a' 和 a 没有任何区别

每一个表达式必须要有值

元祖 大括号
{point,14,2} 这样可以是可读性增强 这是一种推荐的编程风格  并不是强制的
元组还可以嵌套
提取元祖里面的值 _ 被称为匿名变量 不必绑定为相同的值

列表 中括号
里面可以是任何类型
列表头 可以是任何事物 但是列表尾一定要是一个列表
访问列表头是一种非常高效的操作

字符串

整数组成的列表 或者一个二进制型
当所有的都是可打印字符 那么就会是一个字符串

$a 代表字符a的整数

X="a\x{221e}b"
io:format("~ts~n",[X])

io:format("~w~n",["abc"]) [97,98,99]

[H}T]="abc" H=97

f(). 忘记所有绑定

cd(DIR).  pwd(). ls().

函数
没有显示的返回结果 他的返回值就是字句的最后一条语句

, 分隔参数    ; 分隔子句

total([])->0;
total([{What,N}}H])->
     shop:cost(What)*N + total(H).

fun：基本的抽象但单元

Double=fun(X,Y)->math:sqrt(X*X+Y*Y) end.
如果有多个不同的子句
TempConvert=fun({c,C})->{f,32+C*9/5};
　　　　　　　　({f,F})->{c,(F-32)*5/9} end.

*函数作为参数lists:map(fun(X)->2*X end.,L)

lists:filter(fun(X)->X rem 2 =:= 0 end.,L).

* 函数作为返回值
MakeTest=fun(L)->(fun(X)->lists:member(X,L) end) end.

定义自己的控制抽象
for(Max,Max,F)->[F(Max)];
for(I,Max,F)->[F(I)|for(I+1,Max,F)].

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

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

total(L)->
sum(map(fun({What,N})->cost(What)*N end,L)).

列表推导
lists:map(fun(X)->2*X end,L).

[2*X || X <- L].

lists:sum([shop:cost(A)*B] || {A,B} <- Buy).

后面可以是生成器 位串 过滤器

快速排序
qsort([])->[];
qsort(Prev|H)->
　　qsort([X || X <- T,X<Prev])
　　++ [Prev] ++
　　qsort([X || X <-T,X>Prev]).

毕达哥拉斯三元组
pythag(N)->
[{A,B,C} || A <- lists:seq(1,N),
B <- lists:seq(1,N),
C <- lists:seq(1,N),
A+B+C =<N,
A*A+B*B =:= C*C]

回文构词
perms([])->[[]];
perms(L)->[[H|T] || H <- L, T <- perms(L--[H])].

X--Y 是列表一处操作符

工作:去取出第一个字符 然后去掉这个字符 然后再次取

内置函数
list_to_tuple(L) 将列表转化为元祖
time() 返回 {时,分,秒}

这些最常用的是自动导入的 不需要加前缀 erlang:

is_atom(X)                X是一个原子
is_binary(X)              X是一个二进制型
is_constant(X)          X是一个常量
is_float(X)                 X是一个浮点数
is_function(X)           X是一个fun
is_function(X, N)      X是一个带有N个参数的fun
is_integer(X)            X是一个整数
is_list(X)                   X是一个列表
is_map(X)                X是一个映射组
is_number(X)           X是一个整数或浮点数
is_pid(X)                  X是一个进程标识符
is_pmod(X)              X是一个参数化模块的实例
is_port(X)                 X是一个端
is_reference(X)        X是一个引用
is_tuple(X)               X是一个元组
is_record(X,Tag)      X是一个类型为Tag的记录
is_record(X,Tag,N)  X是一个类型为Tag、大小为N的记录

abs(X)                     X的绝对值
byte_size(X)           X的字节数,X必须是一个位串或二进制型
element(N, X)         X里的元素N，注意X必须是一个元组
float(X)                   将X转换成一个浮点数， X必须是一个数字
hd(X)                      列表X的列表头
length(X)                列表X的长度
node()                    当前的节点
node(X)                  创建X的节点， X可以是一个进程、标识符、引用或端口
round(X)                将X转换成一个整数， X必须是一个数字
self()                      当前进程的进程标识符
size(X)                  X的大小，它可以是一个元组或二进制型
trunc(X)                将X去掉小数部分取整， X必须是一个数字
tl(X)                      列表X的列表尾
tuple_size(T)       元组T的大小

关卡 用于增加模式匹配的威力

max(X,Y) when X > Y ->X;
max(X,Y) ->Y.

关卡序列 ;分割开来 其中一个为true 就为 true
关卡是有一系列表达式 组成 ,分割 所有为true 才为true

关卡不能调用用户定义的函数 因为要确保没有副作用

is_tuple(T) tuple_size(T) abs(A)
element(4,X) hd(L) 开头

使用 布尔表达式
A>=-1.0 andalso A+1>B

is_atom(L) orelse (is_list(L) andalso length(L)>2)

and andalso      and 和 or 不管怎样两边都会求值
or orelse

case语句

case Expression of
　　pattern1 when -> ..;
　　pattern2 when -> ..;
　　end

例子:

filter(P,[H|T])->
　　case P(H) of
　　　　true -> [H|filter(P,T)];
　　　　false -> filter(P,T)
　　end;
filter(P,[])->[].

就算没有case也能完成

filter(P,[H,T])->filter1(P(H),H,P,T);
filter(P,[])-> [].

filter1(true,H,P,T) ->[H,filter(P,T)];
filter1(false,H,P,T) -> filter(P,T).

if 表达式  经常会在最后加上关卡true 避免报错

List ++ [H]  不要这么干 这是很低效的

归集器

需求：得到一个列表的奇数和偶数

odds_and_events(L) ->
　　Odds=[X || X <- L, (X rem 2) =:= 1],
　　Events=[X || X <-L ,(X rem 2) =:=0],
　　{Odds,Events}.

问题在于 遍历了两次

重写

odds_and_events(L)->
　　odd_and_events_acc(L,[],[]).

odd_and_events_acc([H,T],Odds,Events)->
　　case (H rem 2) of
　　　　1 -> odd_and_events_acc(T,[H | Odds],Events);
　　　　0 -> odd_and_events_acc(T,Odds,[H,Events])
　　end;
odd_and_events_acc([],Odds,Events)->
　　{Odds,Events}.