Сравнение языков программирования (ассоциативный массив)

В этом сравнении языков программирования (ассоциативных массивов) сравниваются особенности ассоциативных массивов структур данных или обработки поиска в массиве для более чем 40 языков компьютерного программирования .

Языковая поддержка

Это динамический список , и он, возможно, никогда не сможет соответствовать определенным стандартам полноты. Вы можете помочь, добавив недостающие элементы из надежных источников .

Ниже приводится сравнение ассоциативных массивов (также «отображений», «хэшей» и «словарей») в различных языках программирования.

АВК

AWK имеет встроенную поддержку ассоциативных массивов на уровне языка.

Например:

phonebook["Sally Smart"] = "555-9999"
phonebook["John Doe"] = "555-1212"
phonebook["J. Random Hacker"] = "555-1337"

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

for (name in phonebook) {
	print name, " ", phonebook[name]
}

Пользователь может искать элементы в ассоциативном массиве и удалять элементы из массива.

Ниже показано, как в стандартном AWK можно моделировать многомерные ассоциативные массивы с использованием конкатенации и встроенной переменной-разделителя строк SUBSEP:

{ # for every input line
	multi[$1 SUBSEP $2]++;
}
#
END {
	for (x in multi) {
		split(x, arr, SUBSEP);
		print arr[1], arr[2], multi[x];
	}
}

С

нет стандартной реализации ассоциативных массивов В C , но доступна сторонняя библиотека C Hash Table с лицензией BSD.

Другая сторонняя библиотека, uthash, также создает ассоциативные массивы из структур C. Структура представляет значение, а одно из полей структуры служит ключом.

Наконец, библиотека GLib также поддерживает ассоциативные массивы наряду со многими другими расширенными типами данных и является рекомендуемой реализацией проекта GNU.

Подобно GLib , от Apple кросс-платформенная платформа Core Foundation предоставляет несколько основных типов данных. В частности, существуют CFDictionary и CFMutableDictionary с подсчетом ссылок.

С#

C# использует классы коллекций, предоставляемые .NET Framework . Наиболее часто используемый тип ассоциативного массива: System.Collections.Generic.Dictionary<TKey, TValue>, который реализован как изменяемая хэш-таблица. Относительно новый System.Collections.Immutable пакет, доступный в .NET Framework версии 4.5 и выше, а также во всех версиях .NET Core , также включает в себя System.Collections.Immutable.Dictionary<TKey, TValue> тип, который реализован с помощью AVL-дерева . Методы, которые обычно изменяют объект на месте, вместо этого возвращают новый объект, который представляет состояние исходного объекта после мутации.

Создание

Ниже демонстрируются три способа заполнения изменяемого словаря:

• тот Add метод, который добавляет ключ и значение и выдает исключение, если ключ уже существует в словаре;
• назначение индексатору, который перезаписывает любое существующее значение, если оно присутствует; и
• присвоение резервному свойству индексатора, для которого индексатор является синтаксическим сахаром (не применимо к C#, см. примеры F# или VB.NET ).

var dictionary = new Dictionary<string, string>();
dictionary.Add("Sally Smart", "555-9999");
dictionary["John Doe"] = "555-1212";
// Not allowed in C#.
// dictionary.Item("J. Random Hacker") = "553-1337";
dictionary["J. Random Hacker"] = "553-1337";

Словарь также можно инициализировать во время создания с помощью «инициализатора коллекции», который компилируется в повторяющиеся вызовы Add.

var dictionary = new Dictionary<string, string> {
    { "Sally Smart", "555-9999" },
    { "John Doe", "555-1212" },
    { "J. Random Hacker", "553-1337" }
};

Доступ по ключу

Значения в основном извлекаются с помощью индексатора (который выдает исключение, если ключ не существует) и TryGetValue метод, который имеет выходной параметр для искомого значения и логическое возвращаемое значение, указывающее, был ли ключ найден.

var sallyNumber = dictionary["Sally Smart"];

var sallyNumber = (dictionary.TryGetValue("Sally Smart", out var result) ? result : "n/a";

В этом примере sallyNumber значение теперь будет содержать строку "555-9999".

Перечисление

Словарь можно рассматривать как последовательность ключей, последовательность значений или последовательность пар ключей и значений, представленных экземплярами KeyValuePair<TKey, TValue> типа, хотя гарантии порядка нет. Для отсортированного словаря программист может использовать SortedDictionary<TKey, TValue> или используйте .Sort LINQ Метод расширения при перечислении.

Ниже показано перечисление с использованием цикла foreach :

// loop through the collection and display each entry.
foreach (KeyValuePair<string,string> kvp in dictionary)
{
    Console.WriteLine("Phone number for {0} is {1}", kvp.Key, kvp.Value);
}

С++

В C++ есть форма ассоциативного массива, называемая std::map (см. Стандартная библиотека шаблонов#Контейнеры ). Карту телефонной книги можно создать с помощью следующего кода на C++:

#include <map>
#include <string>
#include <utility>
 
int main() {
	std::map<std::string, std::string> phone_book;
	phone_book.insert(std::make_pair("Sally Smart", "555-9999"));
	phone_book.insert(std::make_pair("John Doe", "555-1212"));
	phone_book.insert(std::make_pair("J. Random Hacker", "553-1337"));
}

Или менее эффективно, поскольку это создает временные std::string ценности:

#include <map>
#include <string>
 
int main() {
	std::map<std::string, std::string> phone_book;
	phone_book["Sally Smart"] = "555-9999";
	phone_book["John Doe"] = "555-1212";
	phone_book["J. Random Hacker"] = "553-1337";
}

Благодаря расширению списков инициализации в C++11 записи можно добавлять во время построения карты, как показано ниже:

#include <map>
#include <string>

int main() {
	std::map<std::string, std::string> phone_book {
		{"Sally Smart", "555-9999"},
		{"John Doe", "555-1212"},
		{"J. Random Hacker", "553-1337"}
	};
}

Вы можете перебирать список с помощью следующего кода (C++03):

std::map<std::string, std::string>::iterator curr, end;
for(curr = phone_book.begin(), end = phone_book.end();  curr != end;  ++curr)
	std::cout <<  curr->first << " = " << curr->second << std::endl;

Та же задача в C++11:

for(const auto& curr : phone_book)
        std::cout <<  curr.first << " = " << curr.second << std::endl;

Использование структурированной привязки, доступной в C++17 :

for (const auto& [name, number] : phone_book) {
    std::cout << name << " = " << number << std::endl;
}

В С++ std::map Класс является шаблонным , что позволяет типам данных ключей и значений быть разными для разных map экземпляры. Для данного экземпляра map class, ключи должны быть одного и того же базового типа. То же самое должно быть верно для всех ценностей. Хотя std::map обычно реализуется с использованием самобалансирующегося двоичного дерева поиска , C++11 определяет вторую карту, называемую std::unordered_map, который имеет алгоритмические характеристики хеш-таблицы. распространенное расширение стандартной библиотеки шаблонов (STL), обычно называемое Это также hash_map, доступный в таких реализациях, как SGI и STLPort.

Кобра

Инициализация пустого словаря и добавление элементов в Cobra :

 dic as Dictionary<of String, String> = Dictionary<of String, String>()
 dic.add('Sally Smart', '555-9999')
 dic.add('John Doe', '555-1212')
 dic.add('J. Random Hacker', '553-1337')
 
 assert dic['Sally Smart'] == '555-9999'

В качестве альтернативы словарь может быть инициализирован всеми элементами во время создания:

 dic = {
           'Sally Smart':'555-9999',
           'John Doe':'555-1212',
           'J. Random Hacker':'553-1337'
       }

Словарь можно перечислить с помощью цикла for, но гарантированного порядка не существует:

 for key, val in dic
     print "[key]'s phone number is [val]"

Язык разметки ColdFusion

Структура в языке разметки ColdFusion (CFML) эквивалентна ассоциативному массиву:

dynamicKeyName = "John Doe";
phoneBook = {
	"Sally Smart" = "555-9999",
	"#dynamicKeyName#" = "555-4321",
	"J. Random Hacker" = "555-1337",	
	UnknownComic = "???"
};
writeOutput(phoneBook.UnknownComic); // ???
writeDump(phoneBook); // entire struct

Д

D предлагает прямую поддержку ассоциативных массивов на основном языке; такие массивы реализованы как цепочка хеш-таблиц с двоичными деревьями. Эквивалентным примером может быть:

int main() {
	string[ string ] phone_book;
	phone_book["Sally Smart"] = "555-9999";
	phone_book["John Doe"] = "555-1212";
	phone_book["J. Random Hacker"] = "553-1337";
	return 0;
}

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

Перебор всех свойств и связанных значений и их печать можно закодировать следующим образом:

foreach (key, value; phone_book) {
        writeln("Number for " ~ key ~ ": " ~ value );
}

Свойство можно удалить следующим образом:

phone_book.remove("Sally Smart");

Дельфи

Delphi поддерживает несколько стандартных контейнеров, включая TDictionary<T>:

uses
  SysUtils,
  Generics.Collections;

var
  PhoneBook: TDictionary<string, string>;
  Entry: TPair<string, string>;

begin
  PhoneBook := TDictionary<string, string>.Create;
  PhoneBook.Add('Sally Smart', '555-9999');
  PhoneBook.Add('John Doe', '555-1212');
  PhoneBook.Add('J. Random Hacker', '553-1337');

  for Entry in PhoneBook do
    Writeln(Format('Number for %s: %s',[Entry.Key, Entry.Value]));
end.

Версии Delphi до 2009 года не поддерживают напрямую ассоциативные массивы. Такие массивы можно моделировать с помощью класса TStrings:

procedure TForm1.Button1Click(Sender: TObject);
var
  DataField: TStrings;
  i: Integer;
begin
  DataField := TStringList.Create;

  DataField.Values['Sally Smart'] := '555-9999';
  DataField.Values['John Doe'] := '555-1212';
  DataField.Values['J. Random Hacker'] := '553-1337';

  // access an entry and display it in a message box
  ShowMessage(DataField.Values['Sally Smart']);

  // loop through the associative array 
  for i := 0 to DataField.Count - 1 do
  begin
    ShowMessage('Number for ' + DataField.Names[i] + ': ' + DataField.ValueFromIndex[i]);
  end;

  DataField.Free;
end;

Эрланг

Erlang предлагает множество способов представления отображений; три наиболее распространенных в стандартной библиотеке — это списки ключей, словари и карты.

Списки клавиш

Списки ключей — это списки кортежей , где первый элемент каждого кортежа — это ключ, а второй — значение. Функции для работы со списками клавиш представлены в разделе lists модуль.

PhoneBook = [{"Sally Smith", "555-9999"},
             {"John Doe", "555-1212"},
             {"J. Random Hacker", "553-1337"}].

Доступ к элементу списка ключей можно осуществить с помощью lists:keyfind/3 функция:

{_, Phone} = lists:keyfind("Sally Smith", 1, PhoneBook),
io:format("Phone number: ~s~n", [Phone]).

Словари

Словари реализованы в dict модуль стандартной библиотеки. Новый словарь создается с помощью dict:new/0 функция и новые пары ключ/значение сохраняются с использованием dict:store/3 функция:

PhoneBook1 = dict:new(),
PhoneBook2 = dict:store("Sally Smith", "555-9999", Dict1),
PhoneBook3 = dict:store("John Doe", "555-1212", Dict2),
PhoneBook = dict:store("J. Random Hacker", "553-1337", Dict3).

Такая последовательная инициализация была бы более идиоматично представлена ​​в Erlang соответствующей функцией:

PhoneBook = dict:from_list([{"Sally Smith", "555-9999"},
                            {"John Doe", "555-1212"},
                            {"J. Random Hacker", "553-1337"}]).

Доступ к словарю можно получить с помощью dict:find/2 функция:

{ok, Phone} = dict:find("Sally Smith", PhoneBook),
io:format("Phone: ~s~n", [Phone]).

В обоих случаях в качестве ключа можно использовать любой термин Эрланга. Вариации включают в себя orddict модуль, реализующий упорядоченные словари, и gb_trees, реализуя общие сбалансированные деревья.

Карты

Карты были представлены в OTP 17.0, и объединить сильные стороны списков клавиш и словарей. Карта определяется с использованием синтаксиса #{ K1 => V1, ... Kn => Vn }:

PhoneBook = #{"Sally Smith" => "555-9999",
              "John Doe" => "555-1212",
              "J. Random Hacker" => "553-1337"}.

Основные функции для взаимодействия с картами доступны из maps модуль. Например, maps:find/2 функция возвращает значение, связанное с ключом:

{ok, Phone} = maps:find("Sally Smith", PhoneBook),
io:format("Phone: ~s~n", [Phone]).

В отличие от словарей, карты могут быть сопоставлены с образцом:

#{"Sally Smith", Phone} = PhoneBook,
io:format("Phone: ~s~n", [Phone]).

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

PhoneBook2 = PhoneBook#{
    % the `:=` operator updates the value associated with an existing key
    "J. Random Hacker" := "355-7331",

    % the `=>` operator adds a new key-value pair, potentially replacing an existing one
    "Alice Wonderland" => "555-1865"
}

Ф#

Карта<'Ключ,'Значение>

Во время выполнения F# предоставляет Collections.Map<'Key,'Value> type, который представляет собой неизменяемое дерево AVL .

Создание

В следующем примере вызывается Map конструктор, который работает со списком (последовательностью элементов, разделенных точкой с запятой, заключенной в квадратные скобки) кортежей (которые в F# представляют собой последовательности элементов, разделенных запятыми).

let numbers =
    [
        "Sally Smart", "555-9999"; 
        "John Doe", "555-1212";
        "J. Random Hacker", "555-1337"
    ] |> Map

Доступ по ключу

Значения можно просмотреть с помощью одного из Map члены, такие как его индексатор или Item свойство (которое генерирует исключение , если ключ не существует) или TryFind функция, которая возвращает тип опции со значением Some <result>, для успешного поиска, или None, за неудачный. Затем можно использовать сопоставление с образцом для извлечения необработанного значения из результата или установить значение по умолчанию.

let sallyNumber = numbers.["Sally Smart"]
// or
let sallyNumber = numbers.Item("Sally Smart")

let sallyNumber =
    match numbers.TryFind("Sally Smart") with
    | Some(number) -> number
    | None         -> "n/a"

В обоих приведенных выше примерах sallyNumber значение будет содержать строку "555-9999".

Словарь<'TKey,'TValue>

Поскольку F# — это язык .NET, он также имеет доступ к функциям .NET Framework , включая System.Collections.Generic.Dictionary<'TKey,'TValue> type (который реализован в виде хеш-таблицы ), который является основным типом ассоциативного массива, используемым в C# и Visual Basic. Этот тип может быть предпочтителен при написании кода, предназначенного для работы с другими языками в .NET Framework, или когда характеристики производительности хеш-таблицы предпочтительнее характеристик производительности дерева AVL.

Создание

The dict Функция предоставляет средства удобного создания словаря .NET, который не предназначен для изменения; он принимает последовательность кортежей и возвращает неизменяемый объект, реализующий IDictionary<'TKey,'TValue>.

let numbers =
    [
        "Sally Smart", "555-9999"; 
        "John Doe", "555-1212";
        "J. Random Hacker", "555-1337"
    ] |> dict

Когда необходим изменяемый словарь, конструктор System.Collections.Generic.Dictionary<'TKey,'TValue> можно позвонить напрямую. см. в примере C# на этой странице Дополнительную информацию .

let numbers = System.Collections.Generic.Dictionary<string, string>()
numbers.Add("Sally Smart", "555-9999")
numbers.["John Doe"] <- "555-1212"
numbers.Item("J. Random Hacker") <-  "555-1337"

Доступ по ключу

IDictionary экземпляры имеют индексатор, который используется так же, как и Map, хотя это эквивалентно TryFind является TryGetValue, который имеет выходной параметр для искомого значения и возвращаемое логическое значение, указывающее, был ли ключ найден.

let sallyNumber =
    let mutable result = ""
    if numbers.TryGetValue("Sally Smart", &result) then result else "n/a"

F# также позволяет вызывать функцию так, как если бы она не имела выходного параметра и вместо этого возвращала кортеж, содержащий ее обычное возвращаемое значение и значение, присвоенное выходному параметру:

let sallyNumber =
    match numbers.TryGetValue("Sally Smart") with
    | true, number -> number
    | _     -> "n/a"

Перечисление

Словарь или карту можно перечислить с помощью Seq.map.

// loop through the collection and display each entry.
numbers |> Seq.map (fun kvp -> printfn "Phone number for %O is %O" kvp.Key kvp.Value)

ФоксПро

Visual FoxPro реализует сопоставление с помощью класса коллекции.

mapping = NEWOBJECT("Collection")
mapping.Add("Daffodils", "flower2") && Add(object, key) – key must be character
index   = mapping.GetKey("flower2") && returns the index value 1
object  = mapping("flower2")        && returns "Daffodils" (retrieve by key)
object  = mapping(1)                && returns "Daffodils" (retrieve by index)

GetKey возвращает 0, если ключ не найден.

Идти

Go имеет встроенную поддержку ассоциативных массивов на уровне языка, называемых «картами». Тип ключа карты может быть только логическим, числовым, строковым, массивом, структурой, указателем, интерфейсом или типом канала.

Тип карты пишется: map[keytype]valuetype

Добавляем элементы по одному:

phone_book := make(map[string] string) // make an empty map
phone_book["Sally Smart"] = "555-9999"
phone_book["John Doe"] = "555-1212"
phone_book["J. Random Hacker"] = "553-1337"

Литерал карты:

phone_book := map[string] string {
	"Sally Smart": "555-9999",
	"John Doe": "555-1212",
	"J. Random Hacker": "553-1337",
}

Итерация по карте:

// over both keys and values
for key, value := range phone_book {
	fmt.Printf("Number for %s: %s\n", key, value)
}

// over just keys
for key := range phone_book {
	fmt.Printf("Name: %s\n", key)
}

Хаскелл

Язык программирования Haskell предоставляет только один вид ассоциативного контейнера — список пар:

m = [("Sally Smart", "555-9999"), ("John Doe", "555-1212"), ("J. Random Hacker", "553-1337")]

main = print (lookup "John Doe" m)

выход:

Just "555-1212"

Обратите внимание, что функция поиска возвращает значение «Может быть», которое равно «Ничего», если не найдено, или «Просто «результат » », если найдено.

Компилятор Glasgow Haskell (GHC), наиболее часто используемая реализация Haskell, предоставляет еще два типа ассоциативных контейнеров. Другие реализации также могут обеспечить это.

Один из них — полиморфные функциональные карты (представленные в виде неизменяемых сбалансированных двоичных деревьев):

import qualified Data.Map as M

m = M.insert "Sally Smart" "555-9999" M.empty
m' = M.insert "John Doe" "555-1212" m
m'' = M.insert "J. Random Hacker" "553-1337" m'

main = print (M.lookup "John Doe" m'' :: Maybe String)

выход:

Just "555-1212"

Специализированная версия для целочисленных ключей также существует как Data.IntMap.

Наконец, полиморфная хэш-таблица:

import qualified Data.HashTable as H

main = do m <- H.new (==) H.hashString
          H.insert m "Sally Smart" "555-9999"
          H.insert m "John Doe" "555-1212"
          H.insert m "J. Random Hacker" "553-1337"
          foo <- H.lookup m "John Doe"
          print foo

выход:

Just "555-1212"

Списки пар и функциональные карты предоставляют чисто функциональный интерфейс, который в Haskell более идиоматичен. Напротив, хеш-таблицы предоставляют императивный интерфейс в монаде ввода-вывода .

Ява

В Java ассоциативные массивы реализованы как «карты», которые являются частью структуры коллекций Java . Начиная с J2SE 5.0 и появления дженериков в Java, для коллекций может быть указан тип; например, ассоциативный массив, который сопоставляет строки со строками, может быть указан следующим образом:

Map<String, String> phoneBook = new HashMap<String, String>();
phoneBook.put("Sally Smart", "555-9999");
phoneBook.put("John Doe", "555-1212");
phoneBook.put("J. Random Hacker", "555-1337");

The get метод используется для доступа к ключу; например, значение выражения phoneBook.get("Sally Smart") является "555-9999". Этот код использует хэш-карту для хранения ассоциативного массива, вызывая конструктор HashMap сорт. Однако, поскольку в коде используются только методы, общие для интерфейса Mapсамобалансирующееся двоичное дерево можно использовать, вызвав конструктор TreeMap класс (который реализует подинтерфейс SortedMap), не меняя определения phoneBook переменную или остальную часть кода или использование других базовых структур данных, которые реализуют Map интерфейс.

Хэш-функция в Java, используемая HashMap и HashSet, предоставляется Object.hashCode() метод. Поскольку каждый класс в Java наследуется от Object, каждый объект имеет хеш-функцию. Класс может переопределить реализацию по умолчанию. hashCode() чтобы предоставить пользовательскую хеш-функцию, более соответствующую свойствам объекта.

The Object класс также содержит equals(Object) метод, который проверяет объект на равенство с другим объектом. Хешированные структуры данных в Java полагаются на объекты, поддерживающие следующий контракт между своими hashCode() и equals() методы:

Для двух a и b объектов

a.equals(b) == b.equals(a)
if a.equals(b), then a.hashCode() == b.hashCode()

Чтобы поддерживать этот контракт, класс, который переопределяет equals() также необходимо переопределить hashCode(), и наоборот, так что hashCode() основан на тех же свойствах (или подмножестве свойств), что и equals().

Еще одним соглашением, которое хешированная структура данных имеет с объектом, является то, что результаты hashCode() и equals() методы не изменятся после вставки объекта на карту. По этой причине обычно рекомендуется основывать хэш-функцию на неизменяемых свойствах объекта.

Аналогично, TreeMap и другие отсортированные структуры данных требуют, чтобы порядок был определен для типа данных. Либо тип данных уже должен определить свой собственный порядок, реализовав Comparable интерфейс; или обычай Comparator должны быть предоставлены во время создания карты. Как и в случае с HashMap, описанным выше, относительный порядок ключей в TreeMap не должен меняться после их вставки в карту.

JavaScript

JavaScript (и его стандартизированная версия ECMAScript ) — это язык , основанный на прототипах объектно-ориентированный .

Карта и WeakMap

Современный JavaScript обрабатывает ассоциативные массивы, используя метод Map и WeakMap занятия. По умолчанию карта не содержит ключей; он содержит только то, что в него явно вложено. Ключи и значения могут быть любого типа (включая функции, объекты или любые примитивы).

Создание

Карта может быть инициализирована всеми элементами во время построения:

const phoneBook = new Map([
    ["Sally Smart", "555-9999"],
    ["John Doe", "555-1212"],
    ["J. Random Hacker", "553-1337"],
]);

Альтернативно вы можете инициализировать пустую карту, а затем добавлять элементы:

const phoneBook = new Map();
phoneBook.set("Sally Smart", "555-9999");
phoneBook.set("John Doe", "555-1212");
phoneBook.set("J. Random Hacker", "553-1337");

Доступ по ключу

Доступ к элементу карты можно осуществить с помощью get метод:

const sallyNumber = phoneBook.get("Sally Smart");

В этом примере значение sallyNumber теперь будет содержать строку «555-9999».

Перечисление

Ключи на карте упорядочены. Таким образом, при проходе по нему объект карты возвращает ключи в порядке вставки. Ниже показано перечисление с использованием цикла for:

// loop through the collection and display each entry.
for (const [name, number] of phoneBook) {
    console.log(`Phone number for ${name} is ${number}`);
}

Ключ можно удалить следующим образом:

phoneBook.delete("Sally Smart");

Объект

Объект похож на карту: оба позволяют устанавливать ключи для значений, извлекать эти значения, удалять ключи и определять, хранится ли значение в ключе. По этой причине (а также из-за отсутствия встроенных альтернатив) объекты исторически использовались в качестве карт.

Однако есть важные различия, которые делают карту предпочтительнее в определенных случаях. В JavaScript объект представляет собой сопоставление имен свойств со значениями, то есть ассоциативный массив с одной оговоркой: ключи объекта должны быть либо строкой, либо символом (допускаются собственные объекты и примитивы, неявно преобразованные в строковые ключи). . Объекты также включают одну особенность, не связанную с ассоциативными массивами: у объекта есть прототип, поэтому он содержит ключи по умолчанию, которые могут конфликтовать с ключами, определенными пользователем. Таким образом, поиск свойства приведет к поиску определения прототипа, если объект не определяет свойство.

Литерал объекта записывается как { property1: value1, property2: value2, ... }. Например:

const myObject = {
    "Sally Smart": "555-9999",
    "John Doe": "555-1212",
    "J. Random Hacker": "553-1337",
};

Чтобы запретить поиску использовать свойства прототипа, вы можете использовать Object.setPrototypeOf функция:

Object.setPrototypeOf(myObject, null);

Начиная с ECMAScript 5 (ES5), прототип также можно обойти, используя Object.create(null):

const myObject = Object.create(null);

Object.assign(myObject, {
    "Sally Smart": "555-9999",
    "John Doe": "555-1212",
    "J. Random Hacker": "553-1337",
});

Если имя свойства является допустимым идентификатором, кавычки можно опустить, например:

const myOtherObject = { foo: 42, bar: false };

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

myObject["John Doe"]
myOtherObject.foo

Вы также можете перебирать все перечисляемые свойства и связанные значения следующим образом (цикл for-in):

for (const property in myObject) {
    const value = myObject[property];
    console.log(`myObject[${property}] = ${value}`);
}

Или (цикл for):

for (const [property, value] of Object.entries(myObject)) {
    console.log(`${property} = ${value}`);
}

Свойство можно удалить следующим образом:

delete myObject["Sally Smart"];

Как упоминалось ранее, свойства — это строки и символы. Поскольку каждый собственный объект и примитив можно неявно преобразовать в строку, вы можете сделать:

myObject[1]                                        // key is "1"; note that myObject[1] == myObject["1"]
myObject[["a", "b"]]                               // key is "a,b"
myObject[{ toString() { return "hello world"; } }] // key is "hello world"

В современном JavaScript считается дурным тоном использовать тип Array в качестве ассоциативного массива. Консенсус заключается в том, что тип объекта и Map/ WeakMap занятия лучше всего подходят для этой цели. Причина этого заключается в том, что если Array расширяется с помощью прототипа, а Object остается в первозданном виде, циклы for и for-in будут работать должным образом на ассоциативных «массивах». Эта проблема выдвинулась на передний план из-за популярности фреймворков JavaScript, которые интенсивно и иногда неизбирательно используют прототипы для расширения встроенных типов JavaScript.

см . День осведомленности о массивах и прототипах объектов JavaScript Для получения дополнительной информации по этой проблеме .

Юлия

В Julia следующие операции управляют ассоциативными массивами.

Объявить словарь:

 phonebook = Dict( "Sally Smart" => "555-9999", "John Doe" => "555-1212", "J. Random Hacker" => "555-1337" )

Элемент доступа:

phonebook["Sally Smart"]

Добавить элемент:

phonebook["New Contact"] = "555-2222"

Удалить элемент:

delete!(phonebook, "Sally Smart")

Получите ключи и значения в виде итераций :

keys(phonebook)
values(phonebook)

KornShell 93 и совместимые оболочки

В KornShell 93 и совместимых оболочках (ksh93, bash4...) с ассоциативными массивами можно использовать следующие операции.

Определение:

 typeset -A phonebook; # ksh93
 declare -A phonebook; # bash4
 phonebook=(["Sally Smart"]="555-9999" ["John Doe"]="555-1212" ["[[J. Random Hacker]]"]="555-1337");

Разыменование:

 ${phonebook["John Doe"]};

Лисп

Первоначально Lisp был задуман как язык «обработки списков», и одним из его наиболее важных типов данных является связанный список, который можно рассматривать как список ассоциаций («alist»).

'(("Sally Smart" . "555-9999")
  ("John Doe" . "555-1212")
  ("J. Random Hacker" . "553-1337"))

Синтаксис (x . y) используется для обозначения consпара изд . Ключи и значения не обязательно должны быть одного типа в списке. Lisp и Scheme предоставляют такие операторы, как assoc манипулировать списками способами, аналогичными ассоциативным массивам.

существует набор операций, специфичных для обработки списков ассоциаций Для Common Lisp , каждая из которых работает неразрушающе.

Чтобы добавить запись, acons используется функция, создающая и возвращающая новый список ассоциаций. Список ассоциаций в Common Lisp имитирует стек, то есть придерживается принципа «последним пришел — первым вышел» (LIFO) и, следовательно, добавляется к заголовку списка.

(let ((phone-book NIL))
  (setf phone-book (acons "Sally Smart"      "555-9999" phone-book))
  (setf phone-book (acons "John Doe"         "555-1212" phone-book))
  (setf phone-book (acons "J. Random Hacker" "555-1337" phone-book)))

Эту функцию можно рассматривать как приспособление для cons операции.

;; The effect of
;;   (cons (cons KEY VALUE) ALIST)
;; is equivalent to
;;   (acons KEY VALUE ALIST)
(let ((phone-book '(("Sally Smart" . "555-9999") ("John Doe" . "555-1212"))))
  (cons (cons "J. Random Hacker" "555-1337") phone-book))

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

(push (cons "Dummy" "123-4567") phone-book)

Поиск записи по ее ключу осуществляется через assoc, который можно настроить для предиката и направления проверки, особенно для поиска в списке ассоциаций от конца к началу. Результат, если он положительный, возвращает все минусы записи, а не только ее значение. Невозможность получить соответствующий ключ приводит к возврату NIL ценить.

(assoc "John Doe" phone-book :test #'string=)

Два обобщения assoc существовать: assoc-if ожидает функцию предиката, которая проверяет ключ каждой записи, возвращая первую запись, для которой предикат выдает неверный результат. NIL значение при вызове. assoc-if-not инвертирует логику, принимая те же аргументы, но возвращая первую запись, генерирующую NIL.

;; Find the first entry whose key equals "John Doe".
(assoc-if
  #'(lambda (key)
      (string= key "John Doe"))
  phone-book)

;; Finds the first entry whose key is neither "Sally Smart" nor "John Doe"
(assoc-if-not
  #'(lambda (key)
      (member key '("Sally Smart" "John Doe") :test #'string=))
  phone-book)

Обратный процесс, обнаружение записи по ее значению, использует rassoc.

;; Find the first entry with a value of "555-9999".
;; We test the entry string values with the "string=" predicate.
(rassoc "555-9999" phone-book :test #'string=)

Соответствующие обобщения rassoc-if и rassoc-if-not существовать.

;; Finds the first entry whose value is "555-9999".
(rassoc-if
  #'(lambda (value)
      (string= value "555-9999"))
  phone-book)

;; Finds the first entry whose value is not "555-9999".
(rassoc-if-not
  #'(lambda (value)
      (string= value "555-9999"))
  phone-book)

Все предыдущие функции поиска записей могут быть заменены общими вариантами, ориентированными на списки, такими как find, find-if, find-if-not, а также соответствующие функции, такие как position и его производные.

;; Find an entry with the key "John Doe" and the value "555-1212".
(find (cons "John Doe" "555-1212") phone-book :test #'equal)

Удаление, не имеющее конкретного аналога, осуществляется на основе списков объектов, в том числе деструктивных.

;; Create and return an alist without any entry whose key equals "John Doe".
(remove-if
  #'(lambda (entry)
      (string= (car entry) "John Doe"))
  phone-book)

Итерация выполняется с помощью любой функции, которая ожидает список.

;; Iterate via "map".
(map NIL
  #'(lambda (entry)
      (destructuring-bind (key . value) entry
        (format T "~&~s => ~s" key value)))
  phone-book)

;; Iterate via "dolist".
(dolist (entry phone-book)
  (destructuring-bind (key . value) entry
    (format T "~&~s => ~s" key value)))

Поскольку это структурированные списки, операции обработки и преобразования могут применяться без ограничений.

;; Return a vector of the "phone-book" values.
(map 'vector #'cdr phone-book)

;; Destructively modify the "phone-book" via "map-into".
(map-into phone-book
  #'(lambda (entry)
      (destructuring-bind (key . value) entry
        (cons (reverse key) (reverse value))))
  phone-book)

Из-за своей линейной природы списки используются для относительно небольших наборов данных. Common Lisp также поддерживает тип данных хеш-таблицы , а для Scheme они реализованы в SRFI 69. Хеш-таблицы требуют больше накладных расходов, чем списки, но обеспечивают гораздо более быстрый доступ при наличии большого количества элементов. Еще одной особенностью является тот факт, что хеш-таблицы Common Lisp, в отличие от списков ассоциаций, не поддерживают порядок вставки записей.

Хэш-таблицы Common Lisp создаются с помощью make-hash-table функция, аргументы которой, помимо других конфигураций, включают в себя предикат для проверки ключа входа. Допуская произвольные объекты, даже гетерогенность в пределах одного экземпляра хэш-таблицы, спецификация этого ключа :test функция ограничена различимыми сущностями: стандарт Common Lisp требует поддержки только eq, eql, equal, и equalp, но при этом обозначая дополнительные или пользовательские операции как разрешенные для конкретных реализаций.

(let ((phone-book (make-hash-table :test #'equal)))
  (setf (gethash "Sally Smart"      phone-book) "555-9999")
  (setf (gethash "John Doe"         phone-book) "555-1212")
  (setf (gethash "J. Random Hacker" phone-book) "553-1337"))

The gethash функция позволяет получить значение, связанное с ключом.

(gethash "John Doe" phone-book)

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

(gethash "Incognito" phone-book 'no-such-key)

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

(multiple-value-bind (value contains-key) (gethash "Sally Smart" phone-book)
  (if contains-key
    (format T "~&The associated value is: ~s" value)
    (format T "~&The key could not be found.")))

Использовать remhash для удаления записи, связанной с ключом.

(remhash "J. Random Hacker" phone-book)

clrhash полностью очищает хеш-таблицу.

(clrhash phone-book)

Посвященный maphash функция специализируется на итерации хэш-таблиц.

(maphash
  #'(lambda (key value)
      (format T "~&~s => ~s" key value))
  phone-book)

Альтернативно, loop Конструкция предусматривает итерации через ключи, значения или их сочетание.

;; Iterate the keys and values of the hash table.
(loop
  for   key being the hash-keys of phone-book
  using (hash-value value)
  do    (format T "~&~s => ~s" key value))

;; Iterate the values of the hash table.
(loop
  for value being the hash-values of phone-book
  do  (print value))

Дополнительная опция вызывает with-hash-table-iterator, макрос, создающий итератор, обработка которого должна управляться вызывающей стороной.

(with-hash-table-iterator (entry-generator phone-book)
  (loop do
    (multiple-value-bind (has-entry key value) (entry-generator)
      (if has-entry
        (format T "~&~s => ~s" key value)
        (loop-finish)))))

В Lisp легко создавать составные абстрактные типы данных, используя структуры или функции объектно-ориентированного программирования в сочетании со списками, массивами и хеш-таблицами.

ЛПК

LPC реализует ассоциативные массивы как фундаментальный тип, известный как «карта» или «отображение», в зависимости от драйвера. Ключи и значения могут быть любого типа. Литерал отображения записывается как ([ key_1 : value_1, key_2 : value_2 ]). Процедурный код выглядит так:

mapping phone_book = ([]);
phone_book["Sally Smart"] = "555-9999";
phone_book["John Doe"] = "555-1212";
phone_book["J. Random Hacker"] = "555-1337";

Доступ к сопоставлениям для чтения осуществляется с помощью оператора индексации так же, как и для записи, как показано выше. Таким образом, phone_book["Салли Смарт"] вернет строку "555-9999", а phone_book["Джон Смит"] вернет 0. Проверка присутствия выполняется с помощью функцииmember(), например if(member(phone_book, "John Smith")) write("John Smith is listed.\n");

Удаление выполняется с помощью функции m_delete() или map_delete(), в зависимости от драйвера: m_delete(phone_book, "Sally Smart");

Драйверы LPC семейства Amylaar реализуют многозначные сопоставления с использованием вторичного числового индекса (другие драйверы семейства MudOS не поддерживают многозначные сопоставления). Пример синтаксиса:

mapping phone_book = ([:2]);
phone_book["Sally Smart", 0] = "555-9999";
phone_book["Sally Smart", 1] = "99 Sharp Way";
phone_book["John Doe", 0] = "555-1212";
phone_book["John Doe", 1] = "3 Nigma Drive";
phone_book["J. Random Hacker", 0] = "555-1337";
phone_book["J. Random Hacker", 1] = "77 Massachusetts Avenue";

Драйверы LPC, достаточно современные для поддержки конструкции foreach(), используют ее для перебора типов сопоставления.

Два

В Lua «таблица» — это фундаментальный тип, который можно использовать либо как массив (числовой индекс, быстро), либо как ассоциативный массив.

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

Табличный литерал записывается как { value, key = value, [index] = value, ["non id string"] = value }. Например:

phone_book = {
	["Sally Smart"] = "555-9999", 
	["John Doe"] = "555-1212", 
	["J. Random Hacker"] = "553-1337", -- Trailing comma is OK
}

aTable = {
	-- Table as value
	subTable = { 5, 7.5, k = true }, -- key is "subTable"
	-- Function as value
	['John Doe'] = function (age) if age < 18 then return "Young" else return "Old!" end end,
	-- Table and function (and other types) can also be used as keys
}

Если ключ является допустимым идентификатором (а не зарезервированным словом), кавычки можно опустить. Идентификаторы чувствительны к регистру.

Поиск записывается либо с использованием квадратных скобок, которые всегда работают, либо с помощью точечной записи, которая работает только для ключей-идентификаторов:

print(aTable["John Doe"](45))
x = aTable.subTable.k

Вы также можете перебирать все ключи и связанные значения с помощью итераторов или циклов for:

simple = { [true] = 1, [false] = 0, [3.14] = math.pi, x = 'x', ["!"] = 42 }
function FormatElement(key, value)
	return "[" .. tostring(key) .. "] = " .. value .. ", "
end
-- Iterate on all keys
table.foreach(simple, function (k, v) io.write(FormatElement(k, v)) end)
print""
for k, v in pairs(simple) do io.write(FormatElement(k, v)) end
print""
k= nil
repeat
	k, v = next(simple, k)
	if k ~= nil then io.write(FormatElement(k, v)) end
until k == nil
print""

Запись можно удалить, установив для нее значение nil:

simple.x = nil

Аналогичным образом вы можете перезаписать значения или добавить их:

simple['%'] = "percent"
simple['!'] = 111

Mathematica и язык Wolfram

Mathematica и Wolfram Language используют выражение Association для представления ассоциативных массивов.

 phonebook = <| "Sally Smart" -> "555-9999", 
                "John Doe" -> "555-1212",
                "J. Random Hacker" -> "553-1337" |>;

Чтобы получить доступ:

 phonebook[[Key["Sally Smart"]]]

Если ключи являются строками, ключевое слово Key не требуется, поэтому:

 phonebook[["Sally Smart"]]

Чтобы перечислить ключи: и ценности

Keys[phonebook]
Values[phonebook]

Свинка

В MUMPS каждый массив является ассоциативным. Встроенная прямая поддержка ассоциативных массивов на уровне языка. применяется к частным, специфичным для процесса массивам, хранящимся в памяти, называемым «локальными», а также к постоянным, общим, глобальным массивам, хранящимся на диске, которые доступны одновременно для нескольких заданий. Имени глобальных переменных предшествует циркумфлекс «^», чтобы отличить их от локальных переменных.

SET ^phonebook("Sally Smart")="555-9999"      ;; storing permanent data
SET phonebook("John Doe")="555-1212"          ;; storing temporary data
SET phonebook("J. Random Hacker")="553-1337"  ;; storing temporary data
MERGE ^phonebook=phonebook                    ;; copying temporary data into permanent data

Для доступа к значению элемента просто необходимо использовать имя с индексом:

WRITE "Phone Number :",^phonebook("Sally Smart"),!

Вы также можете перебрать связанный массив следующим образом:

SET NAME=""
FOR  S NAME=$ORDER(^phonebook(NAME)) QUIT:NAME=""  WRITE NAME,"  Phone Number :",^phonebook(NAME),!

Objective-C (Какао/GNUstep)

Cocoa и GNUstep , написанные на Objective-C , обрабатывают ассоциативные массивы, используя NSMutableDictionary (изменяемая версия NSDictionary) кластер классов. Этот класс позволяет выполнять назначения между любыми двумя объектами. Копия ключевого объекта создается до его вставки в NSMutableDictionary, поэтому ключи должны соответствовать NSCopying протокол. При вставке в словарь объект значения получает сообщение сохранения, чтобы увеличить счетчик ссылок. Объект значения получит сообщение о выпуске, когда он будет удален из словаря (либо явно, либо путем добавления в словарь другого объекта с тем же ключом).

NSMutableDictionary *aDictionary = [[NSMutableDictionary alloc] init];
[aDictionary setObject:@"555-9999" forKey:@"Sally Smart"]; 
[aDictionary setObject:@"555-1212" forKey:@"John Doe"]; 
[aDictionary setObject:@"553-1337" forKey:@"Random Hacker"];

Для доступа к назначенным объектам можно использовать эту команду:

id anObject = [aDictionary objectForKey:@"Sally Smart"];

Все ключи или значения можно перечислить с помощью NSEnumerator:

NSEnumerator *keyEnumerator = [aDictionary keyEnumerator];
id key;
while ((key = [keyEnumerator nextObject]))
{
  // ... process it here ...
}

В Mac OS X 10.5+ и iPhone OS ключи словаря можно перечислить более кратко, используя команду NSFastEnumeration конструкция:

for (id key in aDictionary) {
  // ... process it here ...
}

Что еще более практично, графы структурированных данных можно легко создать с помощью Cocoa , особенно NSDictionary ( NSMutableDictionary). Это можно проиллюстрировать этим компактным примером:

NSDictionary *aDictionary =
       [NSDictionary dictionaryWithObjectsAndKeys:
                           [NSDictionary dictionaryWithObjectsAndKeys:
                                   @"555-9999", @"Sally Smart",
                                   @"555-1212", @"John Doe",
                                   nil], @"students",
                           [NSDictionary dictionaryWithObjectsAndKeys:
                                   @"553-1337", @"Random Hacker",
                                   nil], @"hackers",
                           nil];

К соответствующим полям можно быстро получить доступ, используя ключевые пути:

id anObject = [aDictionary valueForKeyPath:@"students.Sally Smart"];

OCaml

Язык программирования OCaml предоставляет три различных ассоциативных контейнера. Самый простой — это список пар:

# let m = [
	"Sally Smart", "555-9999";
	"John Doe", "555-1212";
	"J. Random Hacker", "553-1337"];;
val m : (string * string) list = [
	("Sally Smart", "555-9999");
	("John Doe", "555-1212");
	("J. Random Hacker", "553-1337")
]
# List.assoc "John Doe" m;;
- : string = "555-1212"

Второй — полиморфная хеш-таблица:

# let m = Hashtbl.create 3;;
val m : ('_a, '_b) Hashtbl.t = <abstr>
# Hashtbl.add m "Sally Smart" "555-9999";
  Hashtbl.add m "John Doe" "555-1212";
  Hashtbl.add m "J. Random Hacker" "553-1337";;
- : unit = ()
# Hashtbl.find m "John Doe";;
- : string = "555-1212"

В приведенном выше коде используется хеш-функция OCaml по умолчанию. Hashtbl.hash, который определяется автоматически для всех типов. Чтобы использовать модифицированную хеш-функцию, используйте интерфейс функтора Hashtbl.Make для создания модуля, например с помощью Map.

Наконец, функциональные карты (представленные в виде неизменяемых сбалансированных двоичных деревьев):

# module StringMap = Map.Make(String);;
...
# let m = StringMap.add "Sally Smart" "555-9999" StringMap.empty
  let m = StringMap.add "John Doe" "555-1212" m
  let m = StringMap.add "J. Random Hacker" "553-1337" m;;
val m : string StringMap.t = <abstr>
# StringMap.find "John Doe" m;;
 - : string = "555-1212"

Обратите внимание, что для использования Map, вам необходимо предоставить функтор Map.Make с модулем, определяющим тип ключа и функцию сравнения. Сторонняя библиотека ExtLib предоставляет полиморфную версию функциональных карт, называемую PMap, которому при создании предоставляется функция сравнения.

Списки пар и функциональные карты предоставляют чисто функциональный интерфейс. Напротив, хеш-таблицы предоставляют императивный интерфейс. Для многих операций хеш-таблицы выполняются значительно быстрее, чем списки пар и функциональные карты.

ОптимДж

Язык программирования OptimJ является расширением Java 5. Как и Java, Optimj предоставляет карты; но OptimJ также предоставляет настоящие ассоциативные массивы. Массивы Java индексируются неотрицательными целыми числами; ассоциативные массивы индексируются ключами любого типа.

String[String] phoneBook = {
"Sally Smart"      -> "555-9999",
"John Doe"         -> "555-1212",
"J. Random Hacker" -> "553-1337"
};

// String[String] is not a java type but an optimj type:
// associative array of strings indexed by strings.

// iterate over the values
for(String number : phoneBook) {
System.out.println(number);
}

// The previous statement prints:  "555-9999" "555-1212" "553-1337"

// iterate over the keys
for(String name : phoneBook.keys) {
System.out.println(name + " -> " + phoneBook[name]);
}
// phoneBook[name] access a value by a key (it looks like java array access)
// i.e. phoneBook["John Doe"] returns "555-1212"

Конечно, можно определять многомерные массивы, смешивать массивы Java и ассоциативные массивы, смешивать карты и ассоциативные массивы.

 int[String][][double] a;
 java.util.Map<String[Object], Integer> b;

Перл 5

Perl 5 имеет встроенную поддержку ассоциативных массивов на уровне языка. Современный Perl называет ассоциативные массивы хэшами ; термин «ассоциативный массив» встречается в более старой документации, но считается несколько архаичным. Хэши в Perl 5 плоские: ключи — это строки, а значения — скаляры. Однако значения могут быть ссылками на массивы или другие хеши, а стандартный модуль Perl 5 Tie::RefHash позволяет использовать хеши со ссылочными ключами.

Хэш-переменная помечается значком % sigil , чтобы отличить его от скалярных, массивных и других типов данных. Хэш-литерал — это список значений ключа, предпочтительной формой которого является Perl. => токен, который семантически по большей части идентичен запятой и делает связь ключ-значение более понятной:

my %phone_book = (
	'Sally Smart'      => '555-9999',
	'John Doe'         => '555-1212',
	'J. Random Hacker' => '553-1337',
);

Для доступа к элементу хеша используется синтаксис $hash_name{$key} – ключ заключен в фигурные скобки , а имя хеша начинается с префикса $, указывая, что сам элемент хэша является скалярным значением, даже если он является частью хеша. Стоимость $phone_book{'John Doe'} является '555-1212'. % сигил используется только при обращении к хешу в целом, например, при запросе keys %phone_book.

Список ключей и значений можно извлечь с помощью встроенных функций. keys и values, соответственно. Так, например, чтобы напечатать все ключи хеша:

foreach $name (keys %phone_book) {
	print $name, "\n";
}

Можно перебирать пары (ключ, значение), используя each функция:

while (($name, $number) = each %phone_book) {
	print 'Number for ', $name, ': ', $number, "\n";
}

«Ссылка» хеша, которая представляет собой скалярное значение, указывающее на хеш, указывается в буквальной форме с использованием фигурных скобок в качестве разделителей, а синтаксис в остальном аналогичен указанию литерала хеша:

my $phone_book = {
	'Sally Smart' => '555-9999',
	'John Doe' => '555-1212',
	'J. Random Hacker' => '553-1337',
};

Доступ к значениям в хэш-ссылке осуществляется с помощью оператора разыменования:

print $phone_book->{'Sally Smart'};

Когда на хэш, содержащийся в ссылке на хеш, необходимо обращаться как единое целое, как в случае с keys функция, синтаксис следующий:

foreach $name (keys %{$phone_book}) {
	print 'Number for ', $name, ': ', $phone_book->{$name}, "\n";
}

Перл 6 (Раку)

Perl 6 , переименованный в «Raku», также имеет встроенную поддержку на уровне языка ассоциативных массивов, которые называются хэшами или объектами, выполняющими «ассоциативную» роль. Как и в Perl 5, хэши по умолчанию в Perl 6 являются плоскими: ключи представляют собой строки, а значения — скаляры. Можно определить хеш, чтобы не приводить все ключи к строкам автоматически: они называются «хешами объектов», поскольку ключи таких хэшей остаются исходным объектом, а не его строковой структурой.

Хэш-переменная обычно помечается знаком % sigil , чтобы визуально отличить его от скалярных, массивных и других типов данных, а также определить его поведение при итерации. Хэш-литерал — это список значений ключа, предпочтительной формой которого является Perl. => токен, который делает связь ключ-значение более понятной:

my %phone-book =
	'Sally Smart'      => '555-9999',
	'John Doe'         => '555-1212',
	'J. Random Hacker' => '553-1337',
;

Для доступа к элементу хеша используется синтаксис %hash_name{$key} – ключ заключен в фигурные скобки и хеш-имя (обратите внимание, что сигила не меняется, в отличие от Perl 5). Стоимость %phone-book{'John Doe'} является '555-1212'.

Список ключей и значений можно извлечь с помощью встроенных функций. keys и values, соответственно. Так, например, чтобы напечатать все ключи хеша:

for %phone-book.keys -> $name {
	say $name;
}

По умолчанию при переборе хеша получаются пары ключ-значение.

for %phone-book -> $entry {
	say "Number for $entry.key(): $entry.value()";  # using extended interpolation features
}

Также возможно получить чередующиеся значения ключей и значений, используя метод kv метод:

for %phone-book.kv -> $name, $number {
	say "Number for $name: $number";
}

У Раку нет никаких упоминаний. Хэши можно передавать как отдельные параметры, которые не сглаживаются. Если вы хотите убедиться, что подпрограмма принимает только хэши, используйте символ % в подписи.

sub list-phone-book(%pb) {
    for %pb.kv -> $name, $number {
        say "Number for $name: $number";
    }
}
list-phone-book(%phone-book);

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

# Define a hash whose keys may only be integer numbers ("Int" type).
my %numbersWithNames{Int};

# Keys must be integer numbers, as in this case.
%numbersWithNames.push(1 => "one");

# This will cause an error, as strings as keys are invalid.
%numbersWithNames.push("key" => "two");

PHP

. Встроенный тип массива PHP на самом деле является ассоциативным массивом Даже при использовании числовых индексов PHP внутренне хранит массивы как ассоциативные массивы. Таким образом, PHP может иметь массивы с непоследовательной числовой индексацией. Ключи должны быть целочисленными (числа с плавающей запятой усекаются до целых) или строкового типа, а значения могут быть произвольными типами, включая другие массивы и объекты. Массивы неоднородны: в одном массиве могут быть ключи разных типов. Ассоциативные массивы PHP можно использовать для представления деревьев, списков, стеков, очередей и других распространенных структур данных, не встроенных в PHP.

Ассоциативный массив можно объявить, используя следующий синтаксис:

$phonebook                     = array();
$phonebook['Sally Smart']      = '555-9999';
$phonebook['John Doe']         = '555-1212';
$phonebook['J. Random Hacker'] = '555-1337';

// or

$phonebook = array(
    'Sally Smart'      => '555-9999',
    'John Doe'         => '555-1212',
    'J. Random Hacker' => '555-1337',
);

// or, as of PHP 5.4

$phonebook = [
    'Sally Smart'      => '555-9999',
    'John Doe'         => '555-1212',
    'J. Random Hacker' => '555-1337',
];

// or

$phonebook['contacts']['Sally Smart']['number']      = '555-9999';
$phonebook['contacts']['John Doe']['number']         = '555-1212';
$phonebook['contacts']['J. Random Hacker']['number'] = '555-1337';

PHP может перебирать ассоциативный массив следующим образом:

foreach ($phonebook as $name => $number) {
    echo 'Number for ', $name, ': ', $number, "\n";
}

// For the last array example it is used like this
foreach ($phonebook['contacts'] as $name => $num) {
   echo 'Name: ', $name, ', number: ', $num['number'], "\n";
}

PHP имеет обширный набор функций для работы с массивами.

Ассоциативные массивы, которые могут использовать объекты в качестве ключей вместо строк и целых чисел, могут быть реализованы с помощью SplObjectStorage класс из стандартной библиотеки PHP (SPL).

Щука

Pike имеет встроенную поддержку ассоциативных массивов, которые называются отображениями. Сопоставления создаются следующим образом:

mapping(string:string) phonebook = ([
	"Sally Smart":"555-9999",
	"John Doe":"555-1212",
	"J. Random Hacker":"555-1337"
]);

Доступ и проверка присутствия в сопоставлениях осуществляется с помощью оператора индексации. Так phonebook["Sally Smart"] вернет строку "555-9999", и phonebook["John Smith"] вернул бы 0.

Итерация по отображению может быть выполнена с помощью foreach:

foreach(phonebook; string key; string value) {
	write("%s:%s\n", key, value);
}

Или используя объект итератора:

Mapping.Iterator i = get_iterator(phonebook);
while (i->index()) {
	write("%s:%s\n", i->index(), i->value());
	i->next();
}

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

string sallys_number = m_delete(phonebook, "Sally Smart");

Постскриптум

В PostScript ассоциативные массивы называются словарями. В PostScript уровня 1 они должны создаваться явно, но на уровне 2 введено прямое объявление с использованием синтаксиса двойной угловой скобки:

  % Level 1 declaration
  3 dict dup begin
    /red   (rouge) def
    /green (vert)  def
    /blue  (bleu)  def
  end

  % Level 2 declaration
  <<
    /red   (rot)
    /green (gruen)
    /blue  (blau)
  >>

  % Both methods leave the dictionary on the operand stack

Доступ к словарям можно получить напрямую, используя getили неявно, поместив словарь в стек словарей, используя begin:

  % With the previous two dictionaries still on the operand stack
  /red get print    % outputs 'rot'

  begin
  green print       % outputs 'vert'
  end

Содержимое словаря можно перебирать с помощью forall, хотя и не в каком-то определенном порядке:

  % Level 2 example
  <<
    /This  1
    /That  2
    /Other 3
  >> {exch =print ( is ) print ==} forall

Что может вывести:

  That is 2
  This is 1
  Other is 3

Словари можно дополнять (до определенного размера только на уровне 1) или изменять с помощью put, и записи можно удалить с помощью undef:

  % define a dictionary for easy reuse:
  /MyDict <<
    /rouge (red)
    /vert (gruen)
  >> def

  % add to it
  MyDict /bleu (blue) put

  % change it
  MyDict /vert (green) put

  % remove something
  MyDict /rouge undef

Пролог

Некоторые версии Пролога включают утилиты словаря («dict»).

Питон

В Python ассоциативные массивы называются « словарями ». Словарные литералы ограничиваются фигурными скобками:

phonebook = {
    "Sally Smart": "555-9999",
    "John Doe": "555-1212",
    "J. Random Hacker": "553-1337",
}

Доступ к элементам словаря можно получить с помощью оператора индексации массива:

>>> phonebook["Sally Smart"]
'555-9999'

Цикл перебора всех ключей словаря:

>>> for key in phonebook:
...     print(key, phonebook[key])
Sally Smart 555-9999
J. Random Hacker 553-1337
John Doe 555-1212

Перебор кортежей (ключ, значение):

>>> for key, value in phonebook.items():
...     print(key, value)
Sally Smart 555-9999
J. Random Hacker 553-1337
John Doe 555-1212

Ключи словаря можно удалить по отдельности с помощью del заявление. Соответствующее значение можно вернуть до удаления пары ключ-значение с помощью метода pop типа dict:

>>> del phonebook["John Doe"]
>>> val = phonebook.pop("Sally Smart")
>>> phonebook.keys() # Only one key left
['J. Random Hacker']

Python 2.7 и 3.x также поддерживают понимание dict (аналогично пониманию списков ), компактный синтаксис для создания словаря из любого итератора:

>>> square_dict = {i: i*i for i in range(5)}
>>> square_dict
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
>>> {key: value for key, value in phonebook.items() if "J" in key}
{'J. Random Hacker': '553-1337', 'John Doe': '555-1212'}

Строго говоря, словарь представляет собой надмножество ассоциативного массива, поскольку ни ключи, ни значения не ограничены одним типом данных. Словарь можно представить как «ассоциативный список», используя номенклатуру Python. Например, следующее также является законным:

phonebook = {
    "Sally Smart": "555-9999",
    "John Doe": None,
    "J. Random Hacker": -3.32,
    14: "555-3322",
}

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

Красный

Красный ​ встроенный map! datatype предоставляет ассоциативный массив, который сопоставляет значения типов слов, строк и скалярных ключей со значениями любого типа. Для поиска внутри используется хеш-таблица.

Карту можно записать в виде литерала, например #(key1 value1 key2 value2 ...)или может быть создан с помощью make map! [key1 value1 key2 value2 ...]:

Red [Title:"My map"]

my-map: make map! [
    "Sally Smart"      "555-9999"
    "John Doe"         "555-1212"
    "J. Random Hacker" "553-1337"
]

; Red preserves case for both keys and values, however lookups are case insensitive by default; it is possible to force case sensitivity using the <code>/case</code> refinement for <code>select</code> and <code>put</code>.

; It is of course possible to use <code>word!</code> values as keys, in which case it is generally preferred to use <code>set-word!</code> values when creating the map, but any word type can be used for lookup or creation.

my-other-map: make map! [foo: 42 bar: false]

; Notice that the block is not reduced or evaluated in any way, therefore in the above example the key <code>bar</code> is associated with the <code>word!</code> <code>false</code> rather than the <code>logic!</code> value false; literal syntax can be used if the latter is desired:

my-other-map: make map! [foo: 42 bar: #[false]]

; or keys can be added after creation:

my-other-map: make map! [foo: 42]
my-other-map/bar: false

; Lookup can be written using <code>path!</code> notation or using the <code>select</code> action:

select my-map "Sally Smart"
my-other-map/foo

; You can also loop through all keys and values with <code>foreach</code>:

foreach [key value] my-map [
    print [key "is associated to" value]
]

; A key can be removed using <code>remove/key</code>:

remove/key my-map "Sally Smart"

РЕКСС

В REXX ассоциативные массивы называются «основными переменными» или «составными переменными».

KEY = 'Sally Smart'
PHONEBOOK.KEY = '555-9999'
KEY = 'John Doe'
PHONEBOOK.KEY = '555-1212'
KEY = 'J. Random Hacker'
PHONEBOOK.KEY = '553-1337'

Переменные-стержни с цифровыми ключами обычно начинаются с 1 и идут вверх. Переменная основы с нулевой клавишей по соглашению содержит общее количество элементов в основе:

NAME.1 = 'Sally Smart'
NAME.2 = 'John Doe'
NAME.3 = 'J. Random Hacker'
NAME.0 = 3

В REXX нет простого способа автоматического доступа к ключам основной переменной; и обычно ключи хранятся в отдельном ассоциативном массиве с числовыми ключами.

Руби

В Ruby хеш-таблица используется следующим образом:

phonebook = {
  'Sally Smart' => '555-9999',
  'John Doe' => '555-1212',
  'J. Random Hacker' => '553-1337'
}
phonebook['John Doe']

Ruby поддерживает циклы и итерации хеширования со следующим синтаксисом:

irb(main):007:0> ### iterate over keys and values
irb(main):008:0* phonebook.each {|key, value| puts key + " => " + value}
Sally Smart => 555-9999
John Doe => 555-1212
J. Random Hacker => 553-1337
=> {"Sally Smart"=>"555-9999", "John Doe"=>"555-1212", "J. Random Hacker"=>"553-1337"}
irb(main):009:0> ### iterate keys only
irb(main):010:0* phonebook.each_key {|key| puts key}
Sally Smart
John Doe
J. Random Hacker
=> {"Sally Smart"=>"555-9999", "John Doe"=>"555-1212", "J. Random Hacker"=>"553-1337"}
irb(main):011:0> ### iterate values only
irb(main):012:0* phonebook.each_value {|value| puts value}
555-9999
555-1212
553-1337
=> {"Sally Smart"=>"555-9999", "John Doe"=>"555-1212", "J. Random Hacker"=>"553-1337"}

Ruby также поддерживает множество других полезных операций с хэшами, таких как объединение хешей, выбор или отклонение элементов, соответствующих некоторым критериям, инвертирование (замена ключей и значений) и преобразование хеша в массив.

Ржавчина

Стандартная библиотека Rust предоставляет хэш-карту ( std::collections::HashMap) и карту B-дерева ( std::collections::BTreeMap). Они используют несколько методов с одинаковыми именами, но имеют разные требования к типам вставляемых ключей. HashMap требуются ключи для реализации Eq ( отношение эквивалентности ) и Hash (хешируемость) и сохраняет записи в неопределенном порядке, а BTreeMap требует Ord ( общий порядок ) для своих ключей и сохраняет записи в порядке, определенном типом ключа. Порядок отражается итераторами по умолчанию.

use std::collections::HashMap;
let mut phone_book = HashMap::new();
phone_book.insert("Sally Smart", "555-9999");
phone_book.insert("John Doe", "555-1212");
phone_book.insert("J. Random Hacker", "555-1337");

Итераторы по умолчанию посещают все записи как кортежи. HashMap итераторы посещают записи в неопределенном порядке, а BTreeMap итератор посещает записи в порядке, определенном типом ключа.

for (name, number) in &phone_book {
    println!("{} {}", name, number);
}

Также существует итератор для ключей:

for name in phone_book.keys() {
    println!("{}", name);
}

S-только

S-Lang имеет тип ассоциативного массива:

phonebook = Assoc_Type[];
phonebook["Sally Smart"] = "555-9999"
phonebook["John Doe"] = "555-1212"
phonebook["J. Random Hacker"] = "555-1337"

Вы также можете перебрать связанный массив несколькими способами:

foreach name (phonebook) {
	vmessage ("%s %s", name, phonebook[name]);
}

Чтобы напечатать отсортированный список, лучше воспользоваться сильными возможностями S-lang. поддержка стандартных массивов:

keys = assoc_get_keys(phonebook);
i = array_sort(keys);
vals = assoc_get_values(phonebook);
array_map (Void_Type, &vmessage, "%s %s", keys[i], vals[i]);

Скала

Scala предоставляет неизменяемый Map класс как часть scala.collection рамки:

val phonebook = Map("Sally Smart" -> "555-9999",
  "John Doe" -> "555-1212",
  "J. Random Hacker" -> "553-1337")

Scala Вывод типа решит, что это Map[String, String]. Чтобы получить доступ к массиву:

phonebook.get("Sally Smart")

Это возвращает Option type, эквивалент монады Maybe в Haskell в Scala.

Смолток

В Smalltalk ​ Dictionary используется:

phonebook := Dictionary new.
phonebook at: 'Sally Smart' put: '555-9999'.
phonebook at: 'John Doe' put: '555-1212'.
phonebook at: 'J. Random Hacker' put: '553-1337'.

Чтобы получить доступ к записи, отправьте сообщение #at: отправляется в объект словаря:

phonebook at: 'Sally Smart'

Что дает:

 '555-9999'

Словарь хеширует или сравнивает на основе равенства и помечает как ключ, так и значение как сильные ссылки . Существуют варианты, в которых хэширование/сравнение идентификаторов (IdentityDictionary) или сохранение слабых ссылок (WeakKeyDictionary/WeakValueDictionary). Поскольку каждый объект реализует #hash, любой объект можно использовать в качестве ключа (и, конечно же, как значения).

СНОБОЛ

SNOBOL — один из первых (если не первый) языков программирования, использующих ассоциативные массивы. Ассоциативные массивы в СНОБОЛЕ называются Таблицами.

PHONEBOOK = TABLE()
PHONEBOOK['Sally Smart'] = '555-9999'
PHONEBOOK['John Doe'] = '555-1212'
PHONEBOOK['J. Random Hacker'] = '553-1337'

Стандартный ML

Стандарт SML'97 языка программирования Standard ML не предоставляет никаких ассоциативных контейнеров. Однако различные реализации Standard ML предоставляют ассоциативные контейнеры.

Библиотека популярной реализации Standard ML of New Jersey (SML/NJ) предоставляет подпись (что-то вроде «интерфейса»), ORD_MAP, который определяет общий интерфейс для упорядоченных функциональных (неизменяемых) ассоциативных массивов. Существует несколько общих функторов: BinaryMapFn, ListMapFn, RedBlackMapFn, и SplayMapFn— которые позволяют создать соответствующий тип упорядоченной карты (типы — самобалансирующееся двоичное дерево поиска , отсортированный список ассоциаций , красно-черное дерево и дерево расширения соответственно), используя предоставленную пользователем структуру для описания типа ключа и компаратор. Функтор возвращает структуру в соответствии с ORD_MAP интерфейс. Кроме того, существует два предопределенных модуля для ассоциативных массивов, использующих целочисленные ключи: IntBinaryMap и IntListMap.

- structure StringMap = BinaryMapFn (struct
                                       type ord_key = string
                                       val compare = String.compare
                                     end);
structure StringMap : ORD_MAP

- val m = StringMap.insert (StringMap.empty, "Sally Smart", "555-9999")
  val m = StringMap.insert (m, "John Doe", "555-1212")
  val m = StringMap.insert (m, "J. Random Hacker", "553-1337");
val m =
  T
    {cnt=3,key="John Doe",
     left=T {cnt=1,key="J. Random Hacker",left=E,right=E,value="553-1337"},
     right=T {cnt=1,key="Sally Smart",left=E,right=E,value="555-9999"},
     value="555-1212"} : string StringMap.map
- StringMap.find (m, "John Doe");
val it = SOME "555-1212" : string option

SML/NJ также предоставляет полиморфную хэш-таблицу:

- exception NotFound;
exception NotFound
- val m : (string, string) HashTable.hash_table = HashTable.mkTable (HashString.hashString, op=) (3, NotFound);
val m =
  HT
    {eq_pred=fn,hash_fn=fn,n_items=ref 0,not_found=NotFound(-),
     table=ref [|NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,NIL,...|]}
  : (string,string) HashTable.hash_table
- HashTable.insert m ("Sally Smart", "555-9999");
val it = () : unit
- HashTable.insert m ("John Doe", "555-1212");
val it = () : unit
- HashTable.insert m ("J. Random Hacker", "553-1337");
val it = () : unit
HashTable.find m "John Doe"; (* returns NONE if not found *)
val it = SOME "555-1212" : string option
- HashTable.lookup m "John Doe"; (* raises the exception if not found *)
val it = "555-1212" : string

Также поддерживаются мономорфные хеш-таблицы с использованием HashTableFn функтор.

Другая реализация Standard ML, Moscow ML , также предоставляет некоторые ассоциативные контейнеры. Во-первых, он предоставляет полиморфные хэш-таблицы в Polyhash структура. Кроме того, некоторые функциональные карты из библиотеки SML/NJ выше доступны как Binarymap, Splaymap, и Intmap структуры.

Ткл

Существует два средства Tcl , которые поддерживают семантику ассоциативных массивов. «Массив» — это набор переменных. «Дикт» — это полная реализация ассоциативных массивов.

множество

set {phonebook(Sally Smart)} 555-9999
set john {John Doe}
set phonebook($john) 555-1212
set {phonebook(J. Random Hacker)} 553-1337

Если в имени переменной есть пробел, имя необходимо сгруппировать либо с помощью фигурных скобок (подстановка не производится), либо двойных кавычек (подстановка выполняется).

Альтернативно, несколько элементов массива могут быть установлены одной командой, представляя их сопоставления в виде списка (слова, содержащие пробелы, заключаются в скобки):

array set phonebook [list {Sally Smart} 555-9999 {John Doe} 555-1212 {J. Random Hacker} 553-1337]

Чтобы получить доступ к одной записи массива и поместить ее в стандартный вывод:

puts $phonebook(Sally\ Smart)

Что возвращает этот результат:

555-9999

Чтобы получить весь массив как словарь:

array get phonebook

Результатом может быть (порядок ключей не указан не потому, что словарь неупорядочен, а потому, что массив):

{Sally Smart} 555-9999 {J. Random Hacker} 553-1337 {John Doe} 555-1212

диктовать

set phonebook [dict create {Sally Smart} 555-9999 {John Doe} 555-1212 {J. Random Hacker} 553-1337]

Чтобы найти элемент:

dict get $phonebook {John Doe}

Чтобы перебрать dict:

foreach {name number} $phonebook {
	puts "name: $name\nnumber: $number"
}

Визуальный Бейсик

Visual Basic может использовать класс Dictionary из среды выполнения сценариев Microsoft (которая поставляется с Visual Basic 6). Не существует стандартной реализации, общей для всех версий:

' Requires a reference to SCRRUN.DLL in Project Properties
Dim phoneBook As New Dictionary
phoneBook.Add "Sally Smart", "555-9999"
phoneBook.Item("John Doe") = "555-1212"
phoneBook("J. Random Hacker") = "553-1337"
For Each name In phoneBook
	MsgBox name & " = " & phoneBook(name)
Next

Визуальный Бейсик .NET

Visual Basic .NET использует классы коллекций, предоставляемые .NET Framework .

Создание

Следующий код демонстрирует создание и заполнение словаря ( см. в примере C# на этой странице дополнительную информацию ):

Dim dic As New System.Collections.Generic.Dictionary(Of String, String)
dic.Add("Sally Smart", "555-9999")
dic("John Doe") = "555-1212"
dic.Item("J. Random Hacker") = "553-1337"

Альтернативным синтаксисом было бы использование инициализатора коллекции , который компилируется в отдельные вызовы Add:

Dim dic As New System.Collections.Dictionary(Of String, String) From {
    {"Sally Smart", "555-9999"},
    {"John Doe", "555-1212"},
    {"J. Random Hacker", "553-1337"}
}

Доступ по ключу

Пример, демонстрирующий доступ (см. Доступ к C# ):

Dim sallyNumber = dic("Sally Smart")
' or
Dim sallyNumber = dic.Item("Sally Smart")

Dim result As String = Nothing
Dim sallyNumber = If(dic.TryGetValue("Sally Smart", result), result, "n/a")

Перечисление

Пример, демонстрирующий перечисление (см. перечисление #C# ):

' loop through the collection and display each entry.
For Each kvp As KeyValuePair(Of String, String) In dic
    Console.WriteLine("Phone number for {0} is {1}", kvp.Key, kvp.Value)
Next

Windows PowerShell

В отличие от многих других интерпретаторов командной строки , Windows PowerShell имеет встроенную поддержку на уровне языка для определения ассоциативных массивов:

$phonebook = @{
        'Sally Smart' = '555-9999';
	'John Doe' = '555-1212'; 
	'J. Random Hacker' = '553-1337'
}

Как и в JavaScript, если имя свойства является допустимым идентификатором, кавычки можно опустить:

$myOtherObject = @{ foo = 42; bar = $false }

Записи могут быть разделены точкой с запятой или новой строкой:

$myOtherObject = @{ foo = 42
                    bar = $false ;
                    zaz = 3
}

Ключи и значения могут быть .NET объектами любого типа :

$now = [DateTime]::Now
$tomorrow = $now.AddDays(1)
$ProcessDeletionSchedule = @{ 
        (Get-Process notepad) = $now 
        (Get-Process calc) = $tomorrow
}

Также возможно создать пустой ассоциативный массив и позже добавить к нему отдельные записи или даже другие ассоциативные массивы:

$phonebook = @{}
$phonebook += @{ 'Sally Smart' = '555-9999' }
$phonebook += @{ 'John Doe' = '555-1212'; 'J. Random Hacker' = '553-1337' }

Новые записи также можно добавлять с помощью оператора индекса массива, оператора свойства или оператора Add() метод базового объекта .NET:

$phonebook = @{}
$phonebook['Sally Smart'] = '555-9999'
$phonebook.'John Doe' = '555-1212'
$phonebook.Add('J. Random Hacker', '553-1337')

Чтобы разыменовать назначенные объекты, используйте оператор индекса массива, оператор свойства или параметризованное свойство. Item() объекта .NET можно использовать:

$phonebook['Sally Smart'] 
$phonebook.'John Doe'
$phonebook.Item('J. Random Hacker')

Вы можете перебрать ассоциативный массив следующим образом:

$phonebook.Keys | foreach { "Number for {0}: {1}" -f $_,$phonebook.$_ }

Запись можно удалить с помощью Remove() метод базового объекта .NET:

$phonebook.Remove('Sally Smart')

Хэш-таблицы могут быть добавлены:

$hash1 = @{ a=1; b=2 }
$hash2 = @{ c=3; d=4 }
$hash3 = $hash1 + $hash2

Поддержка форматов сериализации данных

Многие форматы сериализации данных также поддерживают ассоциативные массивы (см. эту таблицу ).

JSON

В JSON ассоциативные массивы также называются объектами. Ключи могут быть только строками.

{
    "Sally Smart": "555-9999",
    "John Doe": "555-1212",
    "J. Random Hacker": "555-1337"
}

ЯМЛ

Ассоциативные массивы YAML также называются элементами карты или парами ключ-значение. YAML не накладывает ограничений на типы ключей; в частности, они не ограничиваются скалярными или строковыми значениями.

Sally Smart: 555-9999
John Doe: 555-1212
J. Random Hacker: 555-1337