Исходный код Словарь

Словари являются основным типом данных для хранения пар «ключ-значение» в 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}
iex> %{other_map | "three" => "three"}
%{"four" => 4, "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.

Типы

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 или сам struct и просто удаляет поле __struct__ из заданного struct или из нового struct, созданного из заданного модуля.

Пример

defmodule User do
  defstruct [:name]
end

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

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 и обновляет его за один проход. Вызывает исключение, если нет 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, но вызывает исключение, если 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]