erlang （Lists 操作模块）学习笔记

all

1> lists:all(fun(X)->X<4 end,[1,2,3]).
true
2> lists:all(fun(X)->X<4 end,[1,2,3,4]).
false

all（Pred， List）-> boolean()

如果 Pred（Elem）对 List 中的所有元素 Elem 返回 true，则返回 true，否则返回 false。Pred 函数必须返回布尔值。

any

3>lists:any(fun(X)->X<4 end,[1,2,3,4]).
true
4>lists:any(fun(X)->X<4 end,[4,5]).    
false

all（Pred， List）-> boolean()

如果 Pred（Elem）对列表中的至少一个元素 Elem 返回 true，则返回 true。Pred 函数必须返回一个布尔。

append

5> lists:append([[1, 2, 3], [a, b], [4, 5, 6]]).
[1,2,3,a,b,4,5,6]
6> lists:append("abc", "def").
"abcdef"

append（ListOfLists） -> List1

返回一个列表，其中追加了 ListOfLists 的所有子列表。

append（List1， List2） -> List3

返回一个新列表 List3，该列表由 List1 的元素后跟 List2 的元素。

concat

7> lists:concat([doc, '/', file, '.', 3]).
"doc/file.3"

concat（事物）-> string()

连接事物元素的文本表示形式。Things 的元素可以是原子、整数、浮点数或字符串。

delete

40> lists:delete(1,[1,2,3,4]).                          
[2,3,4]
41> lists:delete(1,[2,3,4]).  
[2,3,4]

delete（Elem， List1） -> List2

返回 List1 的副本，其中第一个元素匹配的 Elem 将被删除，如果有这样的元素。

droplast

8> lists:droplast([1,2,3,4]).               
[1,2,3]
9> lists:droplast([]).       
** exception error: no function clause matching lists:droplast([]) (lists.erl, line 218)

droplast（列表） -> 初始化列表

删除 List 的最后一个元素。该列表是为非空，否则函数崩溃并出现function_clause。

dropwhile

10> lists:dropwhile(fun(X)->X<4 end,[1,2,3,4,5,6,7]).
[4,5,6,7]

dropwhile（Pred， List1） -> List2

从 List1 中删除元素 Elem，而 Pred（Elem）返回 true 和返回剩余列表。Pred 函数必须返回一个布尔。

duplicate

11> lists:duplicate(5,hello).                        
[hello,hello,hello,hello,hello]

duplicate（N， Elem） ->列表

返回包含术语 Elem 的 N 个副本的列表。

filter

13> lists:filter(fun(X)->X<4 end,[1,2,3,4,5,6,7,8]).
[1,2,3]

filter（Pred， List1） -> List2

List2 是 List1 中 Elem 的所有元素的列表，Pred（Elem）为其返回 true。 Pred 函数必须返回布尔值.

filtermap

14> lists:filtermap(fun(X)->X<4 end,[1,2,3,4,5,6,7,8]).
[1,2,3]
15> lists:filtermap(fun(X) -> case X rem 2 of 0 -> {true, X div 2}; _ -> false end end, [1,2,3,4,5]).
[1,2]

filtermap（Fun， List1） -> List2

连续调用 Fun（Elem）元素 Elem of List1.Fun/1 必须返回布尔值或元组 {true， Value}。该函数返回元素，其中 Fun 返回一个新值，其中值 true 与 {true， Elem} 同义。

flatlength

16> lists:flatlength([1,[1,2,[3,4,8]],3,4,5,6]).                                
10

flatlength（DeepList）-> Integer() >= 0

等效于 length（flatten（DeepList）），但效率更高。

flatmap

17>  lists:flatmap(fun(X)->[X,X] end, [a,b,c]).
[a,a,b,b,c,c]

flatmap（Fun， List1） -> List2

将函数从 A s 转换为 B的列表，以及 A的列表（List1），并通过将函数应用于 List1 中的每个元素并附加结果列表来生成 B列表。

flatten

18> lists:flatten([1,[1,2,[3,4,8]],3,4,5,6]). 
[1,1,2,3,4,8,3,4,5,6]
19> lists:flatten([1,[1,2,[3,4,8]],3,4,5,6],[8,34,11]).
[1,1,2,3,4,8,3,4,5,6,8,34,11]

flatten（DeepList） ->列表

返回 DeepList 的平展版本。

flatten（DeepList， tail） ->列表

返回 DeepList 的扁平化版本，并追加了 tail Tail。

foldl 和 fold

20> lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1,2,3,4,5]).
15
21> lists:foldl(fun(X, Prod) -> X * Prod end, 1, [1,2,3,4,5]).
120
22> P = fun(A, AccIn) -> io:format("~p ", [A]), AccIn end.
#Fun<erl_eval.43.65746770>
23> lists:foldl(P, void, [1,2,3]).
1 2 3 void
24> lists:foldr(P, void, [1,2,3]).
3 2 1 void

foldl（Fun， Acc0， List） -> Acc1

在列表的连续元素 A 上调用 Fun（Elem， AccIn），开始使用 AccIn == Acc0。Fun/2 必须返回一个新的累加器，它是传递到下一个调用。该函数返回蓄能器。如果列表为空。

foldr（Fun， Acc0， List） -> Acc1

像foldl/3一样，但列表从右到左遍历。

foldl/3 是尾递归的，通常优于 foldr/3。

join

25> lists:join(x, [a,b,c]).
[a,x,b,x,c]
26> lists:join(x, [a]).    
[a]
27> lists:join(x, []). 
[]

join（Sep， List1） -> List2

在 List1 中的每个元素之间插入 Sep。没有对空列表和单一实例列表的影响。

keydelete

28> lists:keydelete(1,1,[{1,hello},{2,key},{3,value}]).
[{2,key},{3,value}]
29> lists:keydelete(1,1,[{2,key},{3,value}]).          
[{2,key},{3,value}]

keydelete（Key， N， TupleList1） -> TupleList2

返回 TupleList1 的副本，其中第一个出现第 N个元素比较的元组等于 Key，如果存在这样的元组，则删除。

keyfind

30> lists:keyfind(1,1,[{1,hello},{2,key},{3,value}]).  
{1,hello}
31> lists:keyfind(1,1,[{2,key},{3,value}]).          
false

keyfind（Key， N， TupleList） ->元组 |假

在元组 TupleList 列表中搜索第 N个元素比较等于 Key 的元组。如果找到这样的元组，则返回元组，否则为 false。

keymap

32> Fun = fun(Atom) -> atom_to_list(Atom) end.
#Fun<erl_eval.44.65746770>
33> lists:keymap(Fun, 2, [{name,jane,22},{name,lizzie,20},{name,lydia,15}]).
[{name,"jane",22},{name,"lizzie",20},{name,"lydia",15}]

keymap（Fun， N， TupleList1） -> TupleList2

返回一个元组列表，其中，对于 TupleList1 中的每个元组，元组的第 N个元素 Term1 已替换为调用 Fun（Term1）的结果。

keymember

34> lists:keymember(1,1,[{1,hello},{2,key},{3,value}]).                     
true
35> lists:keymember(1,1,[{2,key},{3,value}]).          
false

keymember（Key， N， TupleList） ->boolean()

如果 TupleList 中有一个元组，其第 N个元素，则返回 true compares 等于 Key，否则为 false。

keymerge

36> lists:keymerge(1,[{2,key},{3,value}],[{1,hello},{2,tuple},{3,none}]).
[{1,hello},{2,key},{2,tuple},{3,value},{3,none}]

keymerge（N， TupleList1， TupleList2） -> TupleList3

返回通过合并 TupleList1 和 TupleList2 形成的排序列表。合并是在每个元素的第 N个元素上执行的元。在计算之前，必须对 TupleList1 和 TupleList2 进行键排序此功能。当两个元组比较相等时，在 TupleList1 中的元组之前选取 TupleList2 中的元组。

keyreplace

38> lists:keyreplace(2,1,[{2,key},{3,value}],{1,hello}). 
[{1,hello},{3,value}]
39> lists:keyreplace(1,1,[{2,key},{3,value}],{1,hello}).
[{2,key},{3,value}]

keyreplace（Key， N， TupleList1， NewTuple） -> TupleList2

返回 TupleList1 的副本，其中第一个出现一个 T 元组，其第 N个元素如果存在这样的元组 T，则将等于 Key 替换为 NewTuple。

m0_62961827