8-模块

编译
脚本模式
命名函数
函数捕捉
默认参数

Elixir中我们把许多函数组织成一个模块。我们在前几章已经提到了许多模块，
如String模块：

  1. iex> String.length "hello"
  2. 5

创建自己的模块，用defmodule宏。用def宏在其中定义函数：

  1. iex> defmodule Math do
  2. ...>   def sum(a, b) do
  3. ...>     a + b
  4. ...>   end
  5. ...> end
  7. iex> Math.sum(1, 2)
  8. 3

像ruby一样，模块名大写起头

8.1-编译

通常把模块写进文件，这样可以编译和重用。假如文件math.ex有如下内容：

  1. defmodule Math do
  2.   def sum(a, b) do
  3.     a + b
  4.   end
  5. end

这个文件可以用elixirc进行编译：

  1. $ elixirc math.ex

这将生成名为Elixir.Math.beam的bytecode文件。
如果这时再启动iex，那么这个模块就已经可以用了（假如在含有该编译文件的目录启动iex）：

  1. iex> Math.sum(1, 2)
  2. 3

Elixir工程通常组织在三个文件夹里：

  • ebin，包括编译后的字节码
  • lib，包括Elixir代码（.ex文件）
  • test，测试代码（.exs文件）

实际项目中，构建工具Mix会负责编译，并且设置好正确的路径。
而为了学习方便，Elixir也提供了脚本模式，可以更灵活而不用编译。

8.2-脚本模式

除了.ex文件，Elixir还支持.exs脚本文件。
Elixir对两种文件一视同仁，唯一区别是.ex文件会保留编译执行后产出的比特码文件，
而.exs文件用来作脚本执行，不会留下比特码文件。例如，如下创建名为math.exs的文件：

  1. defmodule Math do
  2.   def sum(a, b) do
  3.     a + b
  4.   end
  5. end
  7. IO.puts Math.sum(1, 2)

执行之： 

  1. $ elixir math.exs

像这样执行脚本文件时，将在内存中编译和执行，打印出“3”作为结果。没有比特码文件生成。
后文中（为了学习和练习方便），推荐使用脚本模式执行学到的代码。

8.3-命名函数

在某模块中，我们可以用def/2宏定义函数，用defp/2定义私有函数。
用def/2定义的函数可以被其它模块中的代码使用，而私有函数仅在定义它的模块内使用。

  1. defmodule Math do
  2.   def sum(a, b) do
  3.     do_sum(a, b)
  4.   end
  6.   defp do_sum(a, b) do
  7.     a + b
  8.   end
  9. end
  11. Math.sum(1, 2)    #=> 3
  12. Math.do_sum(1, 2) #=> ** (UndefinedFunctionError)

函数声明也支持使用卫兵或多个子句。
如果一个函数有好多子句，Elixir会匹配每一个子句直到找到一个匹配的。
下面例子检查参数是否是数字：

  1. defmodule Math do
  2.   def zero?(0) do
  3.     true
  4.   end
  6.   def zero?(x) when is_number(x) do
  7.     false
  8.   end
  9. end
  11. Math.zero?(0)  #=> true
  12. Math.zero?(1)  #=> false
  14. Math.zero?([1,2,3])
  15. #=> ** (FunctionClauseError)

如果没有一个子句能匹配参数，会报错。

8.4-函数捕捉

本教程中提到函数，都是用name/arity的形式描述。
这种表示方法可以被用来获取一个命名函数（赋给一个函数型变量）。
下面用iex执行一下上文定义的math.exs文件：

  1. $ iex math.exs
  1. iex> Math.zero?(0)
  2. true
  3. iex> fun = &Math.zero?/1
  4. &Math.zero?/1
  5. iex> is_function fun
  6. true
  7. iex> fun.(0)
  8. true

用&<function notation>通过函数名捕捉一个函数，它本身代表该函数值（函数类型的值）。
它可以不必赋给一个变量，直接用括号来使用该函数。

本地定义的，或者已导入的函数，比如is_function/1，可以不用前缀模模块名：

  1. iex> &is_function/1
  2. &:erlang.is_function/1
  3. iex> (&is_function/1).(fun)
  4. true

这种语法还可以作为快捷方式来创建和使用函数：

  1. iex> fun = &(&1 + 1)
  2. #Function<6.71889879/1 in :erl_eval.expr/5>
  3. iex> fun.(1)
  4. 2

代码中&1 表示传给该函数的第一个参数。
因此，&(&1+1)其实等同于fn x->x+1 end。在创建短小函数时，这个很方便。
想要了解更多关于&捕捉操作符，参考Kernel.SpecialForms文档。

8.5-默认参数

Elixir中，命名函数也支持默认参数：

  1. defmodule Concat do
  2.   def join(a, b, sep \\ " ") do
  3.     a <> sep <> b
  4.   end
  5. end
  7. IO.puts Concat.join("Hello", "world")      #=> Hello world
  8. IO.puts Concat.join("Hello", "world", "_") #=> Hello_world

任何表达式都可以作为默认参数，但是只在函数调用时 用到了 才被执行。
（函数定义时，那些表达式只是存在那儿，不执行；函数调用时，没有用到默认值，也不执行）。

  1. defmodule DefaultTest do
  2.   def dowork(x \\ IO.puts "hello") do
  3.     x
  4.   end
  5. end
  1. iex> DefaultTest.dowork 123
  2. 123
  3. iex> DefaultTest.dowork
  4. hello
  5. :ok

如果有默认参数值的函数有了多条子句，推荐先定义一个函数头（无具体函数体）声明默认参数：

  1. defmodule Concat do
  2.   def join(a, b \\ nil, sep \\ " ")
  4.   def join(a, b, _sep) when is_nil(b) do
  5.     a
  6.   end
  8.   def join(a, b, sep) do
  9.     a <> sep <> b
  10.   end
  11. end
  13. IO.puts Concat.join("Hello", "world")      #=> Hello world
  14. IO.puts Concat.join("Hello", "world", "_") #=> Hello_world
  15. IO.puts Concat.join("Hello")               #=> Hello

使用默认值时，注意对函数重载会有一定影响。考虑下面例子：

  1. defmodule Concat do
  2.   def join(a, b) do
  3.     IO.puts "***First join"
  4.     a <> b
  5.   end
  7.   def join(a, b, sep \\ " ") do
  8.     IO.puts "***Second join"
  9.     a <> sep <> b
  10.   end
  11. end

如果将以上代码保存在文件“concat.ex”中并编译，Elixir会报出以下警告：

  1. concat.ex:7: this clause cannot match because a previous clause at line 2 always matches

编译器是在警告我们，在使用两个参数调用join函数时，总使用第一个函数定义。
只有使用三个参数调用时，才会使用第二个定义：

  1. $ iex concat.exs
  1. iex> Concat.join "Hello", "world"
  2. ***First join
  3. "Helloworld"
  4. iex> Concat.join "Hello", "world", "_"
  5. ***Second join
  6. "Hello_world"

后面几章将介绍使用命名函数来做循环，如何从别的模块中导入函数，以及模块的属性等。