常用列表处理函数
- 常用列表处理函数
  - member
  - append
  - reverse
  - delete_all

常用列表处理函数

以下各小节给出了一些简单列表处理函数的使用示例。这里所描述的所有函数都包含在标准Erlang发行版的lists模块中（细节参见附录C）。

member

member(X,L)在X是列表L的元素时返回true，否则返回false。

member(X, [X|_]) -> true;
member(X, [_|T]) -> member(X, T);
member(X, []) -> false.

member的第一个子句匹配的是X为列表的第一个元素的情况，这种情况下member返回true。如果第一个子句不匹配，则第二个子句将匹配第二个参数是非空列表的情况，这种情况下模式[_|T]匹配一个非空列表并将T绑定到列表的尾部，然后以原来的X及列表的尾部T递归调用member。member前两个子句就是在说当X是列表的第一个 元素（头部），或它被包含在列表的剩余部分（尾部）中时，X就是该列表的一个成员。member的第三个子句是说X不可能是空列表[]的成员，并因此返回false。

我们将member的求值过程列举如下：

> lists:member(a,[1,2,a,b,c]).
(0)lists:member(a,[1,2,a,b,c])
(1).lists:member(a, [2,a,b,c])
(2)..lists:member(a,[a,b,c])
(2)..true
(1).true
(0)true
true
> lists:member(a,[1,2,3,4]).
(0)lists:member(a, [1,2,3,4])
(1).lists:member(a, [2,3,4])
(2)..lists:member(a, [3,4])
(3)...lists:member(a, [4])
(4)....lists:member(a, [])
(4)....false
(3)...false
(2)..false
(1).false
(0)false
false

append

append(A,B)连接两个列表A和B。

append([H|L1], L2) -> [H|append(L1, L2)];
append([], L) -> L.

append的第二个子句再明白不过了——将任意列表L追加至空列表之后仍得到L。

第一个子句给出了追加一个非空列表到另一个列表之后的规则。因此，对于：

append([a,b,c], [d,e,f])

其求值结果为：

[a | append([b,c], [d,e,f])]

那么append([b,c],[d,e,f])的值又是多少呢？它（当然）是[b,c,d,e,f]，因此[a|append([b,c],[d,e,f])]的值就是[a|append([b,c],[d,e,f])]，这也是[a,b,c,d,e,f]的另一种写法。

append的行为如下：

> lists:append([a,b,c],[d,e,f]).
(0)lists:append([a,b,c],[d,e,f])
(1).lists:append([b,c], [d,e,f])
(2)..lists:append([c],[d,e,f])
(3)...lists:append([], [d,e,f])
(3)...[d,e,f]
(2)..[c,d,e,f]
(1).[b,c,d,e,f]
(0)[a,b,c,d,e,f]
[a,b,c,d,e,f]

reverse

reverse(L)用于颠倒列表L中的元素顺序。

reverse(L) -> reverse(L, []).

reverse([H|T], Acc) ->
    reverse(T, [H|Acc]);
reverse([], Acc) ->
    Acc.

reverse(L)利用一个辅助函数reverse/2将最终结果累积到第二个参数中。

调用reverse(L,Acc)时，若L是一个非空列表，则将L的第一个元素移除并添加到Acc的头部。因此对reverse([x,y,z],Acc)的调用将导致reverse([y,z],[x|Acc])的调用。最终reverse/2的第一个参数将归结为一个空列表，这时reverse/2的第二个子句将被匹配并另函数结束。

整个过程如下：

> lists:reverse([a,b,c,d]).
(0)lists:reverse([a,b,c,d])
(1).lists:reverse([a,b,c,d], [])
(2)..lists:reverse([b,c,d], [a])
(3)...lists:reverse([c,d], [b,a])
(4)....lists:reverse([d], [c,b,a])
(5).....lists:reverse([], [d,c,b,a])
(5).....[d,c,b,a]
(4)....[d,c,b,a]
(3)...[d,c,b,a]
(2)..[d,c,b,a]
(1).[d,c,b,a]
(0)[d,c,b,a]
[d,c,b,a]

delete_all

delete_all(X,L)用于删除列表L中出现的所有X。

delete_all(X, [X|T]) ->
    delete_all(X, T);
delete_all(X, [Y|T]) ->
    [Y | delete_all(X, T)];
delete_all(_, []) ->
    [].

delete_all所使用的递归模式与member和append类似。

delete_all的第一个子句在要删除的元素出现在列表的头部时匹配。