协议

  1. 协议与结构体
  2. 执行Any
    1. 派生
    2. 回退到Any
  3. 内置协议
  4. 协议巩固

在Elixir中,只有false和nil为假.任何其他东西都为真.对应用来说,设定一个返回布尔值的blank?协议来判断其它数据类型是否为空也许十分重要.事实上,一个空的列表或一个空的二进制数会被认为是空的.

我们能够这样定义协议:

该协议需要一个名为blank?的函数,它接受一个参数.我们可以为其它Elixir数据类型实现这个协议:

  1. # 整数不可能为空白
  2. defimpl Blank, for: Integer do
  3.   def blank?(_), do: false
  4. end
  6. # 空的列表是空白
  7. defimpl Blank, for: List do
  8.   def blank?([]), do: true
  9.   def blank?(_),  do: false
  10. end
  12. # 空的映射是空白
  13. defimpl Blank, for: Map do
  14.   # 记住我们不能用%{}来模式匹配
  15.   # 它能匹配所有映射.但我们可以判断映射大小是否
  16.   # 为零(而且计算大小是一个快速操作).
  17.   def blank?(map), do: map_size(map) == 0
  18. end
  20. # 原子false和nil是空白
  21.   def blank?(false), do: true
  22.   def blank?(nil),   do: true
  23.   def blank?(_),     do: false
  24. end

我们为所有原始数据类型都这样做了.这些类型有:

  1. Atom
  2. BitString
  3. Float
  4. Function
  5. Integer
  6. List
  7. Map
  8. PID
  9. Port
  11. Tuple

协议和实现都已经定义好,我们可以调用它了:

  1. iex> Blank.blank?(0)
  2. false
  3. iex> Blank.blank?([])
  4. true
  5. iex> Blank.blank?([1, 2, 3])
  6. false

传递了一个协议没有实现的数据类型将会抛出一个错误:

  1. iex> Blank.blank?("hello")
  2. ** (Protocol.UndefinedError) protocol Blank not implemented for "hello"

协议与结构体

当同时使用协议与结构体时,Elixir的可扩展性就显示出来了.

在之前的章节,我们已经知道尽管结构体也是映射,但他们不和映射共享协议实现.让我们来定义一个和那一章中一样的User结构体:

  1. iex> defmodule User do
  2. ...>   defstruct name: "john", age: 27
  3. ...> end
  4. {:module, User,
  5.  <<70, 79, 82, ...>>, {:__struct__, 0}}

然后检查:

  1. defimpl Blank, for: User do
  2.   def blank?(_), do: false
  3. end

如果需要的话,你可以自己定义User的空白判断.你还可以使用结构体来构建更强大的数据类型,例如队列,然后为其实现所有相关的协议,例如Enumerable或Blank.

实现Any

手动实现对多有类型的协议是很繁琐和重复的.Elixir提供了两个选项:我们给自己的类型可以明确推导出协议的实现,或是为所有类型自动实现协议.无论哪种,我们都需要为Any实现协议.

Elixir允许我们基于Any的实现来派生一个协议实现.让我们先实现Any:

  1. defimpl Blank, for: Any do
  2. end

现在,当定义结构体时,我们能够精确地派生Blank协议的实现.让我们创造另一个结构体,名为DeriveUser:

  1. defmodule DeriveUser do
  2.   @derive Blank
  3.   defstruct name: "john", age: 27
  4. end

当派生的时候,Elixir会基于Any的实现来为DeriveUser实现Blank协议.注意这个行为是选择性加入:注意结构体的协议只可能是明确实现的或派生而来的.

回退到Any

当一个实现无法找到时,的替代方法是明确地告知协议回退到Any.通过在协议定义中将@fallback_to_any设置为true:

  2.   @fallback_to_any true
  3.   def blank?(data)
  4. end

假设我们已经像之前那样实现了Any:

  1. defimpl Blank, for: Any do
  2.   def blank?(_), do: false
  3. end

现在所有没有实现Blank协议的数据类型(包括结构体)都会被认为是非空白的.与相反,回退到Any是选择性退出的:所有数据都得到了一个预置的行为,除非它们提供了自己的协议实现.那种技术更好取决于使用场景,但Elixir开发者更趋向于使用显性定义,你能看到许多库使用@derive.

内置协议

Elixir装载了许多内置协议.在上一章,我们讨论了Enum模块,任何数据结构只要实现了Enumerable协议就可以使用模块中提供的函数:

  1. iex> to_string :hello
  2. "hello"

注意Elixir中的字符串插值调用了to_string函数:

  1. iex> "age: #{25}"
  2. "age: 25"

上述片段能够工作是因为数字实现了String.Chars协议.如果传送一个元组,就会出现错误:

  1. iex> tuple = {1, 2, 3}
  2. {1, 2, 3}
  3. iex> "tuple: #{tuple}"
  4. ** (Protocol.UndefinedError) protocol String.Chars not implemented for {1, 2, 3}

当需要”打印”一个更复杂的数据结构时,可以简单地使用基于Inspect协议的inspect函数:

  1. iex> "tuple: #{inspect tuple}"
  2. "tuple: {1, 2, 3}"

Inspect协议的作用是约定如何将任何数据结构转化为可读的文本表示.这就是IEx用来打印结果的工具:

  1. iex> {1, 2, 3}
  2. {1, 2, 3}
  3. iex> %User{}
  4. %User{name: "john", age: 27}

记住,处于方便,如果被检查后的值以#开头,这表明着该数据结构使用了非法的Elixir语法.这意味着检查协议是不可逆的,因为信息有可能在中途丢失:

Elixir中还有许多协议,但以上是最普遍的.

协议巩固

当使用Mix构建工具处理Elixir项目时,你可能会看到如下输出:

  1. Consolidated String.Chars
  2. Consolidated Collectable
  3. Consolidated List.Chars
  4. Consolidated IEx.Info
  5. Consolidated Enumerable
  6. Consolidated Inspect

这是Elixir中装载的所有协议,它们都被巩固了.由于一个协议可以被调度到任何数据类型,该协议必须检查每一个调用中给定类型的实现是否已经存在.这可能很复杂.

然而,我们的项目在使用类似Mix的工具编译过之后,就可以知道所有定义了的模块,包括协议和它们的实现.这样,协议就可以被巩固成一个非常简单快速的调度模块.