查看源代码 List (Elixir v1.16.2)
链表可以按选定的顺序保存零个、一个或多个元素。
Elixir 中的列表用方括号指定。
iex> [1, "two", 3, :four]
[1, "two", 3, :four]可以使用 ++/2 和 --/2 运算符连接和减去两个列表。
iex> [1, 2, 3] ++ [4, 5, 6]
[1, 2, 3, 4, 5, 6]
iex> [1, true, 2, false, 3, true] -- [true, false]
[1, 2, 3, true]可以使用 | 将元素附加到列表的前面。
iex> new = 0
iex> list = [1, 2, 3]
iex> [new | list]
[0, 1, 2, 3]Elixir 中的列表实际上是链表，这意味着它们在内部用包含列表的头部和尾部的对来表示。
iex> [head | tail] = [1, 2, 3]
iex> head
1
iex> tail
[2, 3]类似地，我们可以仅使用这样的对（称为 cons 单元）来编写列表 [1, 2, 3]。
iex> [1 | [2 | [3 | []]]]
[1, 2, 3]某些列表（称为不完整列表）在最后一个 cons 单元中没有空列表作为第二个元素。
iex> [1 | [2 | [3 | 4]]]
[1, 2, 3 | 4]尽管通常避免使用不完整列表，但在某些特殊情况下会使用它们，例如 iodata 和 chardata 实体（请参阅 IO 模块）。
由于它们基于 cons 单元的表示，将元素附加到列表的前面始终很快（恒定时间），而随着列表大小的增长（线性时间），附加操作会变得更慢。
iex> list = [1, 2, 3]
iex> [0 | list] # fast
[0, 1, 2, 3]
iex> list ++ [4] # slow
[1, 2, 3, 4]此模块中的大多数函数都在线性时间内工作。这意味着执行操作所需的时间与列表的长度增长速度相同。例如，length/1 和 last/1 将在线性时间内运行，因为它们需要遍历列表的每个元素，但 first/1 将在恒定时间内运行，因为它只需要第一个元素。
列表还实现了 Enumerable 协议，因此可以在 Enum 模块中找到许多用于处理列表的函数。此外，可以在 Kernel 中找到以下列表函数和运算符。
字符列表
如果列表由非负整数组成，其中每个整数都代表一个 Unicode 代码点，则该列表也可以称为字符列表。这些整数必须
- 在范围
0..0x10FFFF(0..1_114_111) 内； - 并且在范围
0xD800..0xDFFF(55_296..57_343) 之外，该范围在 Unicode 中保留用于 UTF-16 替代对。
Elixir 使用 ~c 标记 来定义字符列表。
iex> ~c"héllo"
[104, 233, 108, 108, 111]特别是，如果字符列表仅包含可打印的 ASCII 字符，则它们将默认情况下使用 ~c 标记打印回来。
iex> ~c"abc"
~c"abc"即使表示形式发生了变化，原始数据仍然是整数列表，可以像这样处理。
iex> inspect(~c"abc", charlists: :as_list)
"[97, 98, 99]"
iex> Enum.map(~c"abc", fn num -> 1000 + num end)
[1097, 1098, 1099]当您遇到字符列表时，可以使用 IEx.Helpers.i/1 助手在 IEx 中获取字符列表的简要概述，它将向您显示类型、描述以及单个摘要中的原始表示形式。
这种行为背后的基本原理是更好地支持可能将文本作为字符列表而不是 Elixir 字符串返回的 Erlang 库。在 Erlang 中，字符列表是处理字符串的默认方式，而在 Elixir 中则是二进制数据。此类函数的一个示例是 Application.loaded_applications/0
Application.loaded_applications()
#=> [
#=> {:stdlib, ~c"ERTS CXC 138 10", ~c"2.6"},
#=> {:compiler, ~c"ERTS CXC 138 10", ~c"6.0.1"},
#=> {:elixir, ~c"elixir", ~c"1.0.0"},
#=> {:kernel, ~c"ERTS CXC 138 10", ~c"4.1"},
#=> {:logger, ~c"logger", ~c"1.0.0"}
#=> ]可以使用 ascii_printable?/2 检查列表是否仅由可打印的 ASCII 字符组成。
不完整列表从不视为字符列表。
总结
函数
检查 list 是否为仅由可打印的 ASCII 字符组成的字符列表。
从 list 中删除给定的 element。返回一个不包含该元素的新列表。
通过删除指定 index 处的 value 生成一个新列表。
在列表中将给定的元素 elem 复制 n 次。
返回 list 中的第一个元素，如果 list 为空，则返回 default。
将给定的嵌套列表 list 展平。
将给定的嵌套列表 list 展平。列表 tail 将添加到展平列表的末尾。
使用函数从左侧折叠（减少）给定的列表。需要一个累加器，它可以是任何值。
使用函数从右侧折叠（减少）给定的列表。需要一个累加器，它可以是任何值。
如果 list 是不完整列表，则返回 true。否则返回 false。
返回一个在指定 index 处插入 value 的列表。
接收元组列表，并删除 position 处的元素与给定 key 匹配的第一个元组。返回新列表。
接收元组列表，并返回元组中 position 处的元素与给定 key 匹配的第一个元组。
接收元组列表，并返回元组中 position 处的元素与给定 key 匹配的第一个元组。
接收元组列表，如果元组中 position 处的元素与给定 key 匹配，则返回 true。
接收元组列表，如果由 key 在 position 处标识的元素存在，则将其替换为 new_tuple。
接收元组列表，并对元组中 position 处的元素进行排序。
接收元组列表，并使用 new_tuple 替换由 key 在 position 处标识的元素。
接收元组列表，并返回元组中 position 处的元素与给定 key 匹配的第一个元组，以及没有找到的元组的 list。
返回 list 中的最后一个元素，如果 list 为空，则返回 default。
返回一个表示*编辑脚本*的关键字列表。
返回一个表示具有嵌套差异的*编辑脚本*的关键字列表。
返回并删除 list 中指定 index 处的 value。
返回一个在指定 index 处替换 value 的列表。
如果 list 以给定的 prefix 列表开头，则返回 true；否则返回 false。
将字符列表转换为原子。
将表示 Unicode 代码点的整数列表、列表或字符串转换为字符列表。
将字符列表转换为现有原子。
返回文本表示形式为 charlist 的浮点数。
返回文本表示形式为 charlist 的整数。
返回文本表示形式为 charlist 且基数为 base 的整数。
将表示代码点的整数列表、列表或字符串转换为字符串。
将列表转换为元组。
返回一个在指定 index 处更新 value 的列表。
如果这不是列表，则将 term 包裹在列表中。
将 list_of_lists 中每个列表中的对应元素压缩在一起。
函数
@spec ascii_printable?(list(), 0) :: true
@spec ascii_printable?([], limit) :: true when limit: :infinity | pos_integer()
@spec ascii_printable?([...], limit) :: boolean() when limit: :infinity | pos_integer()
检查 list 是否为仅由可打印的 ASCII 字符组成的字符列表。
接受一个可选的 limit 作为第二个参数。 ascii_printable?/2 只检查列表的可打印性，最多检查到 limit。
Elixir 中的可打印字符列表仅包含标准七位 ASCII 字符编码中的可打印字符，即十进制表示范围从 32 到 126 的字符，以及以下控制字符。
?\a- 响铃?\b- 退格键?\t- 水平制表符?\n- 换行符?\v- 垂直制表符?\f- 换页符?\r- 回车键?\e- 转义
有关更多信息，请阅读 字符组 部分，该部分在 ASCII 标准的维基百科文章中。
示例
iex> List.ascii_printable?(~c"abc")
true
iex> List.ascii_printable?(~c"abc" ++ [0])
false
iex> List.ascii_printable?(~c"abc" ++ [0], 2)
true不完整列表不可打印，即使它们仅由 ASCII 字符组成。
iex> List.ascii_printable?(~c"abc" ++ ?d)
false从 list 中删除给定的 element。返回一个不包含该元素的新列表。
如果 element 在 list 中出现多次，则仅删除第一次出现。
示例
iex> List.delete([:a, :b, :c], :a)
[:b, :c]
iex> List.delete([:a, :b, :c], :d)
[:a, :b, :c]
iex> List.delete([:a, :b, :b, :c], :b)
[:a, :b, :c]
iex> List.delete([], :b)
[]通过删除指定 index 处的 value 生成一个新列表。
负索引表示从 list 末尾偏移。如果 index 超出范围，则返回原始 list。
示例
iex> List.delete_at([1, 2, 3], 0)
[2, 3]
iex> List.delete_at([1, 2, 3], 10)
[1, 2, 3]
iex> List.delete_at([1, 2, 3], -1)
[1, 2]@spec duplicate(any(), 0) :: []
@spec duplicate(elem, pos_integer()) :: [elem, ...] when elem: var
在列表中将给定的元素 elem 复制 n 次。
n 是大于或等于 0 的整数。
如果 n 为 0，则返回一个空列表。
示例
iex> List.duplicate("hello", 0)
[]
iex> List.duplicate("hi", 1)
["hi"]
iex> List.duplicate("bye", 2)
["bye", "bye"]
iex> List.duplicate([1, 2], 3)
[[1, 2], [1, 2], [1, 2]]返回 list 中的第一个元素，如果 list 为空，则返回 default。
first/2 从 Elixir v1.12.0 开始引入，而 first/1 从 v1.0.0 开始可用。
示例
iex> List.first([])
nil
iex> List.first([], 1)
1
iex> List.first([1])
1
iex> List.first([1, 2, 3])
1将给定的嵌套列表 list 展平。
空列表元素会被丢弃。
示例
iex> List.flatten([1, [[2], 3]])
[1, 2, 3]
iex> List.flatten([[], [[], []]])
[]@spec flatten(deep_list, [elem]) :: [elem]
when deep_list: [elem | deep_list], elem: var
将给定的嵌套列表 list 展平。列表 tail 将添加到展平列表的末尾。
list 中的空列表元素会被丢弃，但 tail 中的空列表元素不会被丢弃。
示例
iex> List.flatten([1, [[2], 3]], [4, 5])
[1, 2, 3, 4, 5]
iex> List.flatten([1, [], 2], [3, [], 4])
[1, 2, 3, [], 4]@spec foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
使用函数从左侧折叠（减少）给定的列表。需要一个累加器，它可以是任何值。
示例
iex> List.foldl([5, 5], 10, fn x, acc -> x + acc end)
20
iex> List.foldl([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
2
iex> List.foldl([1, 2, 3], {0, 0}, fn x, {a1, a2} -> {a1 + x, a2 - x} end)
{6, -6}@spec foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
使用函数从右侧折叠（减少）给定的列表。需要一个累加器，它可以是任何值。
示例
iex> List.foldr([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
-2
iex> List.foldr([1, 2, 3, 4], %{sum: 0, product: 1}, fn x, %{sum: a1, product: a2} -> %{sum: a1 + x, product: a2 * x} end)
%{product: 24, sum: 10}@spec improper?(maybe_improper_list()) :: boolean()
如果 list 是不完整列表，则返回 true。否则返回 false。
示例
iex> List.improper?([1, 2 | 3])
true
iex> List.improper?([1, 2, 3])
false返回一个在指定 index 处插入 value 的列表。
注意，index 被限制在列表长度内。负索引表示从 list 末尾开始的偏移量。
示例
iex> List.insert_at([1, 2, 3, 4], 2, 0)
[1, 2, 0, 3, 4]
iex> List.insert_at([1, 2, 3], 10, 0)
[1, 2, 3, 0]
iex> List.insert_at([1, 2, 3], -1, 0)
[1, 2, 3, 0]
iex> List.insert_at([1, 2, 3], -10, 0)
[0, 1, 2, 3]@spec keydelete([tuple()], any(), non_neg_integer()) :: [tuple()]
接收元组列表，并删除 position 处的元素与给定 key 匹配的第一个元组。返回新列表。
示例
iex> List.keydelete([a: 1, b: 2], :a, 0)
[b: 2]
iex> List.keydelete([a: 1, b: 2], 2, 1)
[a: 1]
iex> List.keydelete([a: 1, b: 2], :c, 0)
[a: 1, b: 2]此函数适用于任何元组列表。
iex> List.keydelete([{22, "SSH"}, {80, "HTTP"}], 80, 0)
[{22, "SSH"}]@spec keyfind([tuple()], any(), non_neg_integer(), any()) :: any()
接收元组列表，并返回元组中 position 处的元素与给定 key 匹配的第一个元组。
如果找不到匹配的元组，则返回 default。
示例
iex> List.keyfind([a: 1, b: 2], :a, 0)
{:a, 1}
iex> List.keyfind([a: 1, b: 2], 2, 1)
{:b, 2}
iex> List.keyfind([a: 1, b: 2], :c, 0)
nil此函数适用于任何元组列表。
iex> List.keyfind([{22, "SSH"}, {80, "HTTP"}], 22, 0)
{22, "SSH"}@spec keyfind!([tuple()], any(), non_neg_integer()) :: any()
接收元组列表，并返回元组中 position 处的元素与给定 key 匹配的第一个元组。
如果找不到匹配的元组，则抛出错误。
示例
iex> List.keyfind!([a: 1, b: 2], :a, 0)
{:a, 1}
iex> List.keyfind!([a: 1, b: 2], 2, 1)
{:b, 2}
iex> List.keyfind!([a: 1, b: 2], :c, 0)
** (KeyError) key :c at position 0 not found in: [a: 1, b: 2]此函数适用于任何元组列表。
iex> List.keyfind!([{22, "SSH"}, {80, "HTTP"}], 22, 0)
{22, "SSH"}@spec keymember?([tuple()], any(), non_neg_integer()) :: boolean()
接收元组列表，如果元组中 position 处的元素与给定 key 匹配，则返回 true。
示例
iex> List.keymember?([a: 1, b: 2], :a, 0)
true
iex> List.keymember?([a: 1, b: 2], 2, 1)
true
iex> List.keymember?([a: 1, b: 2], :c, 0)
false此函数适用于任何元组列表。
iex> List.keymember?([{22, "SSH"}, {80, "HTTP"}], 22, 0)
true@spec keyreplace([tuple()], any(), non_neg_integer(), tuple()) :: [tuple()]
接收元组列表，如果由 key 在 position 处标识的元素存在，则将其替换为 new_tuple。
示例
iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
[a: 3, b: 2]
iex> List.keyreplace([a: 1, b: 2], :a, 1, {:a, 3})
[a: 1, b: 2]此函数适用于任何元组列表。
iex> List.keyreplace([{22, "SSH"}, {80, "HTTP"}], 22, 0, {22, "Secure Shell"})
[{22, "Secure Shell"}, {80, "HTTP"}]@spec keysort( [tuple()], non_neg_integer(), (any(), any() -> boolean()) | :asc | :desc | module() | {:asc | :desc, module()} ) :: [tuple()]
接收元组列表，并对元组中 position 处的元素进行排序。
排序是稳定的。
从 Elixir v1.14.0 开始提供 sorter 参数。类似于 Enum.sort/2，排序器可以是匿名函数、原子 :asc 或 :desc，或者实现比较函数的模块。
示例
iex> List.keysort([a: 5, b: 1, c: 3], 1)
[b: 1, c: 3, a: 5]
iex> List.keysort([a: 5, c: 1, b: 3], 0)
[a: 5, b: 3, c: 1]要按降序排序
iex> List.keysort([a: 5, c: 1, b: 3], 0, :desc)
[c: 1, b: 3, a: 5]与 Enum.sort/2 中一样，避免使用默认排序函数对结构体进行排序，因为默认情况下它执行的是结构比较而不是语义比较。在这种情况下，您应该将排序函数作为第三个元素传递，或者传递任何实现 compare/2 函数的模块。例如，如果您有包含用户名及其生日的元组，并且您想按生日（升序或降序）进行排序，您应该执行以下操作
iex> users = [
...> {"Ellis", ~D[1943-05-11]},
...> {"Lovelace", ~D[1815-12-10]},
...> {"Turing", ~D[1912-06-23]}
...> ]
iex> List.keysort(users, 1, Date)
[
{"Lovelace", ~D[1815-12-10]},
{"Turing", ~D[1912-06-23]},
{"Ellis", ~D[1943-05-11]}
]
iex> List.keysort(users, 1, {:desc, Date})
[
{"Ellis", ~D[1943-05-11]},
{"Turing", ~D[1912-06-23]},
{"Lovelace", ~D[1815-12-10]}
]@spec keystore([tuple()], any(), non_neg_integer(), tuple()) :: [tuple(), ...]
接收元组列表，并使用 new_tuple 替换由 key 在 position 处标识的元素。
如果元素不存在，则将其添加到 list 的末尾。
示例
iex> List.keystore([a: 1, b: 2], :a, 0, {:a, 3})
[a: 3, b: 2]
iex> List.keystore([a: 1, b: 2], :c, 0, {:c, 3})
[a: 1, b: 2, c: 3]此函数适用于任何元组列表。
iex> List.keystore([{22, "SSH"}], 80, 0, {80, "HTTP"})
[{22, "SSH"}, {80, "HTTP"}]@spec keytake([tuple()], any(), non_neg_integer()) :: {tuple(), [tuple()]} | nil
接收元组列表，并返回元组中 position 处的元素与给定 key 匹配的第一个元组，以及没有找到的元组的 list。
如果找不到这样的元组，则返回 nil。
示例
iex> List.keytake([a: 1, b: 2], :a, 0)
{{:a, 1}, [b: 2]}
iex> List.keytake([a: 1, b: 2], 2, 1)
{{:b, 2}, [a: 1]}
iex> List.keytake([a: 1, b: 2], :c, 0)
nil此函数适用于任何元组列表。
iex> List.keytake([{22, "SSH"}, {80, "HTTP"}], 80, 0)
{{80, "HTTP"}, [{22, "SSH"}]}返回 list 中的最后一个元素，如果 list 为空，则返回 default。
last/2 从 Elixir v1.12.0 开始引入，而 last/1 从 v1.0.0 开始可用。
示例
iex> List.last([])
nil
iex> List.last([], 1)
1
iex> List.last([1])
1
iex> List.last([1, 2, 3])
3返回一个表示*编辑脚本*的关键字列表。
该算法在 E. Myers 的“An O(ND) Difference Algorithm and Its Variations”论文中概述。
编辑脚本 是一个关键字列表。每个键描述了为了使 list1 更接近于等于 list2 所需的“编辑操作”；键可以是 :eq、:ins 或 :del。每个值都是 list1 或 list2 的子列表，它应该被插入（如果对应的键是 :ins）、删除（如果对应的键是 :del）或保留（如果对应的键是 :eq）到 list1 中，以更接近于 list2。
如果您想在差异脚本中处理嵌套，请参阅 myers_difference/3。
示例
iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
[eq: [1], del: [4], eq: [2, 3], ins: [4]]@spec myers_difference(list(), list(), (term(), term() -> script | nil)) :: script when script: [{:eq | :ins | :del | :diff, list()}]
返回一个表示具有嵌套差异的*编辑脚本*的关键字列表。
这是 myers_difference/2 的扩展，其中可以在需要计算嵌套差异的情况下提供 diff_script 函数。该函数可以返回包含内部编辑脚本的列表，或者在没有这样的脚本的情况下返回 nil。返回的内部编辑脚本将在 :diff 键下。
示例
iex> List.myers_difference(["a", "db", "c"], ["a", "bc"], &String.myers_difference/2)
[eq: ["a"], diff: [del: "d", eq: "b", ins: "c"], del: ["c"]]返回并删除 list 中指定 index 处的 value。
负索引表示从 list 末尾偏移。如果 index 超出范围，则返回原始 list。
示例
iex> List.pop_at([1, 2, 3], 0)
{1, [2, 3]}
iex> List.pop_at([1, 2, 3], 5)
{nil, [1, 2, 3]}
iex> List.pop_at([1, 2, 3], 5, 10)
{10, [1, 2, 3]}
iex> List.pop_at([1, 2, 3], -1)
{3, [1, 2]}返回一个在指定 index 处替换 value 的列表。
负索引表示从 list 末尾偏移。如果 index 超出范围，则返回原始 list。
示例
iex> List.replace_at([1, 2, 3], 0, 0)
[0, 2, 3]
iex> List.replace_at([1, 2, 3], 10, 0)
[1, 2, 3]
iex> List.replace_at([1, 2, 3], -1, 0)
[1, 2, 0]
iex> List.replace_at([1, 2, 3], -10, 0)
[1, 2, 3]@spec starts_with?([...], [...]) :: boolean()
@spec starts_with?(list(), []) :: true
@spec starts_with?([], [...]) :: false
如果 list 以给定的 prefix 列表开头，则返回 true；否则返回 false。
如果 prefix 是一个空列表，则返回 true。
示例
iex> List.starts_with?([1, 2, 3], [1, 2])
true
iex> List.starts_with?([1, 2], [1, 2, 3])
false
iex> List.starts_with?([:alpha], [])
true
iex> List.starts_with?([], [:alpha])
false将字符列表转换为原子。
Elixir 支持从包含任何 Unicode 代码点的字符列表进行转换。
由编译器内联。
示例
iex> List.to_atom(~c"Elixir")
:Elixir
iex> List.to_atom(~c"🌢 Elixir")
:"🌢 Elixir"@spec to_charlist(:unicode.charlist()) :: charlist()
将表示 Unicode 代码点的整数列表、列表或字符串转换为字符列表。
请注意，此函数期望一个表示 Unicode 代码点的整数列表。如果您有一个字节列表，则必须使用 :binary 模块。
示例
iex> ~c"æß" = List.to_charlist([0x00E6, 0x00DF])
[230, 223]
iex> List.to_charlist([0x0061, "bc"])
~c"abc"
iex> List.to_charlist([0x0064, "ee", [~c"p"]])
~c"deep"将字符列表转换为现有原子。
Elixir 支持从包含任何 Unicode 代码点的字符列表进行转换。如果原子不存在，则抛出 ArgumentError。
由编译器内联。
原子和模块
由于 Elixir 是一种编译语言，因此模块中定义的原子只有在该模块加载后才会存在，这通常发生在执行模块中的函数时。因此，通常建议仅调用
List.to_existing_atom/1来转换在调用to_existing_atom/1的函数的模块中定义的原子。
示例
iex> _ = :my_atom
iex> List.to_existing_atom(~c"my_atom")
:my_atom
iex> _ = :"🌢 Elixir"
iex> List.to_existing_atom(~c"🌢 Elixir")
:"🌢 Elixir"返回文本表示形式为 charlist 的浮点数。
由编译器内联。
示例
iex> List.to_float(~c"2.2017764e+0")
2.2017764返回文本表示形式为 charlist 的整数。
由编译器内联。
示例
iex> List.to_integer(~c"123")
123返回文本表示形式为 charlist 且基数为 base 的整数。
由编译器内联。
基数需要在 2 和 36 之间。
示例
iex> List.to_integer(~c"3FF", 16)
1023@spec to_string(:unicode.charlist()) :: String.t()
将表示代码点的整数列表、列表或字符串转换为字符串。
要转换为字符串，列表必须为空或仅包含以下元素
- 字符串
- 表示 Unicode 代码点的整数
- 包含这三种元素之一的列表
请注意，此函数期望一个表示 Unicode 代码点的整数列表。如果您有一个字节列表，则必须使用 :binary 模块。
示例
iex> List.to_string([0x00E6, 0x00DF])
"æß"
iex> List.to_string([0x0061, "bc"])
"abc"
iex> List.to_string([0x0064, "ee", [~c"p"]])
"deep"
iex> List.to_string([])
""将列表转换为元组。
由编译器内联。
示例
iex> List.to_tuple([:share, [:elixir, 163]])
{:share, [:elixir, 163]}返回一个在指定 index 处更新 value 的列表。
负索引表示从 list 末尾偏移。如果 index 超出范围，则返回原始 list。
示例
iex> List.update_at([1, 2, 3], 0, &(&1 + 10))
[11, 2, 3]
iex> List.update_at([1, 2, 3], 10, &(&1 + 10))
[1, 2, 3]
iex> List.update_at([1, 2, 3], -1, &(&1 + 10))
[1, 2, 13]
iex> List.update_at([1, 2, 3], -10, &(&1 + 10))
[1, 2, 3]@spec wrap(term()) :: maybe_improper_list()
如果这不是列表，则将 term 包裹在列表中。
如果 term 已经是列表，则返回该列表。如果 term 为 nil，则返回一个空列表。
示例
iex> List.wrap("hello")
["hello"]
iex> List.wrap([1, 2, 3])
[1, 2, 3]
iex> List.wrap(nil)
[]将 list_of_lists 中每个列表中的对应元素压缩在一起。
一旦任何列表结束，压缩就会结束。
示例
iex> List.zip([[1, 2], [3, 4], [5, 6]])
[{1, 3, 5}, {2, 4, 6}]
iex> List.zip([[1, 2], [3], [5, 6]])
[{1, 3, 5}]