Elixir 简明笔记（十）--- 命名函数

程序由几行代码开始，逐渐变多之后，开发者期望一种结构化的方式组织代码。Elixir模块化代码很简单。你只需要将函数拆分写入模块中，当然Elixir中的函数（指命名函数，接下来除非特别指出匿名函数，否则所有函数都指命名函数）在模块中定义。

先看一个简单的例子。在你的目录中创建一个Elixir源文件times.exs

mm/times.exs

defmodule Times do
    def double(n) do
        n * 2
    end
end

我们定义了一个Times模块。该模块包含一个单独的double函数。该函数只有一个参数，在Elixir中，是通过参数的个数来区分不同模块的函数子句。例如上面的函数定义式是double/1

编译模块

有两种方式编译文件。第一种使用使用iex载入文件并编译：

$ iex times.exs
iex> Times.double 4
8

命令行中输入iex + 文件名就可以编译源文件并将编译结果的上下文载入iex提示界面。

如果你先进入了iex交互提示界面，可以使用c帮助函数进行编译。

iex> c "times.exs"
[Times]
iex> Times.double(4)
8
iex> Times.double(123)
246

这一行c "times.exs"代码将对源文件进行编译并载入编译后的程序。使用模块加函数名即可调用函数，即Times.double。

如果给函数传入一个整数将会发生什么呢？

iex> Times.double("cat")
** (ArithmeticError) bad argument in arithmetic expression
times.exs:3: Times.double/1

堆栈信息中可以看见发生了一个ArithmeticError异常，第一行告诉我们发生了什么错误。下一行告诉我们错误发生在什么地方。注意错误信息中是定义式Times.double/1描述出错的函数。

Elixir中通过函数名及其参数个数（arity）来识别不同的函数子句。double函数有一个参数，因此被标记为double/1。如果它有三个函数，则会被标注为double/3。无需为Elixir担心无法区分这两个函数。设想一下，如果有两个同名函数挨着，即使同名有不同的参数个数，对于人还是无法容易的分辨。为了避免这种情况，请尽量不用把不相关的函数使用相同的名字。

函数体也是一个块

do...end块是组织表达式和代码的一种方式。Elxir的模块和函数使用他们定义，控制代码结构，以及任何需要处理的代码体。

可是，do…end并不是基础语法。他们的本质是像这样的：

def double(n), do: n * 2

可以给do:提供任何使用小括号包裹的表达式。

def greet(greeting, name), do: (
    IO.puts greeting
    IO.puts "How're you doing, #{name}?"
)

do…end只是组织代码块的一个语法糖，他们都可以转换成do: from的形式（do: from本身并没有特别之处，只是一个简单的关键字列表）。人们习惯使用do: form语法来表示单行的代码块的时候，使用do…end组织多行代码块。

例如我们的例子其实可以改写一下：

mm/times1.exs

defmodule Times do
    def double(n), do: n * 2
end

甚至可以这么写：

defmodule Times, do: (def double(n), do: n*2)

（最好不好这样做，可读性不好）

函数调用及其模式匹配

前一章，我们了解了匿名函数式的参数是如果通过模式匹配将参数应用于函数体。这个规则对于命名函数也同样适用。不同的地方在于，命名函数需要写多个不同参数列表和函数体子句的函数。尽管看起来像是定义了多个函数，其实这是一个函数的多个子句而已。

当你调用一个命名函数的时候，Elixir会首先把你传入的参数和第一个函数子句进行模式匹配。只有前面的函数子句没有匹配，才会尝试和后面的函数子句进行匹配（记住，参数的个数必须和模式匹配相同）。直到匹配完所有的函数子句。

我们来玩一玩。编写一个从1到n的阶乘（n!）函数factorial。通常0!等于1。
类似数学语言的表达：

factorial(0) → 1
factorial(n) → n * factorial(n-1)

这是一个阶乘的伪代码，但是它已经和Elixir实现很接近了。

mm/factorial1.exs

defmodule Factorial do

    def of(0), do: 1
    def of(n), do: n * of(n-1)
end

这里我们定了两个同名的函数of。调用Factorial.of(2)，Elixir会用参数2与第一个of函数的参数模式进行匹配，0不匹配2，第一个函数匹配失败。然后，Elixir会把这个参数和第二个函数进行模式匹配n=2，匹配成功，然后把n传入该子句的函数体进行求值运算。其中由递归的调用of(2-1)。此时同样的的处理过程，还是第二个函数匹配调用，再接下来递归调用，Factorial.of(0)，此时则匹配第一个函数了。该函数执行返回1，直到递归回溯完毕。Elixir会自动回溯栈，将所有数字相乘法，然后返回答案。这个factorial模块实现了正常的功能，但是这段代码还可以使用尾递归优化提高。

先运行看看结果：

iex> c "factorial1.exs"
[Factorial]
iex> Factorial.of(3)
6
iex> Factorial.of(7)
5040
iex> Factorial.of(10)
3628800
iex> Factorial.of(1000)
40238726007709377354370243392300398571937486421071463254379991042993851239862
90205920442084869694048004799886101971960586316668729948085589013238296699445
...
00624271243416909004153690105933983835777939410970027753472000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000

Elixir中使用模式匹配设计和编程很普遍（几乎所有函数式语言都如此）。先来说一下最简单的情况下，一个过程有了明确的答案。将是解决问题的切入点。然后找一个递归解决方案，将这些过程集合处理。

更多的例子：

n个数的和
第一个0的和是0
第n个数的和又n-1个数的和与n相加。

列表的长度

空列表的长度是0

& 任何列表的长度都等于第一个元素的长度1加上剩余列表元素的长度

重要的知识点：将上面的语句用代码表达，将会写出多个子句函数。Elixir总是从最先定义的函数进行模式匹配。一旦前面的满足了要求，就不会往下匹配了。所有下面的代码将不会工作：

mm/factorial1-bad.exs

defmodule BadFactorial do
    def of(n), do: n * of(n-1)
    def of(0), do: 1
end

无论是什么参数，第一个函数子句都能匹配，第二个函数永远不会被执行。当然，出现这种情况，Elixir会在定义之后给出一个警告：

iex> c "factorial1-bad.exs"
.../factorial1-bad.ex:3: this clause cannot match because a previous clause at

卫子句

通过传入参数的模式匹配，Elixir可以选择匹配的函数调用。但是，当我们需要匹配的结果是基于不同类型或者是匹配特定的值的时候该怎么办呢？不用担心，Elixir提供了卫子句。这是通过关键字给函数定义添加谓词。当模式匹配的时候，Elxir首先会使用参数的模式匹配，然后在针对when关键字的子句进行逻辑判断，如果条件为真，才执行对于的函数子句。

mm/guard.exs

defmodule Guard do

    def what_is(x) when is_number(x) do
        IO.puts "#{x} is a number"
    end
    
    def what_is(x) when is_list(x) do
        IO.puts "#{inspect(x)} is a list"
    end

    def what_is(x) when is_atom(x) do
        IO.puts "#{x} is an atom"
    end
end

Guard.what_is(99) # => 99 is a number

Guard.what_is(:cat) # => cat is an atom

Guard.what_is([1,2,3]) # => [1,2,3] is a list

从新看看阶乘factorial模块

mm/factorial1.exs

defmodule Factorial do

    def of(0), do: 1

    def of(n), do: n * of(n-1)

end

如果我们传入一个负数，那么这段代码将会进入死循环，一直递归调用，永远不会满足递归结果的条件，即n等于0。因此我们可以通过卫子句对参数进行过滤，才能愉快的玩耍。

mm/factorial2.exs

defmodule Factorial do

    def of(0), do: 1

    def of(n) when n > 0 do
        n * of(n-1)
    end
end

此时调用的时候再传入负数，第二个匹配的函数将会执行卫子句检查，返回false将不会执行函数子句，即没有函数匹配。（没有函数匹配将会抛出异常）

iex> c "factorial2.exs"
[Factorial]
iex> Factorial.of -100
** (FunctionClauseError) no function clause matching in Factorial.of/1...


#### 卫子句的限制 

你只能写一些特定的Elixir表达式。下面的例子来自官方的Getting Started guide

* 比较操作符

    ==, !=, ===, !==, >, <, <=, >=

* 布尔操作符和取反操作符

    or, and, not, !.  注意：|| 和 && 是不能用的.

* 算术操作符

+, -, *, /

* 连接操作符

    <> and ++

* in操作符
    成员的集合和范围



### 类型检测函数


下面是一些内建类型检测函数，具体可以参考其官方文档。


* is_atom
* is_binary 
* is_bitstring 
* is_boolean 
* is_exception 
* is_float 
* is_function 
* is_integer 
* is_l
* ist 
* is_map 
* is_number 
* is_pid 
* is_port 
* is_record 
* is_reference 
* is_tuple


### 其他函数

下面的内建函数将返回参数的值，而不是`true` 或者 `false`

* abs(number) 
* bit_size(bitstring) 
* byte_size(bitstring) 
* div(number,number) 
* elem(tuple, n) 
* float(term) 
* hd(list) 
* length(list) 
* node() 
* node(pid|ref|port) 
* rem(number,number) 
* round(number) 
* self() 
* tl(list) 
* trunc(number) 
* tuple_size(tuple) 


### 默认参数


定义命名函数的时候，可以使用`\\`语法符给函数的参数设置默认值。调用函数的时候，如果该参数没有传值，则函数使用默认的参数。Elixir还会检测调用函数的时候所传入的参数个数，如果传入的参数少于必须参数，则不会匹配成功。如果正好满足必须的参数，那么必须参数则使用传入的参数进行匹配，其他的就使用其默认值。如果传入的参数个数大于必须参数的个数，那么就会匹配必须参数之后，覆盖默认参数的值。参数匹配是由左向右的。

mm/default_params.exs

```elixir
defmodule Example do

    def func(p1, p2 \\ 2, p3 \\ 3, p4) do
        IO.inspect [p1, p2, p3, p4]
    end
end

Example.func("a", "b") # => ["a",2,3,"b"]
Example.func("a", "b", "c") # => ["a","b",3,"c"]
Example.func("a", "b", "c", "d") # => ["a","b","c","d"]

Elixir模式匹配的时候，默认参数有惊人的表现。录入，编译下面代码：

def func(p1, p2 \\ 2, p3 \\ 3, p4) do
    IO.inspect [p1, p2, p3, p4]
end

def func(p1, p2) do
    IO.inspect [p1, p2]
end

你会得到错误：

** (CompileError) default_params.exs:7: def func/2 conflicts with
defaults from def func/4

因为第一个函数子句的定义（带有默认参数），无论参数是两个，三个还是四个，几乎可以匹配任何第二个函数子句的模式。也就是第二个函数永远不会被匹配。

对于默认函数，还有一点需要知道。下面一个函数两个函数头（双函数子句）的情况，只不过另外一个写清楚了默认值：

mm/default_params1.exs

defmodule DefaultParams1 do

    def func(p1, p2 \\ 123) do
        IO.inspect [p1, p2]
    end


    def func(p1, 99) do
        IO.puts "you said 99"
    end
end

编译会报错(两个子句都有默认的参数了)：

** (CompileError) default_params1.exs.exs:8: def func/2 has default
values and multiple clauses, define a function head

使用默认参数

为了降低默认值带来的函数冲突。会把带有默认参数定义写在函数的头部，只需要声明却不写函数体。剩下的函数子句就使用正常的参数。下面的例子中，默认参数的声明写在了头部，这个规则使用下面两个函数的子句。

mm/default_params2.exs

defmodule Params do

    def func(p1, p2 \\ 123)

    def func(p1, p2) when is_list(p1) do

        "You said #{p2} with a list"
    end

    def func(p1, p2) do

        "You passed in #{p1} and #{p2}"
    end
end

IO.puts Params.func(99)             # You passed in 99 and 123 
IO.puts Params.func(99, "cat")      # You passed in 99 and cat
IO.puts Params.func([99])           # You said 123 with a list
IO.puts Params.func([99], "dog")    # You said dog with a list

上面的定义，其实等价于（只不过把默认参数提取出来了）：

defmodule Params do
    def func(p1, p2 \\ 123) when is_list(p1) do

        "You said #{p2} with a list"
    end

    def func(p1, p2 \\ 123) do

        "You passed in #{p1} and #{p2}"
    end
end

私有函数

defp宏可以定义声明一个私有函数，私有函数只能在声明它的模块内部调用。

也可以定义多个私有函数，就像使用def定义函数一样。可是，不能定义参数一致的同名公有和私有函数。正如下面是非法的：

def fun(a) when is_list(a), do: true

defp fun(a), do: false

最后编辑于：2017.11.27 05:42:56

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 213,752评论 6赞 493
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,100评论 3赞 387
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 159,244评论 0赞 349
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,099评论 1赞 286
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,210评论 6赞 385
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,307评论 1赞 292
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,346评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,133评论 0赞 269
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,546评论 1赞 306
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,849评论 2赞 328
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,019评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,702评论 4赞 337
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,331评论 3赞 319
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,030评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,260评论 1赞 267
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,871评论 2赞 365
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,898评论 2赞 351