erlang lists 系列函數功能與用法詳解（共68個函數）

 [置頂] erlang lists 系列函數功能與用法詳解（共68個函數）

一，帶函數Pred

1, all(Pred, List) -> boolean()

若是List中的每一個元素做爲Pred函數的參數執行，結果都返回true，那麼all函數返回true，

不然返回false

例子：

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

結果

true

2, any(Pred, List) -> boolean()

若是List中至少有一個元素做爲Pred函數的參數執行，結果返回true，那麼any函數返回true，

不然返回false

例子

lists:any(fun(E) -> is_integer(E) end,[q,2,a,4]).

結果

true

 

3，dropwhile(Pred, List1) -> List2

將List1列表中的元素做爲參數執行Pred函數，若是返回true，將其丟棄，最後返回剩餘元素

組成的列表

例子

lists:dropwhile(fun(E) -> is_atom(E) end,[a,1,2,a,b]).

結果

[1,2,a,b]

4，filter(Pred, List1) -> List2

返回一個列表，這個列表是由List1中執行Pred函數返回true的元素組成。

lists:filter(fun(E) -> is_integer(E) end,[q,2,a,4]).

結果：

[2,4]

 

5，map(Fun, List1) -> List2

將List1中的每一個元素去在Fun中執行，而後返回一個元素，最後返回的這些元素組成一個列表，

返回給List2

例子：

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

結果：[[a,a],[b,b],[c,c]]

 

6，flatmap(Fun, List1) -> List2

這個函數和map比較相似，至關於執行了

lists:append(lists:map(List1)).

也就是把map的結果進行append處理

例子：

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

結果：[a,a,b,b,c,c]

 

7，foldl(Fun, Acc0, List) -> Acc1

Fun這個函數有兩個參數

第一個參數是List中的元素，第二個參數是Fun函數執行完後的返回值，這個參數第一次執行時

就是Acc0

例子：對[1,2,3,4,5]求和

lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1,2,3,4,5]).

結果：15

執行過程：首先，Fun第一次執行時，X的值取列表List的第一個元素1，Sum取0,

  Fun第二次執行時，X的值取列表List的第二個元素2，Sum取Fun第一次的返回值

  依次輪推，直到List中每一個元素執行完，最後foldl返回最後一次的結果。

 

8，foldr(Fun, Acc0, List) -> Acc1

foldr這個函數和foldl比較類似

不過是Fun執行時，X的值先取List的最後一個，而後取倒數第二個。

 

9，foreach(Fun, List) -> ok

以List中的每一個元素爲參數執行Fun函數，執行順序按照List中元素的順序，這個函數最後返回ok。是單邊的

例子 lists:foreach(fun(X)->

  %%using X to do somethings 

  %%

  end,List)

 

10，keymap(Fun, N, TupleList1) -> TupleList2

對TupleList1中的每一個元素的第N項做爲參數在Fun中處理，而後這個第N項最後就被替換爲Fun執行完返回的值

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"}].

lists:keymap(fun(X)-> 

  list_to_atom(X) 

  end,2,List1).

結果：

[{name,zhangjing},{name,zhangsan}]

 

11，mapfoldl(Fun, Acc0, List1) -> {List2, Acc1}

這個函數等因而把map和foldl函數結合起來。將List1中的每個元素執行Fun函數，執行後花括號的第一個值做爲返回值返回，

第二個值做爲參數傳給Fun，做爲下一次用。

例子：

lists:mapfoldl(fun(X, Sum) -> {2*X, X+Sum} end,

0, [1,2,3,4,5]).

{[2,4,6,8,10],15}

 

12，mapfoldr(Fun, Acc0, List1) -> {List2, Acc1}

這個函數至關於將map和foldr結合起來

13，merge(Fun, List1, List2) -> List3

這個函數的功能也是把List1和List2合併到一塊兒，只不過是List1和List2的元素要做爲參數在Fun中執行，若是

Fun返回true，那麼返回值就是List1在前，List2在後。不然，反之。

例子

lists:merge(fun(A,B)-> false end, [3,4],[2,1]).

結果

[2,1,3,4]

 

14，partition(Pred, List) -> {Satisfying, NotSatisfying}

這個函數的功能是將List分紅兩個List1和List2，List1是將List元素做爲參數去Pred函數中執行返回true的元素組成，

List2由Pred返回false的元素組成。

注意，返回的是一個元組

例子

lists:partition(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).

結果

{[1,3,5,7],[2,4,6]}

15，sort(Fun, List1) -> List2

若是Fun函數返回true，則排序是從小到大的順序，不然，從大到小。

其中Fun有兩個參數。

例子

lists:sort(fun(A,B)-> false end,[1,2,3]).

結果

[3,2,1]

能夠看獲得A,B的值是依次去兩個值，這樣咱們能夠本身比較這兩個數。

不管三個數大小如何排列，我都讓其從大到小

16，splitwith(Pred, List) -> {List1, List2}

將List分紅List1和List2，

List1由List中元素在Pred函數返回true的組成，可是有一點，若是遇到爲false的，則將剩下的元素

所有放到List2中，List1中就只有前面爲true的。

例子

lists:splitwith(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).

結果

{[a,b],[1,c,d,2,3,4,e]}

17，takewhile(Pred, List1) -> List2

List1中的元素element依次執行Pred(element),若是返回true，則獲取這個元素，直到有元素執行Pred(element)返回false

例子

lists:takewhile(fun(E)-> is_atom(E) end,[a,b,1,e,{c},[d]]).

結果

[a,b]

18,umerge(Fun, List1, List2) -> List3

這個函數和merge不一樣的是 當Fun返回true時，返回的List3中不能出現相同的元素

疑問：可是當Fun返回false時，List3中能夠有相同的元素。

例子(Fun返回true的狀況)

lists:umerge(fun(A,B)-> true end,[1,2],[2,3]).

結果

[1,2,3]

(Fun爲false的狀況)

lists:umerge(fun(A,B)-> false end,[1,2],[2,3]).

[2,3,1,2]

好神奇，居然2有重複

 

19，usort(Fun, List1) -> List2

按照Fun函數進行排序，若是Fun返回true，那麼只返回List1的第一個元素

若是Fun返回false，那麼List1從大到小排序

例子1

lists:usort(fun(A,B) -> true end, [1,2,2,3,4]).

結果

[1]

例子2

lists:usort(fun(A,B) -> false end, [1,2,2,3,4]).

結果

[4,3,2,2,1]

20，zipwith(Combine, List1, List2) -> List3

將List1和list2中的每一個元素執行Combine函數，而後返回一個元素，List3就是由Combine函數返回的一個個元素組成的。

功能和map有點像，可是這裏是對兩個列表的操做。

例子

lists:zipwith(fun(X, Y) -> X+Y end, [1,2,3], [4,5,6]).

結果

[5,7,9]

 

21，zipwith3(Combine, List1, List2, List3) -> List4

將List1和list2，list3中的每一個元素執行Combine函數，而後返回一個元素，List4就是由Combine函數返回的一個個元素組成的。

功能和map有點像，可是這裏是對三個列表的操做。

例子

lists:zipwith3(fun(X, Y, Z) -> X+Y+Z end, [1,2,3], [4,5,6],[7,8,9]).

結果

[12,15,18]

 

二，不帶函數Pred

1，append(ListOfLists) -> List1

ListOfLists都是由List組成的，而List一個列表，裏面能夠是任何類型的元素

這個函數就是將ListOfLists裏面的全部列表的元素按順序編成一個列表

提示：ListOfLists裏面的元素必須都是列表才能用這個函數

例子

lists:append([[1, 2, 3], [a, b], [4, 5, 6]]).

結果：

[1,2,3,a,b,4,5,6]

2，append(List1, List2) -> List3

將List1和List2兩個列表鏈接起來，組成一個列表，而後返回新的這個列表

這個函數的功能等同於List1 ++ List2

例子

lists:append("abc", "def").

結果

"abcdef"

 

3，concat(Things) -> string()

這裏的Things是一個列表，裏面由atom() | integer() | float() | string()

將這個列表裏面的元素拼成一個字符串，而後返回

例子

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

結果

doc/file.3"

 

4，delete(Elem, List1) -> List2

List1是由不少Element組成的，這個函數的功能是在List1中尋找第一個和Elem元素同樣的，

而後刪除之，返回刪除後新的列表。

例子

lists:delete({name,"zhangsan"},[{name,"lisi"},{name,"zhangsan"},{name,"wangmazi"})).

結果

[{name,"lisi"},{name,"wangmazi"}]

 

5，duplicate(N, Elem) -> List

返回一個由N個Elem組成的列表。

例子

lists:duplicate(5,"test").

結果

["test","test","test","test","test"]

 

6，flatlength(DeepList) -> integer() >= 0

個人理解是DeepList就是列表裏面套列表

計算列表的長度，即用flatten函數將DeepList轉化成List後元素的個數

這個函數和length()的區別就是：

length函數是獲得列表元素的個數，

而flatlength函數是先將DeepList轉化成List後的個數

譬如說List = [1,2,[3,4]]這個列表用

length(List)求的值是：3

lists:flatlength(List)求的值是：4

其實lists:flatlength(List) = length(flatten(List))

7，flatten(DeepList) -> List

將DeepList變成只有term()的list

例子：

lists:flatten([[a,a],[b,b],[c,c]]).

結果：

[a,a,b,b,c,c]

 

8，flatten(DeepList, Tail) -> List

就是將DeepList變成只有term的List後，在後面再加一個Tail。

例子：

lists:flatten([[a,a],[b,b],[c,c]],[dd]).

結果：

[a,a,b,b,c,c,dd]

 

9,keydelete(Key, N, TupleList1) -> TupleList2

這個函數適合處理列表裏面的元素是元組的狀況

刪除TupleList1中元素第N個元素和Key一致的元素，只刪除第一個同樣的，後面同樣的不刪除

例子：

List = [{name,"zhangjing"},{sex,"male"},{name,"zhangsan"},{sex,"male"}],

lists:keydelete("male",2,List)

結果：

[{name,"zhangjing"},{name,"zhangsan"},{sex,"male"}]

 

10,keyfind(Key, N, TupleList) -> Tuple | false

查找TupleList中的一個Tuple，若是查找到，返回，若是沒有查找到，則返回false

這個Tuple必須知足第N個元素和key是同樣。

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"}].

lists:keyfind("zhangjing",2,List1)

結果：{name,"zhangjing"}

 

11，keymember(Key, N, TupleList) -> boolean()

若是TupleList中的元素中存在第N個元素和key一致，則返回true，不然返回false

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"}].

lists:keymember("zhangjing",2,List1).

結果：true

 

12，keymerge(N, TupleList1, TupleList2) -> TupleList3

將TupleList1和TupleList2進行混合，組成一個TupleList，

新組成的TupleList是按照Tuple的第N個元素進行排序的

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"}].

List2 = [{nick,"zj"},{nick,"zs"}].

lists:keymerge(2,List1,List2).

結果：

[{name,"zhangjing"},

 {name,"zhangsan"},

 {nick,"zj"},

 {nick,"zs"}]

 

13，keyreplace(Key, N, TupleList1, NewTuple) -> TupleList2

在TupleList1的Tuple中找出第N個元素和Key一致，而後用NewTuple將這個Tuple替換掉，若是沒有找到

，則返回原來的TupleList1

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"}]

lists:keyreplace("zhangjing",2,List1,{nickname,"netzj"}).

結果：

[{nickname,"netzj"},{name,"zhangsan"}]

 

14，keysearch(Key, N, TupleList) -> {value, Tuple} | false

這個函數和keyfind差很少，就是返回值的結構不同

也是在TupleList中找一個Tuple，這個Tuple的第N個元素和Key同樣。

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"}]

lists:keysearch("zhangjing",2,List1).

結果：

{value,{name,"zhangjing"}}

 

15，keysort(N, TupleList1) -> TupleList2

對TupleList1中的Tuple按照第N個元素進行排序，而後返回一個新的順序的TupleList。

不過這種排序是固定的。

例子：

List1 = [{name,"zhangsan"},{name,"zhangjing"}].

lists:keysort(2,List1).

結果：

[{name,"zhangjing"},{name,"zhangsan"}]

 

16，keystore(Key, N, TupleList1, NewTuple) -> TupleList2

這個函數和keyreplace函數比較像，不一樣的是，這個keystore在沒有找到對應的Tuple時，

會將這個NewTuple追加在這個TupleList1的最後。

例子：

List1 = [{name,"zhangsan"},{name,"zhangjing"}].

找到了的狀況

lists:keystore("zhangjing",2,List1,{name,"netzhangjing"}).

[{name,"netzhangjing"},{name,"zhangsan"}]

沒有找到的狀況

lists:keystore("zhanging",2,List1,{name,"netzhangjing"}).

[{name,"zhangjing"},{name,"zhangsan"},{name,"netzhangjing"}]

 

17，keytake(Key, N, TupleList1) -> {value, Tuple, TupleList2} | false

在TupleList1中找Tuple，這個Tuple的第N個元素和Key一致，若是找到了這麼一個Tuple

那麼返回，{value, Tuple, TupleList2} 其中TupleList2是去掉Tuple的TupleList1.

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"},{name,"lisi"}].

lists:keytake("zhangjing",2,List1).

結果：

{value,{name,"zhangjing"},[{name,"zhangsan"},{name,"lisi"}]}

 

18，last(List) -> Last

返回：List最後一個元素

例子：

List1 = [{name,"zhangjing"},{name,"zhangsan"},{name,"lisi"}].

lists:last(List1).

結果：

{name,"lisi"}

 

19，max(List) -> Max

取出List中最大的元素，通常List是整型時比較適合。

例子：

lists:max([1,10,15,6]).

結果：

15

 

20，member(Elem, List) -> boolean()

若是Elem和List中的某個元素匹配（相同），那麼返回true，不然返回false

例子

lists:member({sex,"1"},[{sex,"1"},{sex,"2"},{sex,"3"}]).

結果：

true

21，merge(ListOfLists) -> List1

ListOfLists是一個列表，裏面由子列表構成

這個函數的功能就是將這些子列表合併成一個列表。

例子：

lists:merge([[{11}],[{22}],[{33}]]).

結果

[{11},{22},{33}]

 

22，merge(List1, List2) -> List3

List1和List2分別是一個列表，這個函數的功能是將這兩個列表合併成一個列表。

例子：

lists:merge([11],[22]).

結果

[11,22]

[2,1,3,4]

23, merge3(List1, List2, List3) -> List4

將List1，List2，List3合併成一個列表

例子

lists:merge3([11],[22],[33,44]).

結果：

[11,22,33,44]

 

24，min(List) -> Min

返回List中的最小的元素，和max函數對應

例子

lists:min([1,2,3]).

結果

1

 

25，nth(N, List) -> Elem

返回List中的第N個元素。

例子

lists:nth(2,[{name,"zhangsan"},{name,"lisi"},{name,"wangmazi"}]).

結果

{name,"lisi"}

 

26，nthtail(N, List) -> Tail

返回List列表中第N個元素後面的元素

例子

lists:nthtail(3, [a, b, c, d, e]).

結果

[d,e]

27，prefix(List1, List2) -> boolean()

若是List1是List2的前綴(也就是說List1和List2前部分相同)，那麼返回true，不然返回false

28，reverse(List1) -> List2

將List1反轉

例子

lists:reverse([1,2,3,4]).

結果

[4,3,2,1]

 

29,reverse(List1, Tail) -> List2

將List1反轉，而後將Tail接在反轉List1的後面，而後返回

例子

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

[4,3,2,1,a,b,c]

 

30，seq(From, To) -> Seq

其中From和To都是整型，這個函數返回一個從From到To的一個整型列表。

例子

lists:seq(1,10).

結果

[1,2,3,4,5,6,7,8,9,10]

 

31，seq(From, To, Incr) -> Seq

返回一個整型列表，這個列表的後一個元素比前一個元素大Incr。

例子

lists:seq(1,10,4).

[1,5,9]

 

32，sort(List1) -> List2

將List1中的元素從小到大排序，而後返回新的一個列表。

例子

lists:sort([3,2,1]).

結果

[1,2,3]

33，split(N, List1) -> {List2, List3}

將List1分紅List2和List3

其中List2包括List1的前N個元素，List3包含剩餘的。

例子

lists:split(3,[1,2,3,4,5]).

結果

{[1,2,3],[4,5]}

這個函數和partition數有區別，partition是遍歷所有的List，而splitwith在遍歷時遇到false的狀況

則立刻結束遍歷，返回結果。

34，sublist(List1, Len) -> List2

返回從第一個元素到第Len個元素的列表，這個Len大於List1的長度時，返回所有。

例子

lists:sublist([1,2,3,4,5,6],3).

結果

[1,2,3]

 

35，sublist(List1, Start, Len) -> List2

返回從List1的第Start個位置開始，後面Len個元素的列表。

例子

lists:sublist([1,2,3,4], 2, 2).

結果

[2,3]

 

36，subtract(List1, List2) -> List3

等同於 List1 -- List2

這個函數功能是返回一個List1的副本，對於List2中的每一個元素，第一次在List1副本中出現時被刪掉。

例子

lists:subtract("112233","12"). 

結果

"1233"

 

37，suffix(List1, List2) -> boolean()

若是List1是List2的後綴，那麼返回true，不然返回false

例子

lists:suffix("22","1122").

結果

true

 

38，sum(List) -> number()

返回List中每一個元素的和。其中List中的元素都應該是number()類型的。

例子

lists:sum([1,2,3,4]). 

結果

10

39，ukeymerge(N, TupleList1, TupleList2) -> TupleList3

TupleList1和TupleList2裏面的元素都是元組

將TupleList1和TupleList2合併，合併的規則是按照元組的第N個元素，若是第N個元素有相同的，那麼保留TupleList1中

的，刪除TupleList2中的。

 

40，ukeysort(N, TupleList1) -> TupleList2

TupleList1裏面的元素都是元組

這個函數也一樣返回一個元素是元組的列表，返回的這個列表是按照元組的第N個元素來排序的，若是元組中有出現

第N個元素相同的狀況，刪除掉後面的一個元組。

例子

lists:ukeysort(1,[{name,"zhangsan"},{sex,"male"},{name,"himan"}]).

結果

[{name,"zhangsan"},{sex,"male"}]

 

41，umerge(ListOfLists) -> List1

這個函數和merge惟一不一樣的就是，裏面不能出現相同的元素，若是出現相同的，那麼刪除之，只保留一個惟一的

例子

lists:umerge([[1,2],[2,3]]).

結果

[1,2,3]

分析：因爲[[1,2],[2,3]]中merge後是[1,2,2,3],這個時候有兩個相同的元素2，因此只保存一個2，因此結果是[1,2,3].

42，umerge3(List1, List2, List3) -> List4

將List1, List2, List3合併

和merge3不一樣的是返回的List4中不能出現重複的元素

例子

lists:merge3([1,2],[2,3],[3,4]).

結果

[1,2,3,4]

 

43，unzip(List1) -> {List2, List3}

List1裏面的元素是元組，每一個元組由兩個元素組成，返回值List2包含每一個List1中每一個元組的第一個元素

返回值List3包含每一個List1中每一個元組的第二個元素。

例子

lists:unzip([{name,"zhangsan"},{sex,"male"},{city,"hangzhou"}]).

結果

{[name,sex,city],["zhangsan","male","hangzhou"]}

 

44，unzip3(List1) -> {List2, List3, List4}

List1裏面的元素是元組，每一個元組由三個元素組成，返回值List2包含每一個List1中每一個元組的第一個元素；

返回值List3包含每一個List1中每一個元組的第二個元素；返回值List4包含每一個List1中每一個元組的第三個元素。

例子

lists:unzip3([{name,"zhangsan","apple"},{sex,"male","banana"},{city,"hangzhou","orange"}]).

結果

{[name,sex,city],

 ["zhangsan","male","hangzhou"],

 ["apple","banana","orange"]}

注意，最終返回的是一個元組。

45，usort(List1) -> List2

將List1按照從小到大的順序排序，若是排序後有重複的元素，刪除重複的，只保存一個惟一的。

例子

lists:usort([4,3,2,1,2,3,4]).

結果

[1,2,3,4]

46，zip(List1, List2) -> List3

將兩個長度相同的列表合併成一個列表

List3是裏面的每個元組的第一個元素是從List1獲取的，而每一個元組的第二個元素是從List2中獲取的

例子

lists:zip([name,sex,city],["zhangsan","male","hangzhou"]).

結果

[{name,"zhangsan"},{sex,"male"},{city,"hangzhou"}]

注意，若是List1和List2長度不一致，那麼這個函數將會報錯。

 

47，zip3(List1, List2, List3) -> List4

將三個長度相同的列表合併成一個列表

List4是裏面的每個元組的第一個元素是從List1獲取的，而每一個元組的第二個元素是從List2中獲取的

每一個元組的第三個元素是從List3中獲取的。

例子

lists:zip3([name,sex,city],["zhangsan","male","hangzhou"],["nick","1","zhejiang"]).

結果

[{name,"zhangsan","nick"},

 {sex,"male","1"},

 {city,"hangzhou","zhejiang"}]

 

---

後面本身添加使用的函數，在項目中用到了

Proplists:get_value函數

proplists 模塊適用數據量較少的場景,處理配置文件和函數選項時經常使用.proplists對內部數據結構是Key-Value鍵值對形式,第一個元素作key用來查詢和刪除,若是一個key有多個值就會使用第一次出現的值,其它被忽略.proplists對於Key和Value的約束極其寬鬆,能夠是任意term().甚至能夠把{Atom,true}縮寫成爲Atom.也正是因爲這樣寬鬆的數據約束,proplists模塊沒有更新和追加數據項的方法,須要使用lists:replace/4.Key進行比較使用的是=:=精確等於,會判斷類型和值.