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
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
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。

你可能感兴趣的:(erlang,学习,笔记)