Erlang 备忘清单
Erlang 是一种用于构建并发、分布式和容错系统的编程语言。以下是一些常用的命令和操作。
入门
启动 Erlang Shell
编译代码
1
2
3
4
| # 在 Erlang Shell 中编译
c(module).
# 在命令行中编译
erlc module.erl
|
运行代码
1
2
3
4
| # 在 Erlang Shell 中运行
module:function().
# 从命令行运行
erl -noshell -s module function -s init stop
|
退出 Erlang Shell
代码结构
模块定义
1
2
3
4
5
6
| -module(module_name).
-export([function_name/arity, ...]).
function_name(Args) ->
Result.
|
导出函数
1
| -export([function1/0, function2/1]).
|
注释
变量
1
2
3
| VarName = Value.
Age = 25.
Name = "Alice".
|
数据类型
原子
数字
布尔值
字符串
元组
列表
1
2
| [1, 2, 3].
[H|T] = [1, 2, 3].
|
字典 (Map)
1
| #{key1 => value1, key2 => value2}.
|
控制结构
条件语句
1
2
3
4
5
| if
Condition1 -> Expression1;
Condition2 -> Expression2;
true -> DefaultExpression
end.
|
case 表达式
1
2
3
4
5
| case Expression of
Pattern1 -> Expression1;
Pattern2 -> Expression2;
_ -> DefaultExpression
end.
|
函数定义
1
2
3
4
5
6
7
|
my_function() ->
ok.
add(A, B) ->
A + B.
|
列表操作
列表生成
1
2
3
4
5
|
[ X || X <- lists:seq(1, 10)].
[ X || X <- lists:seq(1, 10), X rem 2 == 0].
|
并发
启动进程
1
2
3
4
| spawn(Module, Function, Args).
% 示例
Pid = spawn(fun() -> io:format("Hello from process~n") end).
|
发送消息
1
2
3
4
| Pid ! Message.
Pid ! {hello, self()}.
|
接收消息
1
2
3
4
5
| receive
Pattern1 -> Expression1;
Pattern2 -> Expression2;
after Timeout -> TimeoutExpression
end.
|
模式匹配
常用内置函数 (BIFs)
列表操作
1
2
3
4
| lists:append(List1, List2).
lists:map(Function, List).
lists:filter(Function, List).
lists:foldl(Function, Acc, List).
|
元组操作
1
2
3
| element(N, Tuple).
setelement(N, Tuple, Value).
tuple_size(Tuple).
|
字符串操作
1
2
3
| string:len(String).
string:concat(String1, String2).
string:tokens(String, Delimiters).
|
文件操作
1
2
3
| file:read_file(Filename).
file:write_file(Filename, Data).
file:delete(Filename).
|
列表操作
1
2
| lists:map(fun(X) -> X * 2 end, [1, 2, 3]).
lists:filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]).
|
字符串操作
1
2
| string:len("Hello").
string:upper("hello").
|
文件操作
1
2
3
| {ok, File} = file:open("test.txt", [write]).
file:write(File, "Hello, file!").
file:close(File).
|
示例：简单的服务器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| -module(server).
-export([start/0, loop/0]).
start() ->
spawn(fun loop/0).
loop() ->
receive
{echo, Msg} ->
io:format("Echo: ~p~n", [Msg]),
loop();
stop ->
io:format("Server stopping~n"),
ok;
_ ->
io:format("Unknown message~n"),
loop()
end.
|
并发编程
创建进程
1
| Pid = spawn(Module, Function, Args).
|
发送消息
接收消息
1
2
3
4
5
| receive
Pattern1 -> Actions1;
Pattern2 -> Actions2;
...
end.
|
链接进程
监控进程
1
2
| MonitorRef = erlang:monitor(process, Pid).
erlang:demonitor(MonitorRef).
|
错误处理
捕获异常
1
2
3
4
5
| try Expression of
Pattern -> Result
catch
Class:Reason -> Handler
end.
|
常见异常类型
错误处理
1
2
3
4
5
| try Expression of
Pattern -> Result
catch
Type:Reason -> ErrorHandlingExpression
end.
|
分布式编程
启动分布式节点
1
| erl -name nodename@hostname -setcookie Cookie
|
连接节点
发送消息到远程节点
1
| {remote_process, 'remote_node@host'} ! Message.
|
OTP 框架
定义 GenServer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| -module(my_gen_server).
-behaviour(gen_server).
-export([start_link/0, init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
start_link() ->
gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
init([]) ->
{ok, #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}.
|
使用 GenServer
1
2
3
| gen_server:start_link({local, Name}, Module, Args, Options).
gen_server:call(ServerRef, Request).
gen_server:cast(ServerRef, Msg).
|
测试
编写 EUnit 测试
1
2
3
4
5
6
7
8
9
10
11
| -module(module_name_tests).
-include_lib("eunit/include/eunit.hrl").
simple_test() ->
?assertEqual(Expected, Actual).
complex_test_() ->
[
{"Test case 1", ?_assertEqual(Expected1, Actual1)},
{"Test case 2", ?_assertEqual(Expected2, Actual2)}
].
|
运行 EUnit 测试
1
2
| # 在命令行中运行
erl -eval "eunit:test(module_name)" -s init stop
|
另见
