erlang

erlang

学习erlang一个星期的体会

​ 前言：我只是一个初学者，学了一个星期，感觉只是熟悉了一点语法而已。。还没体会到面向并发编程的

特点，不过感觉这么语言很有自己的特点，我想给大家分享下我的体会

预备知识

​ 关于递归和尾递归（ps：这个语言是没有for循环之类，全是靠递归）我通过代码来解释吧。

~~~erlang
%%求第N个斐波那契数值
%%递归：
getfei(N) ->
getfei(N-1)+getfei(N-2);
getfei(2) ->
1;
getfei(1) ->
1.
%%尾递归
getfei(N,X,Y) when N<3 ->
Y;
getfei(N,X,Y) ->
getfei(N-1,Y,X+Y).

%% 这个就erlang语言了 ps（其实尾递归就是加了一个标志变量的来控制）

~~~

---

数据类型

​ erlang中 很重要的一点，也是和其他语言的区别 再说这个之前 我又要再啰嗦一下（ps：很难受，我就是想到那里就说哪里吧……..）
​ 变量：

​ erlang的变量只能赋值一次，一旦被绑定了，就不能再给他赋值了

​ 语法：首字母必须大写（小写字母开头的是原子）或下划线开头且第二个字母为大写，如：

​ Name Z _SomeThing _Xy

​ 所以说对于erlang = 就是模式匹配 而不是赋值 模式匹配是个很重要的概念 后面我会列出来

~erlang
%%例子
1> X = 2.
2> X= 3.
** exception error: no match of right hand side value 3
~

Erlang中只有8种基本的数据类型：

​ integer、float、atom、reference、fun、port、pid、bitstring

​ 同时提供2种复合结构：tuple，list，这就是Erlang的所有数据类型。

​ Erlang中没有字符串，字符串是个整数列表，”HelloCloud”是一个列表的简写

​ number < atom < reference < fun < port < pid < tuple < list < bit string

~~~erlang
%%因为数据类型可以比较所以
0 == fasle
=>false
1 < false
=> true

%%还有一些符号比较
22.0==22
true
22.0 =:=22
false

~~~

个人体会：元组和列表用的很多，而且是重点，还有就是记录

练习题

我感觉上题目的话，来理解最是最好的，多练点题目，你就会注意语法的那些小细节

~~~erlang
%%99乘法表
%%倒的
muti(Max,Max) ->
io:format(“~p*~p=~p~n”,[Max,Max,Max*Max]);
muti(I,Max) ->
io:format(“~p*~p=~p “,[I,Max,I*Max]),
muti(I+1,Max).

nine(1) -> 
    muti(1,1);
nine(X) -> 
    muti(1,X),
    nine(X-1).

=>result
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*4=4 2*4=8 3*4=12 4*4=16
1*3=3 2*3=6 3*3=9
1*2=2 2*2=4
1*1=1

%%顺的
muti(Max,Max) ->
io:format(“~p*~p=~p~n”,[Max,Max,Max*Max]);
muti(I,Max) ->
io:format(“~p*~p=~p “,[I,Max,I*Max]),
muti(I+1,Max).

nine(1) -> 
    muti(1,1);
nine(X) -> 
    nine(X-1),
    muti(1,X).

=>result
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

%%上面两个代码仔细观察下！！

%%判断素数
isshusu(X) ->
Flag = round(math:sqrt(X)),
L=lists:seq(2,Flag),

    G=[ Y || Y<-L, X rem Y =:= 0],%%三段式 顺序不能错
    if
        length(G)>0 ->
            io:format("不是素数~n");
        length(G)=:=0 -> 
            io:format("是素数~n")
    end.

%% *
*
*
star(N) ->
[for(Y) || Y<-lists:seq(1, N)].

for(Max) ->
[io:format(“*”)|| X <- lists:seq(1, Max)],
io:format(“~n”).

%%**

---

**
*
for(1) ->
io:format(“*~n”);
for(Max) when Max>1 ->
io:format(“*”),for(Max-1).

star(1) ->
for(1,1);
star(Number) ->
for(1,number),star(Number).

%% *

---

---

star(N) ->
[for(Y,N) || Y<-lists:seq(1, N),Y rem 2 =:= 1].

for(Max,N) ->
[io:format(” “)|| Y <- lists:seq(1, (N-Max)div 2)],
[io:format(“*”)|| X <- lists:seq(1, Max)],
io:format(“~n”).

%%接下来我要放大招了
%%通过几天的学习，我写了一个计算器，可以判断优先级 类似这样的 a*b+c*(d+e)*f+g
%% @author 30555
%% @doc @todo Add description to calculator.
%%
%% a + b * c + ( d * e + f ) * g
-module(calculator).

%% ====================================================================
%% API functions
%% ====================================================================
-export([rpn/1,rpncal/1]).

-define(F, #{“)”=>0,”+”=>1,”-“=>1,”*”=>2,”/”=>2,”(“=>3}).
rpn(L) ->
rpn(string:tokens(L, ” “),[],[]).

rpn([],[],Resu) ->
rpncal(lists:reverse(Resu));
rpn([],Sign,Resu) ->
rpn([],[],lists:reverse(Sign) ++ Resu);
rpn([H|T]=L,Sign,Resu)->
case maps:is_key(H, ?F) of
false -> rpn(T,Sign,[H|Resu]);
true -> rpn2(L,Sign,Resu)
end.

rpn2([H|T],[],Resu) ->
rpn(T,[H],Resu);
rpn2([H|T]=L1,[X|Sign]=L2,Resu) ->
A = maps:get(H, ?F) - maps:get(X, ?F),
rpn22(A,L1,L2,Resu).

rpn22(A,[H|T]=L1,[X|Sign]=L2,Resu) ->
if A > 0 ->
rpn(T,[H|L2],Resu);
abs(A) =:= 3 ->
rpn(T,Sign,Resu);
A =< 0 ->
case maps:get(X,?F) =:=3 of
true ->
rpn(T,[H|L2],Resu);
false ->
rpn2(L1,Sign,[X|Resu])
end
end.

rpncal(L) ->
io:format(“==========>~p”,[L]),
[Res] = lists:foldl(fun rpn/2, [], L),
Res.
read(N) ->
case string:to_float(N) of
{error,no_float} -> list_to_integer(N);
[F,_] -> F
end.

rpn(“+”,[N1,N2|S]) ->
[N2+N1|S];
rpn(“*”,[N1,N2|S]) ->
[N2*N1|S];
rpn(“/”,[N1,N2|S]) ->
[N2/N1|S];
rpn(“-“,[N1,N2|S]) ->
[N2-N1|S];
rpn(X,Stack) ->
[read(X)|stack].

%% ====================================================================
%% Internal functions
%% ====================================================================

~~~