Источник Карта

Карты — это наиболее часто используемая структура данных «ключ-значение» в Elixir.

Карты можно создать с помощью синтаксиса %{}, а пары «ключ-значение» могут быть выражены как key => value.

iex> %{}
%{}
iex> %{"one" => :two, 3 => "four"}
%{3 => "four", "one" => :two}

Пары «ключ-значение» в карте не упорядочены (поэтому напечатанная карта в примере выше имеет другой порядок, чем карта, которая была создана).

Карты не накладывают никаких ограничений на тип ключа: ключом в карте может быть что угодно. В качестве структуры «ключ-значение» карты не допускают дублирования ключей. Ключи сравниваются с помощью оператора точного равенства (===/2). Если в литерале карты определены коллидирующие ключи, преобладает последний.

Если ключ в паре «ключ-значение» является атомом, можно использовать сокращённый синтаксис key: value (как и во многих других специальных формах):

iex> %{a: 1, b: 2}
%{a: 1, b: 2}

Если вы хотите смешать сокращённый синтаксис с =>, сокращённый синтаксис должен стоять в конце:

iex> %{"hello" => "world", a: 1, b: 2}
%{:a => 1, :b => 2, "hello" => "world"}

Доступ к ключам в картах можно получить через некоторые функции в этом модуле (например, Map.get/3 или Map.fetch/2) или через синтаксис map[], предоставляемый модулем Access:

iex> map = %{a: 1, b: 2}
iex> Map.fetch(map, :a)
{:ok, 1}
iex> map[:b]
2
iex> map["non_existing_key"]
nil

Для доступа к ключам-атомам можно также использовать запись map.key. Обратите внимание, что map.key вызовет исключение KeyError, если map не содержит ключ :key, в отличие от map[:key], который вернёт nil.

map = %{foo: "bar", baz: "bong"}
map.foo
#=> "bar"
map.non_existing_key
** (KeyError) key :non_existing_key not found in: %{baz: "bong", foo: "bar"}

Избегайте скобок

Не добавляйте скобки при обращении к полям, как в data.key(). Если скобки используются, Elixir ожидает, что data будет атомом, представляющим модуль, и попытается вызвать функцию key/0 в нём.

Два синтаксиса доступа к ключам раскрывают двойственную природу карт. Синтаксис map[key] используется для динамически создаваемых карт, которые могут иметь любой ключ любого типа. map.key используется с картами, содержащими предопределённый набор ключей-атомов, которые ожидаются всегда. Структуры, определённые с помощью defstruct/1, являются одним примером таких «статических карт», где ключи также могут проверяться во время компиляции.

Карты можно использовать в шаблонах.

iex> %{} = %{foo: "bar"}
%{foo: "bar"}
iex> %{a: a} = %{:a => 1, "b" => 2, [:c, :e, :e] => 3}
iex> a
1

Но это вызовет исключение MatchError:

%{:c => 3} = %{:a => 1, 2 => :b}

Переменные могут использоваться в качестве ключей карт как при записи литералов карт, так и при сопоставлении:

iex> n = 1
1
iex> %{n => :one}
%{1 => :one}
iex> %{^n => :one} = %{1 => :one, 2 => :two, 3 => :three}
%{1 => :one, 2 => :two, 3 => :three}

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

iex> map = %{one: 1, two: 2}
iex> %{map | one: "one"}
%{one: "one", two: 2}

Или любых других ключей:

iex> other_map = %{"three" => 3, "four" => 4, "five" => 5}
iex> %{other_map | "three" => "three", "four" => "four"}
%{"five" => 5, "four" => "four", "three" => "three"}

При обновлении ключа, которого нет в карте, будет выброшено исключение KeyError:

%{map | three: 3}

Функции в этом модуле, которые должны найти определённый ключ, работают за логарифмическое время. Это означает, что время, затрачиваемое на поиск ключей, растёт по мере увеличения карты, но не прямо пропорционально размеру карты. По сравнению с поиском элемента в списке, это работает лучше, потому что списки имеют линейную сложность времени. Некоторые функции, такие как keys/1 и values/1, работают за линейное время, потому что им нужно обратиться ко всем элементам карты.

Карты также реализуют протокол Enumerable, поэтому многие функции для работы с картами находятся в модуле Enum. Кроме того, следующие функции для карт находятся в Kernel:

map_size/1

Краткое описание

Функции

delete(map, key): Удаляет запись в map для определенного key.
drop(map, keys): Удаляет указанные keys из map.
equal?(map1, map2): Проверяет, равны ли два массива.
fetch(map, key): Извлекает значение для определенного key в заданном map.
fetch!(map, key): Извлекает значение для определенного key в заданном map, вызывая ошибку, если map не содержит key.
filter(map, fun): Возвращает массив, содержащий только те пары из map, для которых fun возвращает истинное значение.
from_keys(keys, value): Создает массив из заданных keys и фиксированного value.
from_struct(struct): Преобразует struct в массив.
get(map, key, default \\ nil): Получает значение для определенного key в map.
get_and_update(map, key, fun): Получает значение из key и обновляет его за один проход.
get_and_update!(map, key, fun): Получает значение из key и обновляет его за один проход. Вызывает ошибку, если там нет key.
get_lazy(map, key, fun): Получает значение для определенного key в map.
has_key?(map, key): Возвращает, существует ли заданный key в заданном map.
intersect(map1, map2): Пересекает два массива, возвращая массив с общими ключами.
intersect(map1, map2, fun): Пересекает два массива, возвращая массив с общими ключами и разрешая конфликты с помощью функции.
keys(map): Возвращает все ключи из map.
merge(map1, map2): Объединяет два массива в один.
merge(map1, map2, fun): Объединяет два массива в один, разрешая конфликты с помощью заданной fun.
new(): Возвращает новый пустой массив.
new(enumerable): Создает массив из перечисляемого объекта.
new(enumerable, transform): Создаёт массив из перечисляемого объекта с помощью заданной функции преобразования.
pop(map, key, default \\ nil): Удаляет значение, связанное с key в map и возвращает значение и обновлённый массив.
pop!(map, key): Удаляет и возвращает значение, связанное с key в map, вместе с обновлённым массивом, или вызывает ошибку, если key отсутствует.
pop_lazy(map, key, fun): Лениво возвращает и удаляет значение, связанное с key в map.
put(map, key, value): Добавляет указанное value под key в map.
put_new(map, key, value): Добавляет указанное value под key только в том случае, если запись key ещё не существует в map.
put_new_lazy(map, key, fun): Вычисляет fun и помещает результат под key в map только в том случае, если key ещё не существует.
reject(map, fun): Возвращает массив, исключая пары из map для которых fun возвращает истинное значение.
replace(map, key, value): Помещает значение под key только если key уже существует в map.
replace!(map, key, value): Помещает значение под key только если key уже существует в map.
replace_lazy(map, key, fun): Заменяет значение под key с помощью заданной функции только в том случае, если key уже существует в map.
split(map, keys): Берёт все записи, соответствующие заданным keys в map и извлекает их в отдельный массив.
split_with(map, fun): Разделяет map на два массива в соответствии с заданной функцией fun.
take(map, keys): Возвращает новый массив со всеми парами ключ-значение в map где ключ содержится в keys.
to_list(map): Преобразует map в список.
update(map, key, default, fun): Обновляет key в map с помощью заданной функции.
update!(map, key, fun): Обновляет key с помощью заданной функции.
values(map): Возвращает все значения из map.

END_OF_DOCUMENT_MARKER

Типы

key()Source

@type key() :: any()

value()Source

@type value() :: any()

Функции

delete(map, key)Source

@spec delete(map(), key()) :: map()

Удаляет запись в map для определенного key.

Если key не существует, возвращает map без изменений.

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

Примеры

iex> Map.delete(%{a: 1, b: 2}, :a)
%{b: 2}
iex> Map.delete(%{b: 2}, :a)
%{b: 2}

drop(map, keys)Source

@spec drop(map(), [key()]) :: map()

Удаляет заданные keys из map.

Если keys содержит ключи, которых нет в map, они просто игнорируются.

Примеры

iex> Map.drop(%{a: 1, b: 2, c: 3}, [:b, :d])
%{a: 1, c: 3}

equal?(map1, map2)Source

@spec equal?(map(), map()) :: boolean()

Проверяет, равны ли две карты.

Две карты считаются равными, если они содержат одни и те же ключи, и эти ключи содержат одинаковые значения.

Обратите внимание, что эта функция существует для полноты, поэтому модули Map и Keyword предоставляют аналогичные API. На практике разработчики часто сравнивают карты, используя ==/2 или ===/2 непосредственно.

Примеры

iex> Map.equal?(%{a: 1, b: 2}, %{b: 2, a: 1})
true
iex> Map.equal?(%{a: 1, b: 2}, %{b: 1, a: 2})
false

Сравнение ключей и значений выполняется с помощью ===/3, что означает, что целые числа не эквивалентны числам с плавающей запятой:

iex> Map.equal?(%{a: 1.0}, %{a: 1})
false

fetch(map, key)Source

@spec fetch(map(), key()) :: {:ok, value()} | :error

Извлекает значение для определенного key в заданной map.

Если map содержит заданный key, то его значение возвращается в виде {:ok, value}. Если map не содержит key, возвращается :error.

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

Примеры

iex> Map.fetch(%{a: 1}, :a)
{:ok, 1}
iex> Map.fetch(%{a: 1}, :b)
:error

fetch!(map, key)Source

@spec fetch!(map(), key()) :: value()

Извлекает значение для определенного key в заданной map, вызывая ошибку, если map не содержит key.

Если map содержит key, возвращается соответствующее значение. Если map не содержит key, возникает исключение KeyError.

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

Примеры

iex> Map.fetch!(%{a: 1}, :a)
1

filter(map, fun)Source

@spec filter(map(), ({key(), value()} -> as_boolean(term()))) :: map()

Возвращает карту, содержащую только те пары из map, для которых fun возвращает истинное значение.

fun получает ключ и значение каждого из элементов в карте в виде пары ключ-значение.

См. также reject/2, который отбрасывает все элементы, где функция возвращает истинное значение.

Соображения по производительности

Если вы обнаружите, что вы несколько раз вызываете Map.filter/2 и Map.reject/2 в конвейере, вероятно, будет эффективнее использовать Enum.map/2 и Enum.filter/2 вместо этого и преобразовать в карту в конце с помощью Map.new/1.

Примеры

iex> Map.filter(%{one: 1, two: 2, three: 3}, fn {_key, val} -> rem(val, 2) == 1 end)
%{one: 1, three: 3}

from_keys(keys, value)Source

@spec from_keys([key()], value()) :: map()

Создает карту из заданных keys и фиксированного value.

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

Примеры

iex> Map.from_keys([1, 2, 3], :number)
%{1 => :number, 2 => :number, 3 => :number}

from_struct(struct)Source

@spec from_struct(atom() | struct()) :: map()

Преобразует struct в карту.

Он принимает структуру и просто удаляет поле __struct__ из данной структуры.

Пример

defmodule User do
  defstruct [:name]
end

Map.from_struct(%User{name: "john"})
#=> %{name: "john"}

get(map, key, default \\ nil)Source

@spec get(map(), key(), value()) :: value()

Получает значение для определенного key в map.

Если key присутствует в map, то возвращается его значение value. В противном случае возвращается default.

Если default не указано, используется nil.

Примеры

iex> Map.get(%{}, :a)
nil
iex> Map.get(%{a: 1}, :a)
1
iex> Map.get(%{a: 1}, :b)
nil
iex> Map.get(%{a: 1}, :b, 3)
3
iex> Map.get(%{a: nil}, :a, 1)
nil

get_and_update(map, key, fun)Source

@spec get_and_update(map(), key(), (value() | nil ->
                                {current_value, new_value :: value()} | :pop)) ::
  {current_value, new_map :: map()}
when current_value: value()

Получает значение из key и обновляет его за один проход.

fun вызывается с текущим значением под key в map (или nil, если key отсутствует в map) и должен возвращать кортеж из двух элементов: текущее значение (извлеченное значение, которое может быть обработано перед возвратом) и новое значение, которое будет храниться под key в результирующей новой карте. fun также может возвращать :pop, что означает, что текущее значение должно быть удалено из map и возвращено (в результате чего эта функция будет вести себя как Map.pop(map, key)).

Возвращаемое значение представляет собой кортеж из двух элементов с текущим значением, возвращаемым fun, и новой картой с обновленным значением под key.

Примеры

iex> Map.get_and_update(%{a: 1}, :a, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{1, %{a: "new value!"}}

iex> Map.get_and_update(%{a: 1}, :b, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{nil, %{a: 1, b: "new value!"}}

iex> Map.get_and_update(%{a: 1}, :a, fn _ -> :pop end)
{1, %{}}

iex> Map.get_and_update(%{a: 1}, :b, fn _ -> :pop end)
{nil, %{a: 1}}

get_and_update!(map, key, fun)Source

@spec get_and_update!(map(), key(), (value() ->
                                 {current_value, new_value :: value()} | :pop)) ::
  {current_value, map()}
when current_value: value()

Получает значение из key и обновляет его за один проход. Вызывает исключение, если ключа нет.

Ведет себя точно так же, как get_and_update/3, но вызывает исключение KeyError, если key отсутствует в map.

Примеры

iex> Map.get_and_update!(%{a: 1}, :a, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{1, %{a: "new value!"}}

iex> Map.get_and_update!(%{a: 1}, :b, fn current_value ->
...>   {current_value, "new value!"}
...> end)
** (KeyError) key :b not found in: %{a: 1}

iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
...>   :pop
...> end)
{1, %{}}

get_lazy(map, key, fun)Source

@spec get_lazy(map(), key(), (-> value())) :: value()

Получает значение для определенного key в map.

Если key присутствует в map, то возвращается его значение value. В противном случае вычисляется fun и возвращается его результат.

Это полезно, если значение по умолчанию очень дорого вычисляется или его сложно настроить и снова удалить.

Примеры

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Map.get_lazy(map, :a, fun)
1
iex> Map.get_lazy(map, :b, fun)
13

has_key?(map, key)Source

@spec has_key?(map(), key()) :: boolean()

Возвращает, существует ли заданный key в заданной map.

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

Примеры

iex> Map.has_key?(%{a: 1}, :a)
true
iex> Map.has_key?(%{a: 1}, :b)
false

intersect(map1, map2)Source

@spec intersect(map(), map()) :: map()

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

Значения в возвращаемой карте являются значениями пересекающихся ключей в map2.

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

Примеры

iex> Map.intersect(%{a: 1, b: 2}, %{b: "b", c: "c"})
%{b: "b"}

intersect(map1, map2, fun)Source

@spec intersect(map(), map(), (key(), value(), value() -> value())) :: map()

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

Указанная функция будет вызвана при наличии дублирующихся ключей; ее аргументами являются key (дублирующийся ключ), value1 (значение key в map1), и value2 (значение key в map2). Возвращаемое значение fun используется в качестве значения под key в результирующем хэшмапе.

Примеры

iex> Map.intersect(%{a: 1, b: 2}, %{b: 2, c: 3}, fn _k, v1, v2 ->
...>   v1 + v2
...> end)
%{b: 4}

keys(map)Source

@spec keys(map()) :: [key()]

Возвращает все ключи из map.

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

Примеры

Map.keys(%{a: 1, b: 2})
[:a, :b]

merge(map1, map2)Source

@spec merge(map(), map()) :: map()

Объединяет два хэшмапа в один.

Все ключи из map2 будут добавлены в map1, перезаписывая любые существующие (то есть ключи из map2 имеют «преимущество» перед ключами в map1).

Если у вас есть структура и вы хотите объединить набор ключей в эту структуру, не используйте эту функцию, так как она объединит все ключи справа в структуру, даже если ключ не является частью структуры. Вместо этого используйте struct/2.

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

Примеры

iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
%{a: 3, b: 2, d: 4}

merge(map1, map2, fun)Source

@spec merge(map(), map(), (key(), value(), value() -> value())) :: map()

Объединяет два хэшмапа в один, разрешая конфликты с помощью заданной fun.

Все ключи из map2 будут добавлены в map1. Указанная функция будет вызвана при наличии дублирующихся ключей; ее аргументами являются key (дублирующийся ключ), value1 (значение key в map1 ), и value2 (значение key в map2). Возвращаемое значение fun используется в качестве значения под key в результирующем хэшмапе.

Примеры

iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4}, fn _k, v1, v2 ->
...>   v1 + v2
...> end)
%{a: 4, b: 2, d: 4}

new()Source

@spec new() :: map()

Возвращает новый пустой хэшмап.

Примеры

iex> Map.new()
%{}

new(enumerable)Source

@spec new(Enumerable.t()) :: map()

Создаёт хэшмап из enumerable.

Дублирующие ключи удаляются; последняя пара преобладает.

Примеры

iex> Map.new([{:b, 1}, {:a, 2}])
%{a: 2, b: 1}
iex> Map.new(a: 1, a: 2, a: 3)
%{a: 3}

new(enumerable, transform)Source

@spec new(Enumerable.t(), (term() -> {key(), value()})) :: map()

Создаёт хэшмап из enumerable через заданную функцию преобразования.

Дублирующие ключи удаляются; последняя пара преобладает.

Примеры

iex> Map.new([:a, :b], fn x -> {x, x} end)
%{a: :a, b: :b}

iex> Map.new(%{a: 2, b: 3, c: 4}, fn {key, val} -> {key, val * 2} end)
%{a: 4, b: 6, c: 8}

pop(map, key, default \\ nil)Source

@spec pop(map(), key(), default) :: {value(), updated_map :: map()} | {default, map()}
when default: value()

Удаляет значение, связанное с key в map и возвращает значение и обновлённый хэшмап.

Если key присутствует в map, возвращает {value, updated_map}, где value — значение ключа, а updated_map — результат удаления key из map. Если key отсутствует в map, возвращается {default, map}.

Примеры

iex> Map.pop(%{a: 1}, :a)
{1, %{}}
iex> Map.pop(%{a: 1}, :b)
{nil, %{a: 1}}
iex> Map.pop(%{a: 1}, :b, 3)
{3, %{a: 1}}

pop!(map, key)Source

@spec pop!(map(), key()) :: {value(), updated_map :: map()}

Удаляет и возвращает значение, связанное с key в map вместе с обновлённым хэшмапом, или поднимает исключение, если key отсутствует.

Ведёт себя так же, как pop/3, но поднимает исключение KeyError, если key отсутствует в map.

Примеры

iex> Map.pop!(%{a: 1}, :a)
{1, %{}}
iex> Map.pop!(%{a: 1, b: 2}, :a)
{1, %{b: 2}}
iex> Map.pop!(%{a: 1}, :b)
** (KeyError) key :b not found in: %{a: 1}

pop_lazy(map, key, fun)Source

@spec pop_lazy(map(), key(), (-> value())) :: {value(), map()}

Лениво возвращает и удаляет значение, связанное с key в map.

Если key присутствует в map, возвращает {value, new_map}, где value — значение ключа, а new_map — результат удаления key из map. Если key отсутствует в map, возвращается {fun_result, map}, где fun_result — результат применения fun.

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

Примеры

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Map.pop_lazy(map, :a, fun)
{1, %{}}
iex> Map.pop_lazy(map, :b, fun)
{13, %{a: 1}}

put(map, key, value)Source

@spec put(map(), key(), value()) :: map()

Помещает заданное value под key в map.

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

Примеры

iex> Map.put(%{a: 1}, :b, 2)
%{a: 1, b: 2}
iex> Map.put(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

put_new(map, key, value)Source

@spec put_new(map(), key(), value()) :: map()

Помещает заданное value под key , если запись key ещё не существует в map.

Примеры

iex> Map.put_new(%{a: 1}, :b, 2)
%{a: 1, b: 2}
iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
%{a: 1, b: 2}

put_new_lazy(map, key, fun)Source

@spec put_new_lazy(map(), key(), (-> value())) :: map()

Вычисляет fun и помещает результат под key в map , если key ещё не существует.

Эта функция полезна в случае, когда вы хотите вычислить значение для помещения под key только в том случае, если key ещё не существует, например, когда значение сложно вычислить или его сложно настроить и завершить.

Примеры

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   3
...> end
iex> Map.put_new_lazy(map, :a, fun)
%{a: 1}
iex> Map.put_new_lazy(map, :b, fun)
%{a: 1, b: 3}

reject(map, fun)Source

@spec reject(map(), ({key(), value()} -> as_boolean(term()))) :: map()

Возвращает хэшмап, исключая пары из map, для которых fun возвращает истинное значение.

См. также filter/2.

Примеры

iex> Map.reject(%{one: 1, two: 2, three: 3}, fn {_key, val} -> rem(val, 2) == 1 end)
%{two: 2}

replace(map, key, value)Source

@spec replace(map(), key(), value()) :: map()

Помещает значение под key только в том случае, если key уже существует в map.

Примеры

iex> Map.replace(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

iex> Map.replace(%{a: 1}, :b, 2)
%{a: 1}

replace!(map, key, value)Source

@spec replace!(map(), key(), value()) :: map()

Записывает значение под key только если key уже существует в map.

Если key отсутствует в map, генерируется исключение KeyError.

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

Примеры

iex> Map.replace!(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

iex> Map.replace!(%{a: 1}, :b, 2)
** (KeyError) key :b not found in: %{a: 1}

replace_lazy(map, key, fun)Source

@spec replace_lazy(map(), key(), (existing_value :: value() -> new_value :: value())) ::
  map()

Заменяет значение под key с помощью заданной функции только если key уже существует в map.

По сравнению с replace/3, это может быть полезно, когда вычисление значения является дорогостоящим.

Если key не существует, исходный массив возвращается без изменений.

Примеры

iex> Map.replace_lazy(%{a: 1, b: 2}, :a, fn v -> v * 4 end)
%{a: 4, b: 2}

iex> Map.replace_lazy(%{a: 1, b: 2}, :c, fn v -> v * 4 end)
%{a: 1, b: 2}

split(map, keys)Source

@spec split(map(), [key()]) :: {map(), map()}

Возвращает все записи, соответствующие заданным keys в map и извлекает их в отдельный массив.

Возвращает кортеж с новым массивом и старым массивом с удалёнными ключами.

Ключи, для которых в map нет записей, игнорируются.

Примеры

iex> Map.split(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
{%{a: 1, c: 3}, %{b: 2}}

split_with(map, fun)Source

@spec split_with(map(), ({key(), value()} -> as_boolean(term()))) :: {map(), map()}

Разделяет map на два массива в соответствии с заданной функцией fun.

fun получает каждую {key, value} пару в map в качестве единственного аргумента. Возвращает кортеж с первым массивом, содержащим все элементы из map для которых применение fun возвращает истинное значение, и второй массив со всеми элементами, для которых применение fun возвращает ложное значение (false или nil).

Примеры

iex> Map.split_with(%{a: 1, b: 2, c: 3, d: 4}, fn {_k, v} -> rem(v, 2) == 0 end)
{%{b: 2, d: 4}, %{a: 1, c: 3}}

iex> Map.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {k, _v} -> k in [:b, :d] end)
{%{b: -2, d: -3}, %{a: 1, c: 1}}

iex> Map.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {_k, v} -> v > 50 end)
{%{}, %{a: 1, b: -2, c: 1, d: -3}}

iex> Map.split_with(%{}, fn {_k, v} -> v > 50 end)
{%{}, %{}}

take(map, keys)Source

@spec take(map(), [key()]) :: map()

Возвращает новый массив со всеми парами ключ-значение в map где ключ находится в keys.

Если keys содержит ключи, которые не находятся в map, они просто игнорируются.

Примеры

iex> Map.take(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
%{a: 1, c: 3}

to_list(map)Source

@spec to_list(map()) :: [{term(), term()}]

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

Каждая пара ключ-значение в массиве преобразуется в двухэлементный кортеж {key, value} в результирующем списке.

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

Примеры

iex> Map.to_list(%{a: 1})
[a: 1]
iex> Map.to_list(%{1 => 2})
[{1, 2}]

update(map, key, default, fun)Source

@spec update(map(), key(), default :: value(), (existing_value :: value() ->
                                            new_value :: value())) ::
  map()

Обновляет key в map с помощью заданной функции.

Если key присутствует в map, то существующее значение передаётся в fun, и результат используется в качестве обновлённого значения key. Если key отсутствует в map, default вставляется в качестве значения key. Значение по умолчанию не будет передаваться через функцию обновления.

Примеры

iex> Map.update(%{a: 1}, :a, 13, fn existing_value -> existing_value * 2 end)
%{a: 2}
iex> Map.update(%{a: 1}, :b, 11, fn existing_value -> existing_value * 2 end)
%{a: 1, b: 11}

update!(map, key, fun)Source

@spec update!(map(), key(), (existing_value :: value() -> new_value :: value())) ::
  map()

Обновляет key с помощью заданной функции.

Если key присутствует в map, то существующее значение передаётся в fun, и результат используется в качестве обновлённого значения key. Если key отсутствует в map, генерируется исключение KeyError.

Примеры

iex> Map.update!(%{a: 1}, :a, &(&1 * 2))
%{a: 2}

iex> Map.update!(%{a: 1}, :b, &(&1 * 2))
** (KeyError) key :b not found in: %{a: 1}

values(map)Source

@spec values(map()) :: [value()]

Возвращает все значения из map.

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

Примеры

Map.values(%{a: 1, b: 2})
[1, 2]