列表 | List
列单
适用于（链接）列表的功能。
在方括号中指定了Elixir中的列表：
iex> [1, "two", 3, :four]
[1, "two", 3, :four]
可以将两个列表连接起来，并使用Kernel.++/2和Kernel.--/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> [head | tail] = [1, 2, 3]
iex> head
1
iex> tail
[2, 3]
同样，我们可以[1, 2, 3]只使用这样的对（称为cons单元格）来编写列表：
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]
该Kernel模块包含许多功能来操纵列表并允许在警卫中使用。例如，Kernel.hd/1检索头部，Kernel.tl/1获取尾部和Kernel.length/1计算长度。请记住，类似于追加到列表中，计算长度需要遍历整个列表。
Charlists
如果列表由非负整数组成，则也可以称为charlist。Elixir使用单引号来定义charlist：
iex> 'héllo'
[104, 233, 108, 108, 111]
特别是，如果charlists只包含ASCII可打印的代码点，则可以用单引号将其打印回来：
iex> 'abc'
'abc'
这种行为背后的基本原理是更好地支持Erlang库，后者可能以字符列表的形式返回文本，而不是以Elixir字符串的形式返回。这类函数的一个例子是Application.loaded_applications/0*
Application.loaded_applications
#=> [{:stdlib, 'ERTS CXC 138 10', '2.6'},
{:compiler, 'ERTS CXC 138 10', '6.0.1'},
{:elixir, 'elixir', '1.0.0'},
{:kernel, 'ERTS CXC 138 10', '4.1'},
{:logger, 'logger', '1.0.0'}]
列表和Enum模块
本模块旨在提供特定于列表的操作，如数据类型之间的转换，更新，删除和键查找（用于元组列表）。对于一般遍历列表，开发人员应该使用Enum模块中跨越各种数据类型的函数。
两种Enum和List模块，列表上的任何类型的索引访问都是线性的。负索引也被支持，但它们意味着列表将被迭代两次，一个用于计算适当的索引，另一个用于执行操作。
摘要
函数
delete(list, item)
删除给定的item从list返回一个没有该项的新列表。
delete_at(list, index)
通过删除指定的值生成新的列表 index
duplicate(elem, n)
n在列表中复制给定的元素时间
first(list)
返回第一个元素list或nil如果list是空的
flatten(list)
使给定的list嵌套列表
flatten(list, tail)
展平给定list的嵌套列表。该列表tail将被添加到展平列表的末尾
foldl(list, acc, function)
使用函数折叠（缩小）给定列表。需要一个累加器
foldr（list，acc，function）
使用函数折叠（缩小）给定列表的右侧。需要一个累加器
insert_at（list，index，value）
返回一个列表value插入在指定的index
keydelete(list, key, position)
接收list的元组，并删除第一个元组，其中项位于position匹配给定的key返回新列表
keyfind(list, key, position, default \ nil)
接收元组列表，并返回第一个元组，其中项位于position在元组中匹配给定的key
keymember?(list, key, position)
true如果存在元组中元素与position给定元素匹配的元组，则接收元组列表并返回key
keyreplace(list, key, position, new_tuple)
接收元组列表并替换由keyat 标识的项目（position如果存在）
keysort(list, position)
接收元组列表并对position元组的。这种类型是稳定的
keystore(list, key, position, new_tuple)
接收一个list元组并替换keyat 标识的项目position
keytake(list, key, position)
接收一个list元组并返回元组中元素position与给定元素相匹配的第一个元组key，以及list未找到的元组
last(list)
返回最后一个元素list或者nil是否list为空
myers_difference(list1, list2)
返回表示编辑脚本的关键字列表
pop_at(list, index, default \ nil)
返回并在指定的去除值index在list
replace_at(list, index, value)
返回指定的具有替换值的列表 index
starts_with?(list, prefix)
如果list从给定prefix列表开始，则返回true；否则返回false
to_atom(charlist)
将字符列表转换为原子
to_existing_atom(charlist)
将charlist转换为现有原子。ArgumentError如果原子不存在，则引发一次
to_float(charlist)
返回文本表示为charlist
to_integer(charlist)
返回文本表示为charlist
to_integer(charlist, base)
返回文本表示为charlist在基地base
to_string(list)
将表示代码点、列表或字符串的整数列表转换为字符串。
to_tuple(list)
将列表转换为元组。
update_at(list, index, fun)
返回具有指定位置的更新值的列表 index
wrap(list)
将参数包装在列表中。
zip(list_of_lists)
从中的每个列表中拉伸相应的元素 list_of_lists
函数
delete(list, item)
delete(list, any) :: list
删除给定item的list。返回没有该项目的新列表。
如果在item不止一次出现list，只是第一次出现被删除。
实例
iex> List.delete([:a, :b, :c], :a)
[:b, :c]
iex> List.delete([:a, :b, :b, :c], :b)
[:a, :b, :c]
delete_at(list, index)
delete_at(list, integer) :: list
通过删除指定的值生成新的列表index。
负指数表示从该结尾偏移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]
duplicate(elem, n)
duplicate(elem, non_neg_integer) :: [elem] when elem: var
在列表中复制给定的元素n时间。
实例
iex> List.duplicate("hello", 3)
["hello", "hello", "hello"]
iex> List.duplicate([1, 2], 2)
[[1, 2], [1, 2]]
first(list)
first([elem]) :: nil | elem when elem: var
返回第一个元素list或nil如果list是空的。
实例
iex> List.first([])
nil
iex> List.first([1])
1
iex> List.first([1, 2, 3])
1
flatten(list)
flatten(deep_list) :: list when deep_list: [any | deep_list]
使给定的list嵌套列表。
实例
iex> List.flatten([1, [[2], 3]])
[1, 2, 3]
flatten(list, tail)
flatten(deep_list, [elem]) :: [elem] when deep_list: [elem | deep_list], elem: var
使给定的list嵌套列表。名单tail将在扁平列表的末尾添加。
实例
iex> List.flatten([1, [[2], 3]], [4, 5])
[1, 2, 3, 4, 5]
foldl(list, acc, function)
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
foldr(list, acc, function)
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
insert_at(list, index, value)
insert_at(list, integer, any) :: list
返回value在指定位置插入的列表index。
请注意，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]
keydelete(list, key, position)
keydelete([tuple], any, non_neg_integer) :: [tuple]
接收list元组并删除第一个元组，该元组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]
keyfind(list, key, position, default \ nil)
keyfind([tuple], any, non_neg_integer, any) :: 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)
nil
keymember?(list, key, position)
keymember?([tuple], any, non_neg_integer) :: boolean
true如果存在元组中元素与position给定元素匹配的元组，则接收元组列表并返回key。
实例
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
keyreplace(list, key, position, new_tuple)
keyreplace([tuple], any, non_neg_integer, tuple) :: [tuple]
接收元组列表，并替换key在position如果它存在的话。
实例
iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
[a: 3, b: 2]
keysort(list, position)
keysort([tuple], non_neg_integer) :: [tuple]
接收元组列表并对position元组的。这种情况是稳定的。
实例
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]
keystore(list, key, position, new_tuple)
keystore([tuple], any, non_neg_integer, tuple) :: [tuple, ...]
接收一个list元组并替换keyat 标识的项目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]
keytake(list, key, position)
keytake([tuple], any, non_neg_integer) ::
{tuple, [tuple]} |
nil
接收list元组并返回元组中的元素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
last(list)
last([elem]) :: nil | elem when elem: var
中的最后一个元素list或nil如果list是空的。
实例
iex> List.last([])
nil
iex> List.last([1])
1
iex> List.last([1, 2, 3])
3
myers_difference(list1, list2)
myers_difference(list, list) ::
[{:eq | :ins | :del, list}] |
nil
返回表示编辑脚本的关键字列表。
该算法在E.Myers的“AnO（ND）Difference Algorithm and Its Variations”论文中概述。
一个编辑的脚本是一个关键词列表。每一个关键词描述了要采取的“编辑行动”以便list1更接近于平等list2; 一个密钥可以是:eq，:ins或:del。每个值都是应该插入（如果对应的键），删除（如果对应的键），或者单独（如果对应的键）在其中以便更接近的任一list1或list2那个子列表。:ins:del:eqlist1list2
实例
iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
[eq: [1], del: [4], eq: [2, 3], ins: [4]]
pop_at(list, index, default \ nil)
pop_at(list, integer, any) :: {any, list}
返回和删除指定值index的list。
负指数表示从该结尾偏移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]}
replace_at(list, index, value)
replace_at(list, integer, any) :: list
返回指定的具有替换值的列表index。
负指数表示从该结尾偏移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]
starts_with?(list, prefix)
starts_with?([], [...]) :: false
starts_with?(list, []) :: true
starts_with?(list, list) :: boolean
如果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
to_atom(charlist)
to_atom(charlist) :: atom
将字符列表转换为原子。
目前Elixir不支持包含Unicode代码点大于0xFF的charlists转换。
编译器插入。
实例
iex> List.to_atom('elixir')
:elixir
to_existing_atom(charlist)
to_existing_atom(charlist) :: atom
将charlist转换为现有原子。ArgumentError如果原子不存在，则引发一次。
目前Elixir不支持包含Unicode代码点大于0xFF的charlists转换。
编译器插入。
实例
iex> _ = :my_atom
iex> List.to_existing_atom('my_atom')
:my_atom
iex> List.to_existing_atom('this_atom_will_never_exist')
** (ArgumentError) argument error
to_float(charlist)
to_float(charlist) :: float
返回其文本表示形式的浮点数charlist。
编译器插入。
实例
iex> List.to_float('2.2017764e+0')
2.2017764
to_integer(charlist)
to_integer(charlist) :: integer
返回其文本表示形式的整数charlist。
编译器插入。
实例
iex> List.to_integer('123')
123
to_integer(charlist, base)
to_integer(charlist, 2..36) :: integer
返回其文本表示charlist以基数表示的整数base。
编译器插入。
实例
iex> List.to_integer('3FF', 16)
1023
to_string(list)
to_string(:unicode.charlist) :: String.t
将表示代码点、列表或字符串的整数列表转换为字符串。
注意这个函数需要一个表示UTF-8码点的整数列表。如果你有一个字节列表，你必须改用这个:binary模块。
实例
iex> List.to_string([0x00E6, 0x00DF])
"æß"
iex> List.to_string([0x0061, "bc"])
"abc"
to_tuple(list)
to_tuple(list) :: tuple
将列表转换为元组。
编译器插入。
实例
iex> List.to_tuple([:share, [:elixir, 163]])
{:share, [:elixir, 163]}
update_at(list, index, fun)
update_at([elem], integer, (elem -> any)) :: list when elem: var
返回具有指定位置的更新值的列表index。
负指数表示从该结尾偏移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]
wrap(list)
wrap(list | any) :: list
将参数包装在列表中。
如果参数已经是一个列表，则返回该列表。如果争论是nil，返回空列表。
实例
iex> List.wrap("hello")
["hello"]
iex> List.wrap([1, 2, 3])
[1, 2, 3]
iex> List.wrap(nil)
[]
zip(list_of_lists)
zip([list]) :: [tuple]
从中的每个列表中拉伸相应的元素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}]
