lists

模块

列表

模块摘要

列表处理功能。

描述

该模块包含列表处理功能。

除非另有说明，否则所有函数都假定位置编号从1开始。也就是说，列表的第一个元素位于位置1。

两个条款T1和T2比较相等T1 == T2评估为true.他们匹配如果T1 =:= T2评估为true...

无论何时序函数F作为参数，则假定下列属性持有F对于所有x，y和z：

• 如果x Fy和y Fx，则x = y（F是反对称的）。

• 如果x Fy和y Fz，则x Fz（F是传递性的）。

• xFy或yFx（F是总数）。

一个典型的排序函数的例子小于或等于：=</2。

输出

all(Pred, List) -> boolean()

类型

Pred = fun((Elem :: T) -> boolean())

List = [T]

T = term()

如果对于List中的所有的元素Elem，Pred(ELEM)返回true，否则返回为false。

any(Pred, List) -> boolean()

类型

Pred = fun((Elem :: T) -> boolean())

List = [T]

T = term()

如果对于List中的至少一个元素Elem，Pred(ELEM)返回true，否则返回为false。

append(ListOfLists) -> List1

Types

ListOfLists = [List]

List = List1 = [T]

T = term()

返回ListOfLists的所有子列表已被追加的列表。

示例：

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

append(List1, List2) -> List3

Types

List1 = List2 = List3 = [T]

T = term()

返回一个新的列表List3，它由List1的元素和后面的List2的元素组成。

示例：

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

lists:append(A, B) 相当于 A ++ B。

concat(Things) -> string()

类型

Things = [Thing]

Thing = atom() | integer() | float() | string()

连接事物元素的文本表示。的元件的东西可以是原子，整数，浮点数，或字符串。

示例：

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

delete(Elem, List1) -> List2

类型

Elem = T

List1 = List2 = [T]

T = term()

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

droplast(List) -> InitList

类型

List = [T, ...]

InitList = [T]

T = term()

删除列表的最后一个元素。这份名单是为非空，否则该功能与崩溃function_clause。

dropwhile(Pred, List1) -> List2

类型

Pred = fun((Elem :: T) -> boolean())

List1 = List2 = [T]

T = term()

从List1中删除元素Elem，而Pred（Elem）返回true并返回剩余列表。

duplicate(N, Elem) -> List

类型

N = integer() >= 0

Elem = T

List = [T]

T = term()

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

Example:

> lists:duplicate(5, xx).
[xx,xx,xx,xx,xx]

filter(Pred, List1) -> List2

Types

Pred = fun((Elem :: T) -> boolean())

List1 = List2 = [T]

T = term()

List2 is a list of all elements Elem in List1 for which Pred(Elem) returns true.

列表2是所有元素的列表ELEM在列表1，当Pred(Elem) 返回真。

filtermap(Fun, List1) -> List2

Types

Fun = fun((Elem) -> boolean() | {true, Value})

List1 = [Elem]

List2 = [Elem | Value]

Elem = Value = term()

返回Fun(Elem)上连续元素ELEM的列表1。 Fun/1必须返回一个布尔值或一个元组{true, Value}。该函数返回Fun为其返回新值的元素列表，其中true值与{true，Elem}同义 。

也就是说，filtermap的行为就好像它已被定义如下：

filtermap(Fun, List1) ->
    lists:foldr(fun(Elem, Acc) ->
                       case Fun(Elem) of
                           false -> Acc;
                           true -> [Elem|Acc];
                           {true,Value} -> [Value|Acc]
                       end
                end, [], List1).

示例：

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

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

类型

DeepList = [term() | DeepList]

相当于length(flatten(DeepList))，但效率更高。

flatmap(Fun, List1) -> List2

类型

Fun = fun((A) -> [B])

List1 = [A]

List2 = [B]

A = B = term()

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

也就是说，flatmap的行为就好像它已被定义如下：

flatmap(Fun, List1) ->
    append(map(Fun, List1)).

示例：

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

flatten(DeepList) -> List

类型

DeepList = [term() | DeepList]

List = [term()]

返回DeepList的展平版本。

flatten(DeepList, Tail) -> List

Types

DeepList = [term() | DeepList]

Tail = List = [term()]

返回尾部Tail追加的DeepList的扁平版本。

foldl(Fun, Acc0, List) -> Acc1

Types

Fun = fun((Elem :: T, AccIn) -> AccOut)

Acc0 = Acc1 = AccIn = AccOut = term()

List = [T]

T = term()

调用Fun(Elem, AccIn) 上连续元素一的名单，从AccIn == Acc0.Fun/2必须返回一个新的累加器，并将其传递给下一个调用。该函数返回累加器的最终值。如果列表为空，则返回Acc0。

示例：

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

foldr(Fun, Acc0, List) -> Acc1

类型

Fun = fun((Elem :: T, AccIn) -> AccOut)

Acc0 = Acc1 = AccIn = AccOut = term()

List = [T]

T = term()

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

示例：

> P = fun(A, AccIn) -> io:format("~p ", [A]), AccIn end.
#Fun<erl_eval.12.2225172>
> lists:foldl(P, void, [1,2,3]).
1 2 3 void
> lists:foldr(P, void, [1,2,3]).
3 2 1 void

foldl/3是尾递归的，通常比foldr/3更受欢迎。

join(Sep, List1) -> List2

类型

Sep = T

List1 = List2 = [T]

T = term()

插入Sep在各元件之间的List1。对空列表和单例列表没有影响。例如：

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

foreach(Fun, List) -> ok

类型

Fun = fun((Elem :: T) -> term())

List = [T]

T = term()

调用Fun(Elem)对每个元素ELEM在列表。此功能用于其副作用，并且评估顺序被定义为与列表中元素的顺序相同。

keydelete(Key, N, TupleList1) -> TupleList2

类型

Key = term()

N = integer() >= 1

1..tuple_size(Tuple)

TupleList1 = TupleList2 = [Tuple]

Tuple = tuple()

如果有这样一个元组，则返回TupleList1的副本，其中第N个元素与Key相等的元组的第一次出现被删除。

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

类型

Key = term()

N = integer() >= 1

1..tuple_size(Tuple)

TupleList = [Tuple]

Tuple = tuple()

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

keymap(Fun, N, TupleList1) -> TupleList2

类型

Fun = fun((Term1 :: term()) -> Term2 :: term())

N = integer() >= 1

1..tuple_size(Tuple)

TupleList1 = TupleList2 = [Tuple]

Tuple = tuple()

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

示例：

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

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

类型

Key = term()

N = integer() >= 1

1..tuple_size(Tuple)

TupleList = [Tuple]

Tuple = tuple()

如果 TupleList中的第N个元素的值等于Key，则返回true ;否则返回false。

keymerge（N，TupleList1，TupleList2） - > TupleList3

类型

N = integer() >= 1

1..tuple_size(Tuple)

TupleList1 = [T1]

TupleList2 = [T2]

TupleList3 = [T1 | T2]

T1 = T2 = Tuple

Tuple = tuple()

返回通过合并TupleList1和TupleList2形成的排序列表。合并在每个元组的第N个元素上执行。无论TupleList1和TupleList2必须键排序评估此功能之前。当两个元组比较相等时，来自TupleList1的元组在TupleList2的元组之前被选取。

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

类型

Key = term()

N = integer() >= 1

1..tuple_size(Tuple)

TupleList1 = TupleList2 = [Tuple]

NewTuple = Tuple

Tuple = tuple()

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

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

类型

Key = term()

N = integer() >= 1

1..tuple_size(Tuple)

TupleList = [Tuple]

Tuple = tuple()

在元组TupleList的列表中搜索第N个元素与Key相等 的元组。如果找到这样的元组，则返回{value，Tuple}，否则返回false。

注意

为了向后兼容，此功能被保留。功能 keyfind / 3 通常更方便。

keysort(N, TupleList1) -> TupleList2

类型

N = integer() >= 1

1..tuple_size(Tuple)

TupleList1 = TupleList2 = [Tuple]

Tuple = tuple()

返回包含列表TupleList1的排序元素的列表。对元组的第N个元素执行排序。排序稳定。

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

类型

Key = term()

N = integer() >= 1

1..tuple_size(Tuple)

TupleList1 = [Tuple]

TupleList2 = [Tuple, ...]

NewTuple = Tuple

Tuple = tuple()

如果存在这样的元组T，则返回TupleList1的副本，其中第N个元素与Key相等的元组T的第一次出现被NewTuple替换。如果不存在这样的元组T，则返回[NewTuple]已附加到结尾的TupleList1的副本。

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

类型

Key = term()

N = integer() >= 1

1..tuple_size(Tuple)

TupleList1 = TupleList2 = [tuple()]

Tuple = tuple()

在元组TupleList1的列表中搜索第N个元素与Key相等的元组。如果找到这样的元组，则返回{value，Tuple，TupleList2}，否则返回false。TupleList2是副本TupleList1，其中第一次出现的元组已被删除。

last(List) -> Last

类型

List = [T, ...]

Last = T

T = term()

返回List中的最后一个元素。

map(Fun, List1) -> List2

类型

Fun = fun((A) -> B)

List1 = [A]

List2 = [B]

A = B = term()

需要从函数甲s到乙s，且列表甲S和产生的列表乙通过将所述函数应用于列表中的每个要素s。该函数用于获取返回值。评估顺序取决于实施。

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

类型

Fun = fun((A, AccIn) -> {B, AccOut})

Acc0 = Acc1 = AccIn = AccOut = term()

List1 = [A]

List2 = [B]

A = B = term()

将map/2和foldl/3的操作组合成一个遍。

示例：

将列表中的元素总结在一起并同时加倍：

> lists:mapfoldl(fun(X, Sum) -> {2*X, X+Sum} end,
0, [1,2,3,4,5]).
{[2,4,6,8,10],15}

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

类型

Fun = fun((A, AccIn) -> {B, AccOut})

Acc0 = Acc1 = AccIn = AccOut = term()

List1 = [A]

List2 = [B]

A = B = term()

将map/2和foldr/3的操作合并为一个pass。

max(List) -> Max

类型

List = [T, ...]

Max = T

T = term()

返回List的第一个元素，它比较大于或等于List的所有其他元素。

member(Elem, List) -> boolean()

Types

Elem = T

List = [T]

T = term()

如果Elem匹配List的某个元素，则返回true，否则返回false。

merge(ListOfLists) -> List1

类型

ListOfLists = [List]

List = List1 = [T]

T = term()

返回通过合并ListOfLists的所有子列表形成的排序列表。在评估此功能之前，必须对所有子列表进行排序。当两个元素比较相等时，ListOfLists中具有最低位置的子列表中的元素将在其他元素之前被选取。

merge(List1, List2) -> List3

类型

List1 = [X]

List2 = [Y]

List3 = [X | Y]

X = Y = term()

返回通过合并List1和List2形成的排序列表。这两个列表1和列表2必须评估该功能前进行排序。当两个元素比较相等时，来自List1的元素在来自List2的元素之前被选取。

merge(Fun, List1, List2) -> List3

类型

Fun = fun((A, B) -> boolean())

List1 = [A]

List2 = [B]

List3 = [A | B]

A = B = term()

返回通过合并List1和List2形成的排序列表。这两个列表1和列表2必须按照排序顺序功能玩转评估此功能之前。如果A在排序中比较小于或等于B，则乐趣（A，B）将返回true，否则为false。当两个元素比较相等时，来自List1的元素在来自List2的元素之前被选取。

merge3(List1, List2, List3) -> List4

类型

List1 = [X]

List2 = [Y]

List3 = [Z]

List4 = [X | Y | Z]

X = Y = Z = term()

返回通过合并List1，List2和List3形成的排序列表。在评估此功能之前，必须对List1，List2和List3进行排序。当两个元素比较相等时，来自List1的元素（如果存在这样的元素）在其他元素之前被选取，否则来自List2的元素被选择在来自List3的元素之前。

min(List) -> Min

Types

List = [T, ...]

Min = T

T = term()

返回List的第一个元素，它比较小于或等于List的所有其他元素。

nth(N, List) -> Elem

Types

N = integer() >= 1

1..length(List)

List = [T, ...]

Elem = T

T = term()

返回List的第N个元素。

示例：

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

nthtail(N, List) -> Tail

类型

N = integer() >= 0

0..length(List)

List = [T, ...]

Tail = [T]

T = term()

返回List的第N个尾部，即从N + 1开始并继续到列表末尾的List的子列表。

示例

> lists:nthtail(3, [a, b, c, d, e]).
[d,e]
> tl(tl(tl([a, b, c, d, e]))).
[d,e]
> lists:nthtail(0, [a, b, c, d, e]).
[a,b,c,d,e]
> lists:nthtail(5, [a, b, c, d, e]).
[]

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

类型

Pred = fun((Elem :: T) -> boolean())

List = Satisfying = NotSatisfying = [T]

T = term()

分区列表分为两个列表，其中第一个列表包含Pred（Elem）返回true的所有元素，第二个列表包含Pred（Elem）返回false的所有元素。

示例：

> lists:partition(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1,3,5,7],[2,4,6]}
> lists:partition(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b,c,d,e],[1,2,3,4]}

有关分区列表的不同方式，请参阅splitwith/2。

prefix(List1, List2) -> boolean()

类型

List1 = List2 = [T]

T = term()

如果List1是List2的前缀，则返回true，否则返回false。

reverse(List1) -> List2

类型

List1 = List2 = [T]

T = term()

以相反顺序返回List1中元素的列表。

reverse(List1, Tail) -> List2

Types

List1 = [T]

Tail = term()

List2 = [T]

T = term()

以相反顺序返回List1中元素的列表，并附加Tailappended。

示例：

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

seq(From, To) -> Seq

seq(From, To, Incr) -> Seq

类型

From = To = Incr = integer()

Seq = [integer()]

返回以From开头的整数序列，并包含将Incr添加到前一个元素的连续结果，直到To达到或通过（在后一种情况下，To不是序列的元素）。Incr默认为1。

失败：

• 如果To < From - Incr和Incr > 0。

• 如果To > From - Incr和Incr < 0。

• 如果Incr =:= 0和From =/= To。

下列等式适用于所有序列：

length(lists:seq(From, To)) =:= To - From + 1
length(lists:seq(From, To, Incr)) =:= (To - From + Incr) div Incr

例子：

> lists:seq(1, 10).
[1,2,3,4,5,6,7,8,9,10]
> lists:seq(1, 20, 3).
[1,4,7,10,13,16,19]
> lists:seq(1, 0, 1).
[]
> lists:seq(10, 6, 4).
[]
> lists:seq(1, 1, 0).
[1]

sort(List1) -> List2

类型

返回包含排序元素的列表List1。

sort(Fun, List1) -> List2

类型

根据ordering function Fun。返回包含排序元素的列表List1。如果A比较小于或等于B，Fun(A, B)则返回true，否则返回false。

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

类型

0..length(List1)

拆分List1成List2和List3。List2包含第一个N元素和List3其余元素（第Nth尾）。

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

类型

分区List成两个列表根据Pred。splitwith/2表现如同它被定义如下：

splitwith(Pred, List) ->
    {takewhile(Pred, List), dropwhile(Pred, List)}.

例子：

> lists:splitwith(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1],[2,3,4,5,6,7]}
> 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]}

有关分区列表的另一种方式，请参阅partition/2。

sublist(List1, Len) -> List2

类型

返回List1从位置1开始并具有（最大）Len元素的子列表。Len超出列表的长度并不是错误，在这种情况下，整个列表将被返回。

sublist(List1, Start, Len) -> List2

类型

1..(length(List1)+1)

返回以List1（最大）Len元素开始Start的子列表。超出列表长度并不是Start+Len错误。

例子：

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

subtract(List1, List2) -> List3

类型

按照以下过程返回作为List3副本的新列表List1：对于其中的每个元素List2，其第一个出现的元素将List1被删除。

例子：

> lists:subtract("123212", "212").
"312".

lists:subtract(A, B)相当于A -- B。

警告

在复杂lists:subtract(A, B)成正比length(A)*length(B)，这意味着它是非常缓慢的，如果这两个A和B很长的列表。（如果两个列表都很长，使用有序列表和更好的选择是更好的选择ordsets:subtract/2。

suffix(List1, List2) -> boolean()

类型

返回true如果 List1是后缀List2，否则返回false。

sum(List) -> number()

类型

返回中的元素总和List。

takewhile(Pred, List1) -> List2

类型

Elem从List1while Pred(Elem)返回元素true，也就是说，函数返回列表中所有元素满足谓词的最长前缀。

ukeymerge(N, TupleList1, TupleList2) -> TupleList3

类型

1..tuple_size(Tuple)

返回合并TupleList1和所形成的排序列表TupleList2。合并在N每个元组的第th个元素上执行。在评估此功能之前，两者TupleList1和TupleList2必须按键分类，不得重复。当两个元组比较相等时，元组被从中TupleList1挑选出来，并从中TupleList2删除。

ukeysort(N, TupleList1) -> TupleList2

类型

1..tuple_size(Tuple)

返回一个包含列表的排序元素的列表TupleList1，其中除了比较相等的元组的第一个元组之外的所有元素都已被删除。排序N在元组的第th个元素上执行。

umerge(ListOfLists) -> List1

类型

返回合并所有子列表形成的排序列表ListOfLists。在评估此功能之前，所有子列表必须进行排序并且不包含重复项。当两个元素比较相等时，位于最低位置的子列表中的元素ListOfLists被选中，另一个被删除。

umerge(List1, List2) -> List3

类型

返回合并List1和所形成的排序列表List2。双方List1并List2必须进行分类和评估包含此功能之前，没有重复。当两个元素比较相等时，元素来自List1被挑选，而来自元素的元素List2被删除。

umerge(Fun, List1, List2) -> List3

类型

返回合并List1和所形成的排序列表List2。在评估此功能之前，List1和List2两者都必须根据ordering function Fun并且不包含重复项进行排序。如果A比较小于或等于B则Fun(A, B)返回true，否则返回false。当两个元素比较相等时，来自List1元素被挑选，而来自List2元素被删除。

umerge3(List1, List2, List3) -> List4

类型

返回排序列表通过合并形成的List1，List2和List3。所有的List1，List2以及List3必须进行分类和评估包含此功能之前，没有重复。当两个元素比较相等时，List1如果存在这样的元素，则从中List2选择元素，否则从中拾取元素，而另一个元素被删除。

unzip(List1) -> {List2, List3}

类型

将两元组列表解压缩到两个列表中，其中第一个列表包含每个元组的第一个元素，第二个列表包含每个元组的第二个元素。

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

类型

将三元组列表解压缩为三个列表，其中第一个列表包含每个元组的第一个元素，第二个列表包含每个元组的第二个元素，第三个列表包含每个元组的第三个元素。

usort(List1) -> List2

类型

返回包含排序元素的列表。List1其中，除第一个元素外，所有元素都已被删除。

usort(Fun, List1) -> List2

类型

返回一个列表，其中包含List1所有元素的排序元素，除了根据ordering function Fun已被删除的元素的第一个元素比较相等以外。如果比较小于或等于Fun(A, B)则返回，否则返回。trueABfalse

zip(List1, List2) -> List3

类型

“Zips”将两个长度相等的列表合并成一个由两个元组组成的列表，其中每个元组的第一个元素从第一个列表中提取，第二个元素从第二个列表中的相应元素中提取。

zip3(List1, List2, List3) -> List4

类型

“Zips”三个长度相等的列表为一个三元组列表，其中每个元组的第一个元素从第一个列表中提取，第二个元素从第二个列表中的相应元素中提取。第三个元素从第三个列表中的对应元素中提取。

zipwith(Combine, List1, List2) -> List3

类型

将两个长度相等的列表的元素组合成一个列表。对于X, Y这两个列表中的每对列表元素，结果列表中的元素是Combine(X, Y)。

zipwith(fun(X, Y) -> {X,Y} end, List1, List2)等于zip(List1, List2)...

例子：

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

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

类型

将三个长度相等的列表的元素组合成一个列表。对于X, Y, Z三个列表中每个列表元素的三元组，结果列表中的元素是Combine(X, Y, Z)。

zipwith3(fun(X, Y, Z) -> {X,Y,Z} end, List1, List2, List3)相当于zip3(List1, List2, List3)。

例子：

> lists:zipwith3(fun(X, Y, Z) -> X+Y+Z end, [1,2,3], [4,5,6], [7,8,9]).
[12,15,18]
> lists:zipwith3(fun(X, Y, Z) -> [X,Y,Z] end, [a,b,c], [x,y,z], [1,2,3]).
[[a,x,1],[b,y,2],[c,z,3]]