...> else
...> "This will"
...> end
"This will"
unless 和 if 相反，条件为false时才执行
iex> unless true do
...> "This won't be seen"
...> else
...> "This will"
...> end
"This will"
do
do 语句快有2种写法：
iex> if true do
...> "this is true"
...> else
...> "this is false"
...> end
OR
iex> if true, do: ("this is true"), else: ("this is false")
键值列表-图-字典
键值列表
iex> l = [{:a, 1},{:b, 2}]
[a: 1, b: 2]
iex> l[:a]
1
iex> l[:b]
2
键值列表还有另一种定义方式：(注意 a: 和 1 之间必须有个空格)
iex> l = [a: 1, b: 2]
[a: 1, b: 2]
键值列表2个特点：
- 有序
- key 可以重复，重复时，优先取排在前面的key
iex> l = [a: 3] ++ l;
[a: 3, a: 1, b: 2]
iex> l
[a: 3, a: 1, b: 2]
iex> l[:a]
3
图
图的2个特点：
- 图中的key是无序的
- 图的key可以是任意类型
iex> map = %{:a => 1, 2 => :b}
%{2 => :b, :a => 1}
图匹配时，只要 = 右边包含左边的值就能匹配上
iex> %{} = %{:a => 1, 2 => :b}
%{2 => :b, :a => 1}
iex> %{:a => 1, 2 => :b} = %{}
** (MatchError) no match of right hand side value: %{}
iex> %{:a => 1} = %{:a => 1, 2 => :b}
%{2 => :b, :a => 1}
iex> %{:a => 1, :c => 2} = %{:a => 1, 2 => :b}
** (MatchError) no match of right hand side value: %{2 => :b, :a => 1}
修改图中的值可以用以下的方式：
iex> %{map | 2 => :c}
%{2 => :c, :a => 1}
字典
以上的 键值列表 和 图 都是 字典 ，它们都实现了 Dict 接口。
此模块现在已经 deprecated
模块和函数定义
模块和函数定义方式
defmodule Math do
def sum(a, b) do
do_sum(a, b)
end
defp do_sum(a, b) do
a + b
end
end
Math.sum(1, 2) #=> 3
Math.do_sum(1, 2) #=> ** (UndefinedFunctionError)
函数中的卫兵表达式
defmodule Math do
def zero?(0) do
true
end
def zero?(x) when is_number(x) do
false
end
end
Math.zero?(0) #=> true
Math.zero?(1) #=> false
Math.zero?([1,2,3])
#=> ** (FunctionClauseError)
默认参数
defmodule Concat do
def join(a, b, sep \\ " ") do
a <> sep <> b
end
end
IO.puts Concat.join("Hello", "world") #=> Hello world
IO.puts Concat.join("Hello", "world", "_") #=> Hello_world
枚举类型和流
枚举类型
枚举类型提供了大量函数来对列表进行操作
iex> Enum.sum([1,2,3])
6
iex> Enum.map(1..3, fn x -> x * 2 end)
[2, 4, 6]
iex> Enum.reduce(1..3, 0, &+/2)
6
iex> Enum.filter(1..3, &(rem(&1, 2) != 0))
[1, 3]
枚举操作都是积极的，比如如下的操作：
iex> odd? = &(rem(&1, 2) != 0)
#Function<6.54118792/1 in :erl_eva l.expr/5>
iex> 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum
7500000000
以上每步的操作(Enum.map, Enum.filter)都会产生一个新的列表，这就是 积极 的意思。
流
和上面的枚举类型对应，流的处理是 懒惰 的，比如：
iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum
7500000000
表面上看，和枚举类型的处理一样，而实际上，流先创建了一系列的计算操作。然后仅当我们把它传递给Enum模块，它才会被调用。
iex> stream = 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?)
#Stream<[enum: 1..100000,
funs: [#Function<23.27730995/1 in Stream.map/2>,
#Function<8.27730995/1 in Stream.filter/2>]]>
iex> Enum.sum(stream) <== 这里才开始执行
7500000000
进程
elixir中进程都是轻量级的，所以使用时不用太在意进程的数目。
派生的进程执行完自动结束自己
iex> pid = spawn fn -> 1 + 2 end
#PID<0.62.0>
iex> Process.alive?(pid)
false
发送和接收消息
下面示例中是给自己发送了一条消息，可以通过 flush/1 函数刷新消息，刷新一次之后就
iex> send self(), {:hello, "world"}
{:hello, "world"}
iex> flush
{:he