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是总数）。

如果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]]