列表 | 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}]

本文档系腾讯云开发者社区成员共同维护，如有问题请联系 cloudcommunity@tencent.com

最后更新于：2017-12-18