编程语言有了基本数据结构，那么可以遣词造句了。等等，词组是有了，可是如何把这些词组组合起来呢？

本节将会介绍运算符，基本数据结构通过运算符的计算，获得预期的值。Elixir的运算符与其他语言类似，并没有特别之处。主要有下面几类：

• 布尔操作符 （Boolean operators）
• 比较操作符 （Comparison operators）
• 算术运算符（Arithmetic operators）
• 包含操作符（in operator）

布尔操作符

Elixir的布尔操作符只有三个，分别是and，or，not。之前介绍了布尔类型的数据结构。布尔操作符恰恰就是专门用于操作布尔类型的操作符。并且，布尔操作符只能接受布尔值做运算，非布尔值将会报错。

iex(1)> a = true
true
iex(2)> b = false
false
iex(3)> a and b
false
iex(4)> a or b
true
iex(5)> not a
false
iex(6)> not 1
** (ArgumentError) argument error
    :erlang.not(1)
iex(6)> 1 and 2
** (ArgumentError) argument error: 1
iex(6)> 2 or 3
** (ArgumentError) argument error: 2

布尔操作符运算遵循短路规则。即and表达式总是返回第一个false，如果全部是true的值，则返回最后一个true的值。or则返回第一个是true的值，如果都是false，则返回最后一个false的值。not则最简单，取反的值即可。一旦表达式返回了，就不会计算后面的逻辑表达式了。

and

a and b # 如果 a 的值是 false，返回false，否则返回 b

iex(1)> a = false
false
iex(2)> b = 1
1
iex(3)> a and b
false
iex(4)> a = true
true
iex(5)> a and b
1

这里需要注意，方才我们说布尔操作符只接受布尔值，非布尔值将会报错。为什么当 a=true，b=1的时候，a and b不会报错，反而返回b的值呢？

实际上，上面的and操作符运算的时候，都是从左往右计算求值，对于表达式 a and b。可以这么理解，and 的左边对a求值得到true（a=true变量绑定）。然后and操作符左边接受且必须接受一个布尔值，此时为a，根据and的计算原则，如果a的true，直接返回。如果a的false，则不需要计算后面的结构了，直接返回and右边的b。也就是说b并没有被and计算求值。

在看下面的表达式：

iex(6)> a and b and b
** (ArgumentError) argument error: 1
iex(6)> a and b and 1
** (ArgumentError) argument error: 1

在第一个b后面再使用and操作符，第一个and把a当成参数计算的结果是返回b，第二个and则把返回的b当成自己的参数进行计算，显然此时b为1，不是布尔值，因此第二个and操作符报错。

iex(8)> a and true and b
1
iex(9)> a and true and a and b
1

当and计算到最后一个元素，都是true的时候，则直接返回最后一个元素。例如上面的例子，最后一个and前面的值都是true，则返回and右边的值，此时不需要对右边的值进行逻辑求值。

掌握逻辑操作的关键就是布尔操作符号每次只把左边的数当成参数求值计算，要么返回计算的结果，要么就返回右边的值。此时右边的值无需计算。

or

or操作符的原则是

a or b # 如果 a 的值是 true，返回ture，否则返回 b

iex(1)> a = true
true
iex(2)> a or b
true
iex(3)> b = 1
1
iex(4)> a = false
false
iex(5)> a or b
1
iex(6)> a or b or true
** (ArgumentError) argument error: 1

掌握了逻辑运算的规则，or也很容易理解。or左边是true，则返回true，如果左边不是true，则直接返回右边的值，不需要对右边的项求值，除非右边的项右边还有操作符。

not

not操作符最简单了

not a # 如果 a 的值是 true，返回false，否则返回 true

与and，or 不同的在于，not不是对左边的项求值，而是对右边的第一项求值。

下面看一个表达式，你觉得结果是什么呢？为什么？

iex(2)> me = true
true
iex(3)> you = false
false
iex(4)> him = :love_u
:love_u
iex(5)> me and you or him
???

当然，如果觉得逻辑操作符只能对布尔值求值比较麻烦。想要对普通的类型求值，可以使用宽松的逻辑操作符&&， ||，!。这三个符号也可以做布尔运算，并且可以接受非布尔值做计算。其中计算的原则是，除了false和nil两个值之外，其他的一切类型求值都是true。

iex(1)> a = true
true
iex(2)> b = 1
1
iex(3)> a and b
1
iex(4)> a and b and 1
** (ArgumentError) argument error: 1
iex(4)> a && b
1
iex(5)> a && b && 1
1
iex(6)> nil && a
nil
iex(7)>

||和!与or和not类似，大家可以自己试试。

比较操作符

Elixir中的=表示模式匹配的符号，与其他语言不一样。那么其他语言的双等号==，Elixir也别有洞天么？

当然不是Elixir的==与其他语言基本一样，用于表示==符号左右两边的数值相当。但是，仅仅是表示值相等，如果需要表示值和类型都相等，需要再加一个等号。

iex(1)> a = 1
1
iex(2)> b = 1.0
1.0
iex(3)> a == b
true
iex(4)> a === b
false
iex(5)>

比较操作符也没有什么特别的，大致如下：

a === b     # 严格意义上的相等，包括值和数据类型 (so 1 === 1.0 is false)
a !== b     # 严格意义上的不等 (so 1 !== 1.0 is true)
a == b      # 值相等 (so 1 == 1.0 is true)
a != b      # 值不等 (so 1 != 1.0 is false)
a > b       # 大于
a >= b      # 大于等于:
a < b       # 小于:
a <= b      # 小于等于:

比较操作符除了做数值大小的比较，还可以做排序的比较。Elixir中的比较排序并不像别的语言那么严格。不同类型也可以进行比较。如果类型相同或者一致，就会使用正常的类型比较。如果类型不同，则基于下面的优先原则：

数字类型(number) < 原子(atom) < 引用(reference) < 函数(function) < 端口(port) < 进程(pid) < 元组(tuple) < 图(map) < 列表(list) < 二进制(binary)

算术运算符

算术运算符也很常见了，基本上就是四则运算符号。四个符号如下：

• • 加法
• • 减法
• • 乘法
• / 除法

需要注意/做除法的时候，得到的结果都是浮点型的，即使能运算能够除尽。想要得到整型结果，需要使用内建的运算函数div。div的参数不能接受浮点型。Elixir很奇怪，没有常见的%做取余，而是使用一个内建的函数rem。

iex(1)> 10 / 3
3.3333333333333335
iex(2)> 10 / 2
5.0
iex(3)> div 10, 3
3
iex(4)> div 10, 2
5
iex(5)> rem 10 , 3
1
iex(6)> div 10.0, 2
** (ArithmeticError) bad argument in arithmetic expression
    :erlang.div(10.0, 2)

拼接操作（Join operators）

相信很多开发者都知道，+符号除了用于数字运算，还通常用于字符串数组列表等数据结构的拼接。elixir中提供了<>拼接字符串，++用于拼接列表，甚至还有--用于列表相减。

包含操作符（in operator）

in成员判断操作符也很常用。用于判断一个元素是否在一个容器集合里面。

本节针对elixir的基本运算符和操作符做了简单的介绍。有了他们，配合强大的元组列表图等结构。对于写一个Elixir程序，已经差不多万事俱备了。