Список

Функции, работающие со (связанными) списками.

Многие функции, предоставляемые для списков, которые реализуют протокол Enumerable, находятся в модуле Enum.

Кроме того, следующие функции и операторы для списков находятся в Kernel:

• ++/2
• --/2
• hd/1
• tl/1
• in/2
• length/1

В 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]

Списки в Elixir фактически являются связанными списками, что означает, что они внутренне представлены парами, содержащими голову и хвост списка:

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]

Кроме того, получение длины списка и доступ к нему по индексу являются линейными операциями. Отрицательные индексы также поддерживаются, но они подразумевают, что список будет проитерирован дважды, один раз для расчета правильного индекса и другой раз для выполнения операции.

Списки символов

Если список состоит из целых чисел без знака, он также может называться списком символов. Elixir использует одинарные кавычки для определения списков символов:

iex> 'héllo'
[104, 233, 108, 108, 111]

В частности, списки символов могут быть напечатаны обратно в одинарные кавычки, если они содержат только символы 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'}
#=>  ]

Можно проверить, состоит ли список из напечатаемых символов ASCII с помощью ascii_printable?/2.

Резюме

Функции

ascii_printable?(list, limit \\ :infinity)

Проверяет, является ли list списком символов, состоящим только из печатаемых символов ASCII.

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, fun)

Складывает (сокращает) заданный список слева с помощью функции. Требуется накопитель.

foldr(list, acc, fun)

Складывает (сокращает) заданный список справа с помощью функции. Требуется накопитель.

improper?(list)

Возвращает true если list является ненадлежащим списком. В противном случае возвращает false.

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)

Получает список кортежей и, если идентифицированный элемент по key в позиции position существует, заменяет его на new_tuple.

keysort(list, position)

Получает список кортежей и сортирует элементы по position кортежей. Сортировка стабильная.

keystore(list, key, position, new_tuple)

Получает list кортежей и заменяет элемент, идентифицированный по key в позиции position, на new_tuple.

keytake(list, key, position)

Получает list кортежей и возвращает первый кортеж, где элемент по position в кортеже соответствует заданному key, а также list без найденного кортежа.

last(list)

Возвращает последний элемент в list или nil, если list пустой.

myers_difference(list1, list2)

Возвращает список ключевых слов, представляющий сценарий редактирования.

myers_difference(list1, list2, diff_script)

Возвращает список ключевых слов, представляющий сценарий редактирования со вложенными различиями.

pop_at(list, index, default \\ nil)

Возвращает и удаляет значение по указанному index в list.

replace_at(list, index, value)

Возвращает список со значением, заменённым в указанной позиции index.

starts_with?(list, prefix)

Возвращает true если list начинается с указанного prefix списка; в противном случае возвращает false.

to_atom(charlist)

Преобразует список символов в атом.

to_charlist(list)

Преобразует список целых чисел, представляющих код символов, списки или строки, в список символов.

to_existing_atom(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(term)

Оборачивает term в список, если это не список.

zip(list_of_lists)

Комбинирует соответствующие элементы из каждого списка в list_of_lists.

Функции

ascii_printable?(list, limit \\ :infinity)

ascii_printable?(list(), limit) :: boolean()
when limit: :infinity | non_neg_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?('abc')
true

iex> List.ascii_printable?('abc' ++ [0])
false

iex> List.ascii_printable?('abc' ++ [0], 2)
true

Неправильные списки не печатаются, даже если они состоят только из символов ASCII:

iex> List.ascii_printable?('abc' ++ ?d)
false

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, fun)

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, fun)

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

improper?(list)

improper?(maybe_improper_list()) :: boolean()

Возвращает true, если list является несобственным списком. В противном случае возвращает false.

Примеры

iex> List.improper?([1, 2 | 3]) true

iex> List.improper?([1, 2, 3]) false

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 существует, заменяет его на 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]

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 кортежей и заменяет элемент, определённый по key в позиции position, на new_tuple.

Если элемент не существует, он добавляется в конец 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()}]

Возвращает список ключевых слов, представляющий сценарий редактирования.

Алгоритм описан в статье «Алгоритм различий O(ND) и его модификации» Э. Майерса.

Сценарий редактирования — это список ключевых слов. Каждый ключ описывает «действие редактирования», которое необходимо выполнить, чтобы приблизить 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]]

myers_difference(list1, list2, diff_script)

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"]]

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?(list(), list()) :: boolean()

starts_with?(list(), []) :: true

starts_with?([], [...]) :: false

Возвращает true, если list начинается с заданного prefix списка; в противном случае возвращает 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 поддерживает преобразования из списков символов, которые содержат любые символы Юникода.

Встроенная компилятором.

Примеры

iex> List.to_atom('Elixir')
:Elixir

iex> List.to_atom('🌢 Elixir')
:"🌢 Elixir"

to_charlist(list)

to_charlist(:unicode.charlist()) :: charlist()

Преобразует список целых чисел, представляющих код символов, списки или строки в список символов.

Обратите внимание, что эта функция ожидает список целых чисел, представляющих UTF-8 коды символов. Если у вас есть список байтов, вам необходимо использовать модуль :binary.

Примеры

iex> List.to_charlist([0x00E6, 0x00DF])
'æß'

iex> List.to_charlist([0x0061, "bc"])
'abc'

iex> List.to_charlist([0x0064, "ee", ['p']])
'deep'

to_existing_atom(charlist)

to_existing_atom(charlist()) :: atom()

Преобразует список символов в существующий атом. Вызывает исключение ArgumentError, если атом не существует.

Elixir поддерживает преобразования из списков символов, которые содержат любые символы Юникода.

Встроенная компилятором.

Примеры

iex> _ = :my_atom
iex> List.to_existing_atom('my_atom')
:my_atom

iex> _ = :"🌢 Elixir"
iex> List.to_existing_atom('🌢 Elixir')
:"🌢 Elixir"

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"

iex> List.to_string([0x0064, "ee", ['p']])
"deep"

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(term)

wrap(nil) :: []

wrap(list) :: list when list: maybe_improper_list()

wrap(term) :: [term, ...] when term: any()

Оборачивает term в список, если это не список.

Если term уже является списком, возвращается список. Если term является 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}]