Elixir基础笔记(一)—— 基本类型

这篇文章中我们主要了解Elixir中的基本数据类型:整数(integers),浮点数(floats),布尔值(booleans),原子(atoms),字符串(strings),列表(lists)和元组(tuples)

1
2
3
4
5
6
7
8
iex> 1          # 整数
iex> 0x1F # 整数
iex> 1.0 # 点数
iex> true # 布尔值
iex> :atom # 原子 / 符号
iex> "elixir" # 字符
iex> [1, 2, 3] # 列表
iex> {1, 2, 3} # 元组

整型

1
2
3
4
5
6
iex> 1 + 2
3
iex> 5 * 5
25
iex> 10 / 2
5.0

在Elixir中除法运算符/永远返回的是浮点数。如果想要整数除法或者取余需要使用divrem方法

1
2
3
4
5
6
iex> div(10, 2)
5
iex> div 10, 2
5
iex> rem 10, 3
1

Elixir同样支持二进制,八进制和十六进制的整数

1
2
3
4
5
6
iex> 0b1010
10
iex> 0o777
511
iex> 0x1F
31

浮点数

浮点数支持指数表示法

1
2
3
4
iex> 1.0
1.0
iex> 1.0e-10
1.0e-10

保留固定位小数

1
2
3
4
iex> round(3.58)
4
iex> trunc(3.58)
3

布尔值

Elixir包含truefalse两种布尔值。

1
2
3
4
iex> true
true
iex> true == false
false

可以通过is_boolean/1来判断是否为布尔值

1
2
3
4
iex> is_boolean(true)
true
iex> is_boolean(1)
false

同理你可以使用is_integer/1is_float/1或者is_number/1来检查值是否为整数,浮点数以及是否为数字。

原子

原子类型是名字和代表的值相同的常量,和Ruby语言中的符号是一个意思

1
2
3
4
5
6
iex> :apple
:apple
iex> :orange
:orange
iex> :watermelon
:watermelon

两个相同名字的原子是相等的

1
2
3
4
iex> :apple == :apple
true
iex> :apple == :orange
false

布尔值truefalse同样也是原子。

1
2
3
4
5
6
iex> true == :true
true
iex> is_atom(false)
true
iex> is_boolean(:false)
true

Elixir的模块(module)名字和以大写字母开始的别名(alias)也是原子。

1
2
iex> is_atom(Hello)
true

字符串

Elixir的字符串是UTF-8编码的,用双引号包住

1
2
iex> "hellö"
"hellö"

Elixir的字符串同样支持字符串插入和换行。

1
2
3
4
5
6
7
8
iex> "hellö #{:world}"
"hellö world"

iex> "hello
...> world"
"hello\nworld"
iex> "hello\nworld"
"hello\nworld"

String模块包含了一系列的函数来操作字符串,例如

1
2
iex> String.upcase("hellö")
"HELLÖ"

列表

Elixir使用方括号来定义列表

1
2
3
4
iex> [1, 2, true, 3]
[1, 2, true, 3]
iex> length [1, 2, 3]
3

两个列表可以使用++/2--/2来进行合并和删除。

1
2
3
4
iex> [1, 2, 3] ++ [4, 5, 6]
[1, 2, 3, 4, 5, 6]
iex> [1, true, 2, false, 3, true] -- [true, false]
[1, 2, 3, true]

我们还可以使用hd/1tl/1来拿到一个列表的第一个元素和剩余的元素

1
2
3
4
5
iex> list = [1, 2, 3]
iex> hd(list)
1
iex> tl(list)
[2, 3]

但是作用于空列表的话会抛出错误

1
2
iex> hd []
** (ArgumentError) argument error

列表在内存中是按照链表结构存储的。这表示我们在列表头部添加元素要比在列表尾部添加元素快很多。同样的,获取列表的长度需要穿过整个列表才能得到。

1
2
3
4
5
6
7
8
9
iex> list = [1, 2, 3]

# This is fast as we only need to traverse `[0]` to prepend to `list`
iex> [0] ++ list
[0, 1, 2, 3]

# This is slow as we need to traverse `list` to append 4
iex> list ++ [4]
[1, 2, 3, 4]

元组

Elixir使用花括号来定义元组。

1
2
3
4
iex> {:ok, "hello"}
{:ok, "hello"}
iex> tuple_size {:ok, "hello"}
2

元组在内存中是连续存放的。这样的话,获取元组的长度很快,但是修改元组的操作很昂贵:新的元组必须重新在内存中拷贝一份。

1
2
3
4
5
6
7
8
9
10
11
12
13
iex> tuple = {:ok, "hello"}
{:ok, "hello"}
iex> elem(tuple, 1)
"hello"
iex> tuple_size(tuple)
2

iex> tuple = {:ok, "hello"}
{:ok, "hello"}
iex> put_elem(tuple, 1, "world")
{:ok, "world"}
iex> tuple
{:ok, "hello"}