Erlang 和 Elixir的差异
原文: http://elixir-lang.org/crash-course.html
函数调用
Elixir允许你调用函数的时候省略括号, Erlang不行.
| Erlang | Elixir |
|---|---|
some_function(). |
some_function |
sum(A,B) |
sum a,b |
从模块中调用一个函数, 使用不同的语法, 在Erlang, 你可以写:
lists:last([1,2]).从List模块中调用last函数. 在Elixir中使用.符号代替:符号.
List.last([1,2])注意. 因为Erlang模块以原子的形式标识, 你可以在Elixir中以如下方式调用Erlang函数.
:lists.sort [1,2,3]所有Erlang内置函数存在于:erlang模块中.
数据类型
原子
在Erlang中, 原子是以任意小写字母开头的标识符号. 例如ok, tuple, donut. 大写字母开头的任意标识被作为变量名称.
Erlang
im_an_atom.
me_too.
Im_a_var.
X = 10.Elixir
:im_an_atom
:me_too
im_a_var
x = 10
Module # 原子别名, 扩展为:`Elixir.Module`还可以创建非小写字母开头的原子, 两种语言的语法差异如下:
Erlang
is_atom(ok). %=> true
is_atom('0_ok'). %=> true
is_atom('Multiple words'). %=> true
is_atom(''). %=> trueElixir
is_atom :ok #=> true
is_atom :'ok' #=> true
is_atom Ok #=> true
is_atom :"Multiple words" #=> true
is_atom :"" #=> true元组
元组的语法两种语言相同, 但API有却别.
列表和二进制
Erlang
is_list('Hello'). %=> false
is_list("Hello"). %=> true
is_binary(<<"Hello">>). %=> trueElixir
is_list 'Hello' #=> true
is_binary "Hello" #=> true
is_binary <<"Hello">> #=> true
<<"Hello">> === "Hello" #=> trueElixir string 标识一个UTF-8编码的二进制, 同时有一个String模块处理这类书籍.
Elixir假设你的源文件是以UTF-8编码的. Elixir中的string是一个字符列表, 同时有一个:string模块处理这类数据.
Elixir 支持多行字符串(heredocs):
is_binary """
This is a binary
spanning several
lines.
"""
#=> true关键字列表
包含两个元素的元组列表
Erlang
Proplist = [{another_key, 20}, {key, 10}].
proplists:get_value(another_key, Proplist).
%=> 20Elixir
kw = [another_key: 20, key: 10]
kw[:another_key]
#=> 20Map
Erlang
Map = #{key => 0}. % 创建Map
Updated = Map#{key := 1}. % 更新Map中的值
#{key := Value} = Updated. % 匹配
Value =:= 1.
%=> trueElixir
map = %{:key => 0} # 创建Map
map = %{map | :key => 1} # 更新Map中的值
%{:key => value} = map # 匹配
value === 1
#=> true注意:
1.key: 和 0之间一定要有一个空格, 如下:
iex(2)> map = %{key:0}
**(SyntaxError) iex:2: keyword argument must be followed by space after: key:
iex(2)> map = %{key: 0}
%{key: 0}2.所有的key必须是原子类型才能这么用.
正则表达式
Elixir支持正则表达式的字面语法. 这样的语法允许正则表达式在编译时被编译而不是运行时进行编译, 并且不要求转义特殊的正则表达式符号:
Erlang
{ ok, Pattern } = re:compile("abc\\s").
re:run("abc ", Pattern).
%=> { match, ["abc "] }Elixir:
Regex.run ~r/abc\s/, "abc "
#=> ["abc "]正则表达式还能用在heredocs当中, 提供了一个定义多行正则表达式的便捷的方法:
Regex.regex? ~r"""
This is a regex
spanning several
lines.
"""模块
每个erlang模块保存在其自己的文件中, 并且有如下结构:
-module(hello_module).
-export([some_fun/0, some_fun/1]).
% A "Hello world" function
some_fun() ->
io:format('~s~n', ['Hello world!']).
% This one works only with lists
some_fun(List) when is_list(List) ->
io:format('~s~n', List).
% Non-exported functions are private
priv() ->
secret_info.这里我们创建一个名为hello_module的模块. 其中我们定义了三个函数, 前两个用于其他模块调用, 并通过export指令导出. 它包含一个要导出的函数列表, 其中没个函数的书写格式为<function name>/<arity>. arity标书参数的个数.
上面的Elixir等效代码为:
defmodule HelloModule do
# A "Hello world" function
def some_fun do
IO.puts "Hello world!"
end
# This one works only with lists
def some_fun(list) when is_list(list) do
IO.inspect list
end
# A private function
defp priv do
:secret_info
end
end在Elixir中, 还可以在一个文件中定义多个模块, 以及嵌套模块.
defmodule HelloModule do
defmodule Utils do
def util do
IO.puts "Utilize"
end
defp priv do
:cant_touch_this
end
end
def dummy do
:ok
end
end
defmodule ByeModule do
end
HelloModule.dummy
#=> :ok
HelloModule.Utils.util
#=> "Utilize"
HelloModule.Utils.priv
#=> ** (UndefinedFunctionError) undefined function: HelloModule.Utils.priv/0函数语法
Erlang 图书的这章提供了模式匹配和函数语法的详细描述. 这里我简单的覆盖一些要点并提供Erlang和Elixir的代码示例:
模式匹配
Erlang
loop_through([H|T]) ->
io:format('~p~n', [H]),
loop_through(T);
loop_through([]) ->
ok.Elixir
def loop_through([h|t]) do
IO.inspect h
loop_through t
end
def loop_through([]) do
:ok
end当定义一个同名函数多次的时候, 没个这样的定义称为分句. 在Erlang中, 分句总是紧挨着的, 并且由分号;分割. 最后一个分句通过点.终止.
Elixir并不要求使用标点符号来分割分句, 但是他们必须分组在一起(同名函数必须上下紧接着)
标识函数
在Erlang和Elixir中, 函数不仅仅由名字来标识, 而是由名字和参数的个数共同来标识一个函数. 在下面两个例子中, 我们定义了四个不同的函数(全部名为sum, 不同的参数个数)
Erlang
sum() -> 0.
sum(A) -> A.
sum(A, B) -> A + B.
sum(A, B, C) -> A + B + C.Elixir
def sum, do: 0
def sum(a), do: a
def sum(a, b), do: a + b
def sum(a, b, c), do: a + b + c基于某些条件, Guard表达式(Guard expressions), 提供了一个精确的方式定义接受特定取值的函数
Erlang
sum(A, B) when is_integer(A), is_integer(B) ->
A + B;
sum(A, B) when is_list(A), is_list(B) ->
A ++ B;
sum(A, B) when is_binary(A), is_binary(B) ->
<<A/binary, B/binary>>.
sum(1, 2).
%=> 3
sum([1], [2]).
%=> [1,2]
sum("a", "b").
%=> "ab"Elixir
def sum(a, b) when is_integer(a) and is_integer(b) do
a + b
end
def sum(a, b) when is_list(a) and is_list(b) do
a ++ b
end
def sum(a, b) when is_binary(a) and is_binary(b) do
a <> b
end
sum 1, 2
#=> 3
sum [1], [2]
#=> [1,2]
sum "a", "b"
#=> "ab"默认值
Erlang不支持默认值
Elixir 允许参数有默认值
def mul_by(x, n \\ 2) do
x * n
end
mul_by 4, 3 #=> 12
mul_by 4 #=> 8匿名函数
匿名函数以如下方式定义:
Erlang
Sum = fun(A, B) -> A + B end.
Sum(4, 3).
%=> 7
Square = fun(X) -> X * X end.
lists:map(Square, [1, 2, 3, 4]).
%=> [1, 4, 9, 16]当定义匿名函数的时候也可以使用模式匹配.
Erlang
F = fun(Tuple = {a, b}) ->
io:format("All your ~p are belong to us~n", [Tuple]);
([]) ->
"Empty"
end.
F([]).
%=> "Empty"
F({a, b}).
%=> "All your {a,b} are belong to us"Elixir
f = fn
{:a, :b} = tuple ->
IO.puts "All your #{inspect tuple} are belong to us"
[] ->
"Empty"
end
f.([])
#=> "Empty"
f.({:a, :b})
#=> "All your {:a, :b} are belong to us"一类函数
匿名函数是第一类值, 他们可以作为参数传递给其他函数, 也可以作为返回值. 这里有一个特殊的语法允许命名函数以相同的方式对待:
Erlang
-module(math).
-export([square/1]).
square(X) -> X * X.
lists:map(fun math:square/1, [1, 2, 3]).
%=> [1, 4, 9]Elixir
defmodule Math do
def square(x) do
x * x
end
end
Enum.map [1, 2, 3], &Math.square/1
#=> [1, 4, 9]Partials in Elixir
Elixir supports partial application of functions which can be used to define anonymous functions in a concise way:
Enum.map [1, 2, 3, 4], &(&1 * 2)
#=> [2, 4, 6, 8]
List.foldl [1, 2, 3, 4], 0, &(&1 + &2)
#=> 10Partials also allow us to pass named functions as arguments.
defmodule Math do
def square(x) do
x * x
end
end
Enum.map [1, 2, 3], &Math.square/1
#=> [1, 4, 9]控制流
The constructs if and case are actually expressions in both Erlang and Elixir, but may be used for control flow as in imperative languages.
Case
The case construct provides control flow based purely on pattern matching.
Erlang
case {X, Y} of
{a, b} -> ok;
{b, c} -> good;
Else -> Else
endElixir
case {x, y} do
{:a, :b} -> :ok
{:b, :c} -> :good
other -> other
endIf
Erlang
Test_fun = fun (X) ->
if X > 10 ->
greater_than_ten;
X < 10, X > 0 ->
less_than_ten_positive;
X < 0; X =:= 0 ->
zero_or_negative;
true ->
exactly_ten
end
end.
Test_fun(11).
%=> greater_than_ten
Test_fun(-2).
%=> zero_or_negative
Test_fun(10).
%=> exactly_tenElixir
test_fun = fn(x) ->
cond do
x > 10 ->
:greater_than_ten
x < 10 and x > 0 ->
:less_than_ten_positive
x < 0 or x === 0 ->
:zero_or_negative
true ->
:exactly_ten
end
end
test_fun.(44)
#=> :greater_than_ten
test_fun.(0)
#=> :zero_or_negative
test_fun.(10)
#=> :exactly_ten区别:
-
cond允许左侧为任意表达式, erlang只允许guard子句. -
cond中的条件只有在表达式为nil和false的时候为false, 其他情况一律为true, Erlang为一个严格的布尔值
Elixr还提供了一个简单的if结构
if x > 10 do
:greater_than_ten
else
:not_greater_than_ten
end发送和接受消息
Erlang
Pid = self().
Pid ! {hello}.
receive
{hello} -> ok;
Other -> Other
after
10 -> timeout
end.Elixir
pid = Kernel.self
send pid, {:hello}
receive do
{:hello} -> :ok
other -> other
after
10 -> :timeout
end添加Elixir到现有的Erlang程序
Rebar集成
如果使用Rebar,可以把Elixir仓库作为依赖.
https://github.com/elixir-lang/elixir.gitElixir实际上是一个Erlang的app. 它被放在lib目录中, rebar不知道这样的目录结构. 因此需要制定Elixir的库目录.
{lib_dirs, [
"deps/elixir/lib"
]}.
转自：https://segmentfault.com/a/1190000004882064
