常用列表处理函数

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

member

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

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

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

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

  1. > lists:member(a,[1,2,a,b,c]).
  2. (0)lists:member(a,[1,2,a,b,c])
  3. (1).lists:member(a, [2,a,b,c])
  4. (2)..lists:member(a,[a,b,c])
  5. (2)..true
  6. (1).true
  7. (0)true
  8. true
  9. > lists:member(a,[1,2,3,4]).
  10. (0)lists:member(a, [1,2,3,4])
  11. (1).lists:member(a, [2,3,4])
  12. (2)..lists:member(a, [3,4])
  13. (3)...lists:member(a, [4])
  14. (4)....lists:member(a, [])
  15. (4)....false
  16. (3)...false
  17. (2)..false
  18. (1).false
  19. (0)false
  20. false

append

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

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

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

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

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

其求值结果为：

  1. [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的行为如下：

  1. > lists:append([a,b,c],[d,e,f]).
  2. (0)lists:append([a,b,c],[d,e,f])
  3. (1).lists:append([b,c], [d,e,f])
  4. (2)..lists:append([c],[d,e,f])
  5. (3)...lists:append([], [d,e,f])
  6. (3)...[d,e,f]
  7. (2)..[c,d,e,f]
  8. (1).[b,c,d,e,f]
  9. (0)[a,b,c,d,e,f]
  10. [a,b,c,d,e,f]

reverse

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

  1. reverse(L) -> reverse(L, []).
  2.  
  3. reverse([H|T], Acc) ->
  4.     reverse(T, [H|Acc]);
  5. reverse([], Acc) ->
  6.     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的第二个子句将被匹配并另函数结束。

整个过程如下：

  1. > lists:reverse([a,b,c,d]).
  2. (0)lists:reverse([a,b,c,d])
  3. (1).lists:reverse([a,b,c,d], [])
  4. (2)..lists:reverse([b,c,d], [a])
  5. (3)...lists:reverse([c,d], [b,a])
  6. (4)....lists:reverse([d], [c,b,a])
  7. (5).....lists:reverse([], [d,c,b,a])
  8. (5).....[d,c,b,a]
  9. (4)....[d,c,b,a]
  10. (3)...[d,c,b,a]
  11. (2)..[d,c,b,a]
  12. (1).[d,c,b,a]
  13. (0)[d,c,b,a]
  14. [d,c,b,a]

delete_all

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

  1. delete_all(X, [X|T]) ->
  2.     delete_all(X, T);
  3. delete_all(X, [Y|T]) ->
  4.     [Y | delete_all(X, T)];
  5. delete_all(_, []) ->
  6.     [].

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

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