Это Сравнение языков программирования (ассоциативных массивов) сравнивает особенности структур данных ассоциативных массивов или обработки поиска по массивам для более чем 40 языков программирования .
Языковая поддержка
Ниже приводится сравнение ассоциативных массивов (также «сопоставление», «хэш» и «словарь») на различных языках программирования.
Awk
Awk имеет встроенную поддержку ассоциативных массивов на уровне языка.
Например:
телефонная книга [ "Sally Smart" ] = "555-9999" телефонная книга [ "John Doe" ] = "555-1212" телефонная книга [ "J. Random Hacker" ] = "555-1337"
Следующий код просматривает связанный массив и выводит его содержимое:
для ( имя в телефонной книге ) { печатное имя , "" , телефонная книга [ имя ] }
Пользователь может искать элементы в ассоциативном массиве и удалять элементы из массива.
Ниже показано, как многомерные ассоциативные массивы можно моделировать в стандартном Awk с помощью конкатенации и встроенной переменной-разделителя строк SUBSEP:
{ # для каждой строки ввода multi [ $ 1 SUBSEP $ 2 ] ++ ; } # END { для ( x в множестве ) { split ( x , arr , SUBSEP ); напечатать arr [ 1 ], arr [ 2 ], multi [ x ]; } }
C
В C нет стандартной реализации ассоциативных массивов , но доступна сторонняя библиотека C Hash Table с лицензией BSD. [1]
Другая сторонняя библиотека, uthash, также создает ассоциативные массивы из структур C. Структура представляет собой значение, а одно из полей структуры служит ключом. [2]
Наконец, библиотека GLib также поддерживает ассоциативные массивы вместе со многими другими расширенными типами данных и является рекомендуемой реализацией проекта GNU. [3]
Подобно GLib , кроссплатформенная структура Core Foundation от Apple предоставляет несколько основных типов данных. В частности, есть CFDictionary и CFMutableDictionary с подсчетом ссылок.
C #
C # использует классы коллекций, предоставляемые .NET Framework . Наиболее часто используемый тип ассоциативного массива - System.Collections.Generic.Dictionary
это изменяемая хеш-таблица. Относительно новый System.Collections.Immutable
пакет, доступный в .NET Framework версий 4.5 и выше, а также во всех версиях .NET Core , также включает System.Collections.Immutable.Dictionary
тип, который реализован с использованием дерева AVL . Методы, которые обычно изменяют объект на месте, вместо этого возвращают новый объект, который представляет состояние исходного объекта после мутации.
Создание
Следующее демонстрирует три способа заполнения изменяемого словаря:
Add
метод, который добавляет ключ и значение и выдает исключение , если ключ уже существует в словаре;- назначение индексатору, который перезаписывает любое существующее значение, если оно есть; а также
- присвоение свойству поддержки индексатора, для которого индексатор является синтаксическим сахаром (не применимо к C #, см. примеры F # или VB.NET ).
Словарь < строка , строка > dic = новый Словарь < строка , строка > (); dic . Добавить ( «Салли Смарт» , «555-9999» ); dic [ "Джон Доу" ] = "555-1212" ; // Не разрешено в C #. // dic.Item ("J. Random Hacker") = "553-1337"; dic [ "J. Random Hacker" ] = "553-1337" ;
Словарь также может быть инициализирован во время создания с помощью «инициализатора коллекции», который компилируется для повторных вызовов Add
.
var dic = new Dictionary < string , string > { { "Салли Смарт" , "555-9999" }, { "Джон Доу" , "555-1212" }, { "J. Random Hacker" , "553-1337" } };
Доступ по ключу
Значения в основном извлекаются с помощью индексатора (который выдает исключение, если ключ не существует) и TryGetValue
метода, который имеет выходной параметр для искомого значения и логическое возвращаемое значение, указывающее, был ли найден ключ.
var sallyNumber = dic [ "Салли Смарт" ];
var sallyNumber = ( dic . TryGetValue ( "Салли Смарт" , вне var result ) ? result : "н / д" ;
В этом примере sallyNumber
значение теперь будет содержать строку "555-9999"
.
Перечисление
Словарь можно рассматривать как последовательность ключей, последовательность значений или последовательность пар ключей и значений, представленных экземплярами KeyValuePair
типа, хотя нет гарантии порядка. Для отсортированного словаря программист может выбрать использование SortedDictionary
или использование метода расширения .Sort
LINQ при перечислении.
Ниже показано перечисление с использованием цикла foreach :
// перебираем коллекцию и отображаем каждую запись. foreach ( KeyValuePair < string , string > kvp in dic ) { Console . WriteLine ( "Номер телефона для {0}: {1}" , kvp . Key , kvp . Value ); }
C ++
C ++ имеет форму ассоциативного массива, называемого std::map
(см. Стандартная библиотека шаблонов # Контейнеры ). Можно создать карту телефонной книги с помощью следующего кода на C ++:
#include <карта>#include <строка>#include <служебная программа> int main () { std :: map < std :: string , std :: string > phone_book ; phone_book . insert ( std :: make_pair ( "Салли Смарт" , "555-9999" )); phone_book . вставить ( std :: make_pair ( "Джон Доу" , "555-1212" )); phone_book . insert ( std :: make_pair ( "J. Random Hacker" , "553-1337" )); }
Или менее эффективно, поскольку это создает временные std::string
значения:
#include <карта>#include <строка> int main () { std :: map < std :: string , std :: string > phone_book ; phone_book [ "Салли Смарт" ] = "555-9999" ; phone_book [ "Джон Доу" ] = "555-1212" ; phone_book [ "J. Random Hacker" ] = "553-1337" ; }
С расширением списков инициализации в C ++ 11 записи могут быть добавлены во время построения карты, как показано ниже:
#include <карта>#include <строка>int main () { std :: map < std :: string , std :: string > phone_book { { "Салли Смарт" , "555-9999" }, { "Джон Доу" , "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 . второй << std :: endl ;
Используя структурированную привязку, доступную в C ++ 17 :
for ( const auto & [ имя , номер ] : phone_book ) { std :: cout << name << "=" << число << std :: endl ; }
В C ++ std::map
класс является шаблонным, что позволяет использовать разные типы данных ключей и значений для разных map
экземпляров. Для данного экземпляра map
класса ключи должны быть одного и того же базового типа. То же самое должно быть верно для всех ценностей. Хотя std::map
обычно реализуется с использованием самобалансирующегося двоичного дерева поиска , C ++ 11 определяет вторую карту, называемую std::unordered_map
, которая имеет алгоритмические характеристики хеш-таблицы. Это распространенное расширение стандартной библиотеки шаблонов (STL), которое также обычно называется hash_map
, и доступно в таких реализациях, как SGI и STLPort.
CFML
Структура в CFML эквивалентна ассоциативному массиву:
dynamicKeyName = "Джон Доу" ; phoneBook = { "Sally Smart" = "555-9999" , " # dynamicKeyName # " = "555-4321" , "J. Random Hacker" = "555-1337" , UnknownComic = "???" }; writeOutput ( phoneBook.UnknownComic ); // ??? writeDump ( телефонная книга ); // вся структура
Кобра
Инициализация пустого словаря и добавление элементов в Cobra :
dic как Dictionary < of String , String > = Dictionary < of String , String > () dic . добавить ( 'Салли Смарт' , '555-9999' ) dic . add ( 'John Doe' , '555-1212' ) dic . add ( 'J. Random Hacker' , '553-1337' ) assert dic [ 'Салли Смарт' ] == '555-9999'
В качестве альтернативы словарь может быть инициализирован всеми элементами во время построения:
dic = { 'Салли Смарт' : '555-9999' , 'Джон Доу' : '555-1212' , 'Дж. Случайный хакер ' : ' 553-1337 ' }
Словарь можно перечислить с помощью цикла for, но нет гарантированного порядка:
для ключа , вал в выпо печати «[ключ] Номер телефона [Val]»
D
D предлагает прямую поддержку ассоциативных массивов в основном языке; такие массивы реализованы в виде хеш-таблицы с бинарными деревьями. [4] Эквивалентный пример:
int main () { строка [ строка ] phone_book ; phone_book [ "Салли Смарт" ] = "555-9999" ; phone_book [ "Джон Доу" ] = "555-1212" ; phone_book [ "J. Random Hacker" ] = "553-1337" ; возврат 0 ; }
Ключи и значения могут быть любых типов, но все ключи в ассоциативном массиве должны быть одного типа, и то же самое касается зависимых значений.
Перебор всех свойств и связанных значений и их печать можно закодировать следующим образом:
foreach ( ключ , значение ; телефонная_книга ) { Writeln ( "Число для" ~ ключа ~ ":" ~ значение ); }
Свойство можно удалить следующим образом:
phone_book . удалить ( «Салли Смарт» );
Delphi
Delphi поддерживает несколько стандартных контейнеров, включая TDictionary
использует SysUtils , Generics . Коллекции ;var PhoneBook : TDictionary < строка , строка >; Запись : TPair < строка , строка >;начать PhoneBook : = TDictionary < строка , строка >. Создать ; Телефонная книга . Добавить ( «Салли Смарт» , «555-9999» ) ; Телефонная книга . Добавить ( 'Джон Доу' , '555-1212' ) ; Телефонная книга . Добавить ( 'J. Random Hacker' , '553-1337' ) ; для въезда в PhoneBook сделать Writeln ( Формат ( 'Номер для% s:% s' , [ запись . Ключ , запись . Value ])) ; конец .
Версии Delphi до 2009 не предлагают прямой поддержки ассоциативных массивов. Однако ассоциативные массивы можно моделировать с помощью класса TStrings:
процедура TForm1 . Button1Click ( Отправитель : TObject ) ; var DataField : TStrings ; я : целое число ; begin DataField : = TStringList . Создать ; DataField . Значения [ 'Салли Смарт' ] : = '555-9999' ; DataField . Значения [ 'John Doe' ] : = '555-1212' ; DataField . Ценности [ 'J. Случайный хакер ' ] : = ' 553-1337 ' ; // доступ к записи и отображение ее в окне сообщения ShowMessage ( DataField . Values [ 'Sally Smart' ]) ; // перебираем ассоциативный массив для i : = 0 в DataField . Count - 1 делать начать ShowMessage ( 'Номер для' + DataField . Имена [ я ] + : '' + DataField . ValueFromIndex [ я ]) ; конец ; DataField . Бесплатно ; конец ;
Erlang
Erlang предлагает множество способов представления отображений; Три самых распространенных в стандартной библиотеке - это списки ключей, словари и карты.
Кейлисты
Кейлисты - это списки кортежей , где первый элемент каждого кортежа является ключом, а второй - значением. В модуле предусмотрены функции для работы со списками ключей lists
.
PhoneBook = [{ "Салли Смит" , "555-9999" }, { "Джон Доу" , "555-1212" }, { "J. Random Hacker" , "553-1337" }].
Доступ к элементу списка ключей можно выполнить с помощью lists:keyfind/3
функции:
{_ Телефон } = списки : keyfind ( "Салли Смит" , 1 , PhoneBook ), ИО : формат ( "Номер телефона: \ с \ п " , [ телефон ]).
Словари
Словари реализованы в dict
модуле стандартной библиотеки. Новый словарь создается с помощью dict:new/0
функции, а новые пары ключ / значение сохраняются с помощью dict:store/3
функции:
PhoneBook1 = dict : new (), PhoneBook2 = dict : store ( "Салли Смит" , "555-9999" , Dict1 ), PhoneBook3 = dict : store ( "John Doe" , "555-1212" , Dict2 ), PhoneBook = dict : store ( "J. Random Hacker" , "553-1337" , Dict3 ).
Такая последовательная инициализация была бы более идиоматически представлена в Erlang с помощью соответствующей функции:
PhoneBook = ДИКТ : from_list ([{ "Салли Смит" , "555-9999" }, { "Джон Доу" , "555-1212" }, { "Дж Случайный Хакер" , "553-1337" }]).
Доступ к словарю можно получить с помощью dict:find/2
функции:
{ ok , Phone } = dict : find ( "Салли Смит" , телефонная книга ), io : format ( "Phone: ~ s ~ n " , [ Phone ]).
В обоих случаях в качестве ключа может использоваться любой термин Erlang. Варианты включают orddict
модуль, реализующий упорядоченные словари и gb_trees
реализующий общие сбалансированные деревья.
Карты
Карты были введены в OTP 17.0, [5] и сочетают в себе сильные стороны списков ключей и словарей. Карта определяется с использованием синтаксиса #{ K1 => V1, ... Kn => Vn }
:
PhoneBook = # { "Салли Смит" => "555-9999" , "John Doe" => "555-1212" , "J. Random Hacker" => "553-1337" }.
Из maps
модуля доступны базовые функции для взаимодействия с картами . Например, maps:find/2
функция возвращает значение, связанное с ключом:
{ ok , Phone } = maps : find ( "Салли Смит" , телефонная книга ), io : format ( "Phone: ~ s ~ n " , [ Phone ]).
В отличие от словарей, карты могут быть сопоставлены по образцу:
# { "Салли Смит" , Телефон } = Телефонная книга , io : format ( "Телефон: ~ s ~ n " , [ Телефон ]).
Erlang также предоставляет синтаксический сахар для функциональных обновлений - создание новой карты на основе существующей, но с измененными значениями или дополнительными ключами:
PhoneBook2 = PhoneBook # { % оператор `: =` обновляет значение, связанное с существующим ключом "J. Random Hacker" : = "355-7331" , % оператор `=>` добавляет новую пару "ключ-значение", потенциально заменяя существующую "Alice Wonderland" => "555-1865" }
F #
Карта <'Ключ,' Значение>
Во время выполнения F # предоставляет Collections.Map<'Key,'Value>
тип, который является неизменяемым деревом AVL .
Создание
В следующем примере вызывается Map
конструктор, который работает со списком (последовательность элементов, разделенных точкой с запятой, заключенная в квадратные скобки) кортежей (которые в F # представляют собой последовательности элементов, разделенных запятыми).
let числа = [ "Салли Смарт" , "555-9999" ; «Джон Доу» , «555-1212» ; "J. Random Hacker" , "555-1337" ] |> Карта
Доступ по ключу
Значения можно искать с помощью одного из Map
членов, например его индексатора или Item
свойства (которые вызывают исключение, если ключ не существует) или TryFind
функции, которая возвращает тип параметра со значением Some
, для успешного поиска или None
, за неудачный. Затем можно использовать сопоставление с шаблоном для извлечения необработанного значения из результата или можно установить значение по умолчанию.
let sallyNumber = numbers . [ "Sally Smart" ] // или пусть sallyNumber = числа . Предмет ( "Салли Смарт" )
пусть sallyNumber = соответствует числам . TryFind ( "Салли Смарт" ) с помощью | Некоторые ( число ) -> число | Нет -> "н / д"
В обоих приведенных выше примерах sallyNumber
значение будет содержать строку "555-9999"
.
Словарь <'TKey,' TValue>
Поскольку F # является языком .NET, он также имеет доступ к функциям .NET Framework , включая System.Collections.Generic.Dictionary<'TKey,'TValue>
тип (который реализован в виде хэш-таблицы ), который является основным типом ассоциативного массива, используемым в C # и Visual Basic. Этот тип может быть предпочтительным при написании кода, который предназначен для работы с другими языками в .NET Framework, или когда характеристики производительности хеш-таблицы предпочтительнее, чем характеристики дерева AVL.
Создание
dict
Функция обеспечивает средство удобно при создании словаря .NET , который не предназначен для мутировать; он принимает последовательность кортежей и возвращает неизменяемый объект, который реализует IDictionary<'TKey,'TValue>
.
let числа = [ "Салли Смарт" , "555-9999" ; «Джон Доу» , «555-1212» ; "J. Random Hacker" , "555-1337" ] |> dict
Когда требуется изменяемый словарь, System.Collections.Generic.Dictionary<'TKey,'TValue>
можно напрямую вызвать конструктор. См. Пример C # на этой странице для получения дополнительной информации.
пусть числа = Система . Коллекции . Универсальный . Dictionary < строка , строка > () числа . Добавьте ( "Салли Смарт" , "555-9999" ) числа . [ "Джон Доу" ] <- "555-1212" числа . Предмет ( "J. Random Hacker" ) <- "555-1337"
Доступ по ключу
IDictionary
у экземпляров есть индексатор, который используется так же, как Map
, хотя и эквивалентен TryFind
is TryGetValue
, который имеет выходной параметр для искомого значения и логическое возвращаемое значение, указывающее, был ли найден ключ.
let sallyNumber = let изменяемый результат = "" если числа . TryGetValue ( "Sally Smart" , & результат ), затем результат else "н / д"
F # также позволяет вызывать функцию, как если бы она не имела выходного параметра, а вместо этого возвращала кортеж, содержащий его обычное возвращаемое значение и значение, присвоенное выходному параметру:
пусть sallyNumber = соответствует числам . TryGetValue ( "Салли Смарт" ) с | истина , число -> число | _ -> "н / д"
Перечисление
Словарь или карту можно перечислить с помощью Seq.map
.
// перебираем коллекцию и отображаем каждую запись. числа |> Посл . карта ( fun kvp -> printfn "Номер телефона для% O -% O" kvp . Ключ kvp . Значение )
FoxPro
Visual FoxPro реализует сопоставление с классом коллекции.
mapping = NEWOBJECT ( "Collection" ) mapping .Add ( "Daffodils" , "flower2" ) && Add (object, key) - ключ должен быть символьным index = mapping .GetKey ( "flower2" ) && возвращает значение индекса 1 объект = mapping ( "flower2" ) && возвращает "Daffodils" (получить по ключу) object = mapping (1) && возвращает "Daffodils" (получить по индексу)
GetKey возвращает 0, если ключ не найден.
Идти
Go имеет встроенную языковую поддержку ассоциативных массивов, называемых «картами». Тип ключа карты может быть только логическим, числовым, строковым, массивом, структурой, указателем, интерфейсом или типом канала.
Тип карты пишется: map[keytype]valuetype
Добавление элементов по одному:
phone_book : = make ( map [ string ] string ) // создаем пустую карту phone_book [ "Sally Smart" ] = "555-9999" phone_book [ "John Doe" ] = "555-1212" phone_book [ "J. Random Hacker " ] = " 553-1337 "
Литерал карты:
phone_book : = map [ string ] string { "Салли Смарт" : "555-9999" , "Джон Доу" : "555-1212" , "J. Random Hacker" : "553-1337" , }
Итерации по карте:
// над обоими ключами и значениями для ключа , значение : = диапазон phone_book { FMT . Printf ( "Число для% s:% s \ n" , ключ , значение ) }// только клавиши для key : = range phone_book { fmt . Printf ( "Имя:% s \ n" , ключ ) }
Haskell
Язык программирования Haskell предоставляет только один вид ассоциативного контейнера - список пар:
m = [( "Салли Смарт" , "555-9999" ), ( "Джон Доу" , "555-1212" ), ( "J. Random Hacker" , "553-1337" )]main = print ( поиск "John Doe" m )
выход:
Просто «555-1212»
Обратите внимание , что функция поиска возвращает «Может быть» значение, которое не является «Ничего» , если не нашли, или «„результат Just “ » , когда найдено.
GHC , наиболее часто используемая реализация Haskell, предоставляет еще два типа ассоциативных контейнеров. Другие реализации также могут предоставить их.
Один из них - полиморфные функциональные карты (представленные в виде неизменяемых сбалансированных бинарных деревьев):
импортировать квалифицированные Data.Map как Mм = M . вставить "Салли Smart" "555-9999" M . пустой т» = M . вставить "John Doe" "555-1212" м м '' = M . вставить "J. Random Hacker" "553-1337" m 'главная = печать ( M . поиск "John Doe" м '' :: Может быть строка )
выход:
Просто «555-1212»
Специализированная версия для целочисленных ключей также существует как Data.IntMap.
Наконец, полиморфная хеш-таблица:
импортировать квалифицированные Data.HashTable как HОсновные = делать м <- H . новый ( == ) Н . hashString Н . вставить м «Салли Смарт» «555-9999» H . вставить м "John Doe" "555-1212" H . вставить м "J. Random Hacker" "553-1337" Foo <- H . поиск м "Джон Доу" print foo
выход:
Просто «555-1212»
Списки пар и функциональные карты предоставляют чисто функциональный интерфейс, который в Haskell более идиоматичен. Напротив, хеш-таблицы обеспечивают императивный интерфейс в монаде ввода-вывода .
Ява
В Java ассоциативные массивы реализованы как «карты», которые являются частью структуры коллекций Java . Начиная с J2SE 5.0 и появления универсальных шаблонов в Java, коллекции могут иметь определенный тип; например, ассоциативный массив, который отображает строки в строки, может быть указан следующим образом:
Карта < String , String > phoneBook = new HashMap < String , String > (); телефонная книга . поставить ( «Салли Смарт» , «555-9999» ); телефонная книга . положите ( "Джон Доу" , "555-1212" ); телефонная книга . положить ( "J. Random Hacker" , "555-1337" );
get
Метод используется для доступа к ключу; например, значение выражения phoneBook.get("Sally Smart")
является "555-9999"
. Этот код использует хэш-карту для хранения ассоциативного массива, вызывая конструктор HashMap
класса. Однако, поскольку в коде используются только общие для интерфейса методы, Map
можно использовать самобалансирующееся двоичное дерево, вызывая конструктор TreeMap
класса (который реализует подинтерфейс SortedMap
), без изменения определения phoneBook
переменной или остальной части кода. или с использованием других базовых структур данных, реализующих Map
интерфейс.
Хеш-функция в Java, используемая HashMap и HashSet, предоставляется Object.hashCode()
методом. Поскольку каждый класс в Java наследует от Object
, каждый объект имеет хэш - функцию. Класс может переопределить реализацию по умолчанию, hashCode()
чтобы предоставить настраиваемую хэш-функцию в большей степени в соответствии со свойствами объекта.
Object
Класс также содержит equals(Object)
метод, который проверяет объект на равенство с другим объектом. Hashed структура данных в Java полагается на объектах , поддержив следующий контракт между их hashCode()
и equals()
методами:
Для двух объектов и б ,
а . равно ( б ) == б . равно ( а ), если а . равно ( b ), то a . hashCode () == б . hashCode ()
Чтобы поддерживать этот контракт, класс, который переопределяет, equals()
также должен переопределять hashCode()
, и наоборот, чтобы hashCode()
он был основан на тех же свойствах (или подмножестве свойств), что и equals()
.
Еще один контракт , который хешированная структура данных с объектом является то , что результаты hashCode()
и equals()
методов не изменятся после того , как объект был вставлен в карту. По этой причине обычно рекомендуется основывать хэш-функцию на неизменяемых свойствах объекта.
Аналогично, TreeMap и другие отсортированные структуры данных требуют, чтобы порядок был определен для типа данных. Либо тип данных должен уже определить свой собственный порядок путем реализации Comparable
интерфейса; или заказ Comparator
должен быть предоставлен во время создания карты. Как и в случае с HashMap выше, относительный порядок ключей в TreeMap не должен меняться после того, как они были вставлены в карту.
JavaScript
JavaScript (и его стандартизированная версия ECMAScript ) - это объектно-ориентированный язык, основанный на прототипах .
Карта и WeakMap
Современный JavaScript обрабатывает ассоциативные массивы, используя классы Map и WeakMap. По умолчанию карта не содержит ключей. Он содержит только то, что явно помещено в него. Ключи и значения могут быть любого типа (включая функции, объекты или любые примитивы).
Создание
Карта может быть инициализирована всеми элементами во время строительства:
var phoneBook = new Map ([ [ "Салли Смарт" , "555-9999" ], [ "Джон Доу" , "555-1212" ], [ "J. Random Hacker" , "553-1337" ] ]);
В качестве альтернативы вы можете инициализировать пустую карту, а затем добавить элементы:
var phoneBook = новая карта (); телефонная книга . набор ( «Салли Смарт» , «555-9999» ); телефонная книга . набор ( «Джон Доу» , «555-1212» ); телефонная книга . набор ( "J. Random Hacker" , "553-1337" );
Доступ по ключу
Доступ к элементу карты можно выполнить с помощью метода get:
var sallyNumber = телефонная книга . получить ( "Салли Смарт" );
В этом примере значение sallyNumber теперь будет содержать строку «555-9999».
Перечисление
Ключи на карте упорядочены. Таким образом, при итерации по нему объект карты возвращает ключи в порядке вставки. Ниже показано перечисление с использованием цикла for:
// перебираем коллекцию и отображаем каждую запись. для ( сопзЬ [ имя , номер ] от PHONEBOOK ) { консоли . log ( 'Номер телефона для $ {name}: $ {number}' ); }
Ключ можно удалить следующим образом:
телефонная книга . удалить ( «Салли Смарт» );
Объект
Объект похож на карту - оба позволяют устанавливать ключи для значений, извлекать эти значения, удалять ключи и определять, хранится ли значение в ключе. По этой причине (а также из-за отсутствия встроенных альтернатив) объекты исторически использовались в качестве карт.
Однако есть важные отличия, которые делают карту предпочтительнее в определенных случаях. В JavaScript объект - это отображение имен свойств на значения, то есть ассоциативный массив с одним предостережением: ключи объекта должны быть либо строкой, либо символом (разрешены собственные объекты и примитивы, неявно преобразованные в строковые ключи) . Объекты также включают одну особенность, не связанную с ассоциативными массивами: объект имеет прототип, поэтому он содержит ключи по умолчанию, которые могут конфликтовать с ключами, определяемыми пользователем. Таким образом, поиск свойства приведет к поиску определения прототипа, если объект не определяет свойство.
Литерал объекта записывается как { property1 : value1, property2 : value2, ... }
. Например:
var myObject = { "Салли Смарт" : "555-9999" , "Джон Доу" : "555-1212" , "Дж. Рэндомный Хакер" : "553-1337" };
Чтобы при поиске не использовались свойства прототипа, вы можете использовать функцию Object.setPrototypeOf:
Объект . setPrototypeOf ( MyObject , нуль );
Начиная с ECMAScript 5 (ES5), прототип также можно обойти, используя Object.create (null):
var myObject = Объект . создать ( ноль );Объект . assign ( myObject , { "Салли Смарт" : "555-9999" , "Джон Доу" : "555-1212" , "J. Random Hacker" : "553-1337" });
Если имя свойства является допустимым идентификатором, кавычки можно опустить, например:
var myOtherObject = { foo : 42 , bar : false }
Поиск написан с использованием нотации доступа к свойствам, либо квадратных скобок, которые работают всегда, либо точечной записи, которая работает только для ключей идентификаторов:
myObject [ "Джон Доу" ] myOtherObject . фу
Вы также можете просмотреть все перечисляемые свойства и связанные значения следующим образом (цикл for-in):
for ( свойство var в myObject ) { значение var = myObject [ свойство ]; консоль . журнал ( "myObject [" + свойство + "] =" + значение ); }
Или (цикл for-of):
для ( сопзИте [ свойства , значения ] от объекта . записей ( MyObject )) { консоли . журнал ( ` $ { свойство } = $ { значение } ` ); }
Свойство можно удалить следующим образом:
удалить myObject [ "Салли Смарт" ];
Как упоминалось ранее, свойства - это строки и символы. Поскольку каждый собственный объект и примитив можно неявно преобразовать в строку, вы можете:
myObject [ 1 ] // ключ равен «1»; обратите внимание, что myObject [1] == myObject ['1'] myObject [[ 'a' , 'b' ]] // ключ - "a, b" myObject [{ toString : function () { return 'hello world' ; }}] // ключ "привет, мир"
В современном JavaScript считается плохим тоном использовать тип Array как ассоциативный массив. По общему мнению, для этой цели лучше всего подходят классы Object и Map / WeakMap. Причина этого заключается в том, что если массив расширяется с помощью прототипа, а объект остается нетронутым, циклы for (in) будут работать должным образом на ассоциативных массивах. Эта проблема была выдвинута на первый план из-за популярности фреймворков JavaScript, которые интенсивно, а иногда и неизбирательно используют прототипы для расширения встроенных типов JavaScript.
См. Раздел « День осведомленности о массивах и прототипах объектов JavaScript» для получения дополнительной информации по этой проблеме.
Юлия
В Julia следующие операции управляют ассоциативными массивами.
Объявить словарь:
телефонная книга = Dict ( "Салли Смарт" => "555-9999" , "Джон Доу" => "555-1212" , "J. Random Hacker" => "555-1337" )
Элемент доступа:
телефонная книга ["Салли Смарт"]
Добавить элемент:
телефонная книга ["Новый контакт"] = "555-2222"
Удалить элемент:
удалить! (телефонная книга, «Салли Смарт»)
Получите ключи и значения в виде итераций :
клавиши (телефонная книга)значения (телефонная книга)
KornShell 93 и совместимые оболочки
В KornShell 93 и совместимых оболочках (ksh93, bash4 ...) с ассоциативными массивами можно использовать следующие операции.
Определение:
наборный - телефонная книга ; # ksh93 declare - телефонная книга ; # Bash4 телефонная книга = ([ "Салли Смарт" ] = "555-9999" [ "Джон Доу" ] = "555-1212" [ "[[Дж Случайный Хакер]]" ] = "555-1337" ) ;
Разыменование:
$ { телефонная книга [ "Джон Доу" ] } ;
Лисп
Изначально Лисп был задуман как язык «обработки списков», и одним из наиболее важных типов данных является связанный список, который можно рассматривать как список ассоциаций (« список »).
' (( "Салли Смарт" . "555-9999" ) ( "Джон Доу" . "555-1212" ) ( "Дж . Рэндомный Хакер" . "553-1337" ))
Синтаксис (x . y)
используется для обозначения пары consed . Ключи и значения не обязательно должны быть одного типа в списке. 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 телефонной книге ( Acons "J. Random Hacker" "555-1337" телефон-книга )))
Эту функцию можно рассматривать как приспособление для cons
операций. [6]
;; Эффект ;; (минусы (минусы КЛЮЧЕВОЕ ЗНАЧЕНИЕ) АЛИСТ) ;; эквивалентно ;; (acons KEY VALUE ALIST) ( let (( phone-book ' (( "Sally Smart . " 555-9999 " ) ( " John Doe " . " 555-1212 " )))) ( cons ( cons " J. Random Хакер " " 555-1337 " ) телефонная книга ))
Конечно, деструктивная push
операция также позволяет вставлять записи в список ассоциаций, причем запись должна составлять cons "ключ-значение", чтобы сохранить действительность отображения.
( нажмите ( минусы "Пустышки" "123-4567" ) телефонной книги )
Поиск записи по ее ключу выполняется через assoc
, который может быть настроен для тестового предиката и направления, особенно поиск в списке ассоциаций от его конца до его начала. Результат, если он положительный, возвращает все минусы записи, а не только ее значение. Неспособность получить соответствующий ключ приводит к возврату NIL
значения.
( связанная телефонная книга "John Doe" : test # ' string = )
Существуют два обобщения assoc
: assoc-if
ожидается функция предиката, которая проверяет ключ каждой записи, возвращая первую запись, для которой предикат NIL
при вызове выдает не значение. assoc-if-not
инвертирует логику, принимая те же аргументы, но возвращая первую сгенерированную запись NIL
.
;; Найдите первую запись, ключ которой равен «Джон Доу». ( assoc-if # ' ( lambda ( key ) ( string = key "John Doe" )) телефонная книга );; Находит первую запись, ключ которой не является ни «Салли Смарт», ни «Джон Доу» ( assoc-if-not # ' ( lambda ( key ) ( member key ' ( «Sally Smart» «John Doe» ) : test # ' string = )) телефонная книга )
Обратный процесс, обнаружение записи по ее значению, использует rassoc
.
;; Найдите первую запись со значением «555-9999». ;; Мы проверяем строковые значения ввода с помощью предиката "string =". ( телефонная книга рассока "555-9999" : test # ' string = )
Соответствующие обобщения rassoc-if
и rassoc-if-not
существуют.
;; Находит первую запись со значением «555-9999». ( rassoc-if # ' ( лямбда ( значение ) ( строка = значение "555-9999" )) телефонная книга );; Находит первую запись, значение которой не равно «555-9999». ( rassoc-if-not # ' ( лямбда ( значение ) ( строка = значение "555-9999" )) телефонная книга )
Все предыдущие функции поиска запись может быть заменен на общий список ориентированных вариантов, таких , как find
, find-if
, find-if-not
, а также соответствующих функций , как position
и его дериватов.
;; Найдите запись с ключом «John Doe» и значением «555-1212». ( найти ( минусы "John Doe" "555-1212" ) телефонная книга : test # ' равно )
Удаление, не имеющее конкретного аналога, производится на основе средств списка, в том числе деструктивных.
;; Создайте и верните список без какой-либо записи, ключ которой равен «John Doe». ( remove-if # ' ( lambda ( entry ) ( string = ( car entry ) "John Doe" )) телефонная книга )
Итерация выполняется с помощью любой функции, которая ожидает список.
;; Итерировать через «карту». ( map NIL # ' ( lambda ( entry ) ( destructuring-bind ( key . value ) entry ( format T "~ & ~ s => ~ s" значение ключа ))) телефонная книга ) ;; Итерировать через "долист". ( dolist ( запись телефонной книги ) ( деструктуризация-привязка ( ключ . значение ) запись ( формат T "~ & ~ s => ~ s" значение ключа )))
Поскольку это структурированные списки, операции обработки и преобразования могут применяться без ограничений.
;; Вернуть вектор значений "телефонной книги". ( карта 'vector #' cdr телефонная книга );; Разрушительно модифицируйте "телефонную книгу" через "map-into". ( map-into phone-book # ' ( lambda ( entry ) ( destructuring-bind ( key . value ) entry ( cons ( обратный ключ ) ( обратное значение )))) телефонная книга )
Из-за своей линейной природы списки используются для относительно небольших наборов данных. 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" ) "553-1337" ))
gethash
Функция позволяет получить значение , связанное с ключом.
( gethash телефонная книга "Джон Доу" )
Кроме того, может быть указано значение по умолчанию для случая отсутствия ключа.
( gethash "Без такого ключа " телефонной книги " Инкогнито" )
Вызов gethash
фактически возвращает два значения: значение или замещающее значение для ключа и логический индикатор, возвращающийся, T
если хэш-таблица содержит ключ, и NIL
сигнализирует о его отсутствии.
( multi -value-bind ( value contains-key ) ( gethash "Sally Smart" phone-book ) ( if contains-key ( format T "~ & Связанное значение: ~ s" value ) ( format T "~ & Ключ может не найти. " )))
Используется remhash
для удаления записи, связанной с ключом.
( телефонная книга remhash "J. Random Hacker" )
clrhash
полностью очищает хеш-таблицу.
( телефонная книга clrhash )
Специальная maphash
функция специализируется на итерации хеш-таблиц.
( maphash # ' ( лямбда ( значение ключа ) ( формат T "~ & ~ s => ~ s" значение ключа )) телефонная книга )
В качестве альтернативы, loop
конструкция предусматривает итерации с помощью ключей, значений или их сочетаний.
;; Итерируйте ключи и значения хеш-таблицы. ( Петля для ключа будучи в хэш-ключей из телефонной книги , используя ( хэш-значение значение ) у ( формат Т «~ & ~ з => ~ с» ключевым значением ));; Итерируйте значения хеш-таблицы. ( Петля для значения будучи в хэш-значения из телефонной книги делать ( печать значение ))
Следующая опция вызывает with-hash-table-iterator
макрос для создания итератора, обработка которого предназначена для запуска вызывающей стороной.
( with-hash-table-iterator ( телефонная книга генератора записей ) ( цикл do ( привязка нескольких значений ( значение ключа has-entry ) ( генератор записей ) ( if has-entry ( формат T "~ & ~ s => ~ s " ключевое значение ) ( конец цикла )))))
В Лиспе легко создавать составные абстрактные типы данных, используя структуры или возможности объектно-ориентированного программирования в сочетании со списками, массивами и хеш-таблицами.
LPC
LPC реализует ассоциативные массивы как основной тип, известный как «карта» или «сопоставление», в зависимости от драйвера. Ключи и значения могут быть любого типа. Литерал отображения записывается как ([ key_1 : value_1, key_2 : value_2 ])
. Процедурный код выглядит так:
отображение phone_book = ([]); phone_book [ "Салли Смарт" ] = "555-9999" ; phone_book [ "Джон Доу" ] = "555-1212" ; phone_book [ "J. Random Hacker" ] = "555-1337" ;
Доступ к сопоставлениям для чтения осуществляется с помощью оператора индексации так же, как и для записи, как показано выше. Таким образом, phone_book ["Sally Smart"] вернет строку "555-9999", а phone_book ["John Smith"] вернет 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 не поддерживают многозначные сопоставления). Пример синтаксиса:
отображение phone_book = ([ : 2 ]); phone_book [ "Салли Смарт" , 0 ] = "555-9999" ; phone_book [ "Салли Смарт" , 1 ] = "99 Sharp Way" ; phone_book [ "Джон Доу" , 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" ;
Драйверы LPC, достаточно современные, чтобы поддерживать конструкцию foreach (), используют ее для перебора своих типов отображения.
Lua
В 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" , - Запятая в конце допустима }aTable = { - Таблица как значение subTable = { 5 , 7.5 , k = true }, - ключ - "subTable" - Функция как значение [ 'John Doe' ] = function ( age ), если возраст < 18, то вернуть " Молодое " остальное верни " Старое! end end , - Таблица и функция (и другие типы) также могут использоваться как ключи }
Если ключ является допустимым идентификатором (не зарезервированным словом), кавычки можно опустить. Идентификаторы чувствительны к регистру.
Поиск записывается с использованием квадратных скобок, что всегда работает, или точечной нотации, которая работает только для ключей идентификатора:
print ( aTable [ "Джон Доу" ] ( 45 )) x = aTable . подтаблица . k
Вы также можете перебирать все ключи и связанные значения с помощью итераторов или циклов for:
simple = { [ true ] = 1 , [ false ] = 0 , [ 3.14 ] = math.pi , x = 'x' , [ "!" ] = 42 } функция FormatElement ( ключ , значение ) return "[" .. tostring ( ключ ) .. "] =" .. значение .. "," end - Итерация по таблице всех ключей . Еогеасп ( простой , функция ( к , v ) io.write ( FormatElement ( к , v )) конец ) печати "" для к , v в парах ( простой ) делать io.write ( FormatElement ( к , v )) конец печати " " k = nil repeat k , v = next ( simple , k ) if k ~ = nil then io.write ( FormatElement ( k , v )) end until k == nil print " »
Запись можно удалить, установив для нее значение nil:
просто . x = ноль
Точно так же вы можете перезаписать значения или добавить их:
простой [ '%' ] = "процент" простой [ '!' ] = 111
Математика и язык Wolfram Language
В Mathematica и Wolfram Language выражение Association используется для представления ассоциативных массивов. [7]
телефонная книга = <| «Салли Смарт» -> «555-9999» , «Джон Доу» -> «555-1212» , «J. Random Hacker» -> «553-1337» |> ;
Чтобы получить доступ: [8]
телефонная книга [[ Ключ [ "Салли Смарт" ]]]
Если ключи являются строками, ключевое слово Key необязательно, поэтому:
телефонная книга [[ "Салли Смарт" ]]
Чтобы перечислить ключи: [9] и значения [10]
Ключи [телефонная книга]Значения [телефонная книга]
Швабры
В MUMPS каждый массив является ассоциативным. Встроенная прямая поддержка ассоциативных массивов на уровне языка применяется к частным массивам для конкретных процессов, хранящимся в памяти, которые называются "локальными", а также к постоянным, совместно используемым глобальным массивам, хранящимся на диске, которые доступны одновременно для нескольких заданий. . Именам глобальных переменных предшествует циркумфлекс «^», чтобы отличать их от локальных переменных.
SET ^ phonebook ("Sally Smart") = "555-9999" ;; постоянное хранение данныхУСТАНОВИТЬ телефонную книгу ("John Doe") = "555-1212" ;; хранение временных данныхУСТАНОВИТЬ телефонную книгу ("J. Random Hacker") = "553-1337" ;; хранение временных данныхMERGE ^ phonebook = phonebook ;; копирование временных данных в постоянные данные
Для доступа к значению элемента просто необходимо использовать имя с нижним индексом:
НАПИШИТЕ «Номер телефона:», ^ телефонную книгу («Салли Смарт») ,!
Вы также можете просмотреть связанный массив следующим образом:
УСТАНОВИТЬ ИМЯ = ""FOR S NAME = $ ORDER (^ phonebook (NAME)) QUIT: NAME = "" WRITE NAME, "Phone Number:", ^ phonebook (NAME) ,!
Objective-C (Какао / GNUstep)
Какао и GNUstep , написанные на Objective-C , обрабатывают ассоциативные массивы с использованием NSMutableDictionary
(изменяемой версии NSDictionary
) кластера классов. Этот класс позволяет выполнять назначения между любыми двумя объектами. Копия ключевого объекта создается до его вставки NSMutableDictionary
, поэтому ключи должны соответствовать NSCopying
протоколу. При вставке в словарь объект значения получает сообщение о сохранении для увеличения счетчика ссылок. Объект значения получит сообщение о выпуске, когда он будет удален из словаря (явно или путем добавления в словарь другого объекта с тем же ключом).
NSMutableDictionary * aDictionary = [[ NSMutableDictionary Alloc ] инициализации ]; [ aDictionary setObject : @ "555-9999" forKey : @ "Салли Смарт" ]; [ aDictionary setObject : @ "555-1212" forKey : @ "John Doe" ]; [ aDictionary setObject : @ "553-1337" forKey : @ "Случайный хакер" ];
Для доступа к назначенным объектам можно использовать эту команду:
id anObject = [ aDictionary objectForKey : @ "Салли Смарт" ];
Все ключи или значения можно перечислить с помощью NSEnumerator
:
NSEnumerator * keyEnumerator = [ словарь keyEnumerator ]; ключ id ; while (( key = [ keyEnumerator nextObject ])) { // ... обрабатываем здесь ... }
В Mac OS X 10.5+ и iPhone OS ключи словаря можно перечислить более кратко с помощью NSFastEnumeration
конструкции: [11]
for ( id key в aDictionary ) { // ... обрабатываем здесь ... }
Что еще более практично, графы структурированных данных могут быть легко созданы с помощью Какао , особенно NSDictionary
( NSMutableDictionary
). Это можно проиллюстрировать на этом компактном примере:
NSDictionary * aDictionary = [ NSDictionary dictionaryWithObjectsAndKeys : [ NSDictionary dictionaryWithObjectsAndKeys : @ "555-9999" , @ "Sally Smart" , @ "555-1212" , @ "John Doe" , nil ], @ " student " , [ NSDictionary dictionaryWithObjectsAndKeys : @ "553-1337" , @ "Random Hacker" , ноль ], @ "hackers" , ноль ];
К соответствующим полям можно быстро получить доступ, используя ключевые пути:
id anObject = [ aDictionary valueForKeyPath : @ " student.Sally Smart" ];
OCaml
Язык программирования OCaml предоставляет три различных ассоциативных контейнера. Самый простой - это список пар:
# let m = [ "Салли Смарт" , "555-9999" ; «Джон Доу» , «555-1212» ; "J. Random Hacker" , "553-1337" ] ;; val m : ( строка * строка ) list = [ ( "Салли Смарт" , "555-9999" ); ( «Джон Доу» , «555-1212» ); ( "J. Random Hacker" , "553-1337" ) ] # Список . ассоци "Джон Доу" м ;; - : string = "555-1212"
Вторая - это полиморфная хеш-таблица:
# let m = Hashtbl . создать 3 ;; val m : ( ' _ a , ' _ b ) Hashtbl . t = < abstr > # Hashtbl . добавить м «Салли Смарт» «555-9999» ; Hashtbl . добавить м "Джон Доу" "555-1212" ; Hashtbl . добавить m "J. Random Hacker" "553-1337" ;; - : unit = () # Hashtbl . найти м "Джон Доу" ;; - : string = "555-1212"
В приведенном выше коде используется хеш-функция по умолчанию OCaml Hashtbl.hash
, которая определяется автоматически для всех типов. Чтобы использовать модифицированную хеш-функцию, используйте интерфейс функтора Hashtbl.Make
для создания модуля, например with Map
.
Наконец, функциональные карты (представленные в виде неизменяемых сбалансированных бинарных деревьев):
# модуль StringMap = Карта . Make ( String ) ;; ... # let m = StringMap . добавить "Салли Смарт" "555-9999" StringMap . пусто let m = StringMap . добавить "Джон Доу" "555-1212" m let m = StringMap . добавить "J. Random Hacker" "553-1337" m ;; val m : строка StringMap . t = < abstr > # StringMap . найти "Джон Доу" m ;; - : string = "555-1212"
Обратите внимание, что для использования Map
вы должны предоставить функтору Map.Make
модуль, который определяет тип ключа и функцию сравнения. Сторонняя библиотека ExtLib предоставляет полиморфную версию функциональных карт, называемую PMap
, [12], которой при создании предоставляется функция сравнения.
Списки пар и функциональные карты обеспечивают чисто функциональный интерфейс. Напротив, хеш-таблицы предоставляют обязательный интерфейс. Для многих операций хеш-таблицы значительно быстрее, чем списки пар и функциональные карты.
OptimJ
OptimJ язык программирования является расширением Java 5. Как делает Java, Optimj предоставляет карты; но OptimJ также предоставляет настоящие ассоциативные массивы. Массивы Java индексируются неотрицательными целыми числами; ассоциативные массивы индексируются с любым типом ключа.
String [ String ] phoneBook = { "Салли Смарт" -> "555-9999" , "Джон Доу" -> "555-1212" , "J. Random Hacker" -> "553-1337" };// String [String] - это не java-тип, а ассоциативный массив optimj type: //, индексируемый строками.// перебираем значения для ( String number : phoneBook ) { System . из . println ( число ); }// Предыдущий оператор выводит: "555-9999" "555-1212" "553-1337"// перебираем ключи для ( String name : phoneBook . keys ) { System . из . println ( имя + "->" + телефонная книга [ имя ] ); } // phoneBook [имя] доступ к значению с помощью ключа (это похоже на доступ к массиву java) // т.е. phoneBook ["John Doe"] возвращает "555-1212"
Конечно, можно определять многомерные массивы, смешивать массивы Java и ассоциативные массивы, смешивать карты и ассоциативные массивы.
int [ String ] [] [ двойной ] a ; java . Util . Карта < String [ Object ] , Integer > b ;
Perl 5
Perl 5 имеет встроенную поддержку ассоциативных массивов на уровне языка. Современный Perl называет ассоциативные массивы хешами ; термин ассоциативный массив встречается в более старой документации, но считается несколько архаичным. Хэши Perl 5 плоские: ключи - это строки, а значения - скаляры. Однако значения могут быть ссылками на массивы или другие хэши, и стандартный модуль Perl 5 Tie :: RefHash позволяет использовать хэши со ссылочными ключами.
Переменная хэш отмечено %
сигилами , чтобы отличить его от скаляра, массива и других типов данных. Хэш-литерал - это список ключ-значение с предпочтительной формой с использованием =>
токена Perl , который семантически в основном идентичен запятой и делает ассоциацию ключ-значение более ясной:
мой % phone_book = ( 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Random Hacker' => '553-1337' , );
Для доступа к хэш-элементу используется синтаксис $hash_name{$key}
- ключ заключен в фигурные скобки, а имя хеш-функции имеет префикс a $
, что указывает на то, что сам хеш-элемент является скалярным значением, даже если он является частью хеш-функции. Стоимость $phone_book{'John Doe'}
составляет '555-1212'
. %
Сигила используется только при обращении к хэш в целом, например, когда просят keys %phone_book
.
Список ключей и значений можно извлечь с помощью встроенных функций keys
и values
, соответственно. Так, например, чтобы распечатать все ключи хэша:
foreach $ name ( ключи % phone_book ) { print $ name , "\ n" ; }
Можно перебирать пары (ключ, значение) с помощью each
функции:
while (( $ name , $ number ) = каждый % phone_book ) { print 'Number for' , $ name , ':' , $ number , "\ n" ; }
Хэш-«ссылка», которая представляет собой скалярное значение, указывающее на хеш, указывается в буквальной форме с использованием фигурных скобок в качестве разделителей, с синтаксисом, аналогичным указанию хеш-литерала:
my $ phone_book = { 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Случайный хакер ' => ' 553-1337 ' , };
Доступ к значениям в хеш-ссылке осуществляется с помощью оператора разыменования:
распечатать $ phone_book -> { 'Салли Смарт' };
Когда хэш, содержащийся в ссылке на хеш, необходимо рассматривать как единое целое, как в случае с keys
функцией, синтаксис выглядит следующим образом:
foreach $ name ( ключи % { $ phone_book }) { print 'Number for' , $ name , ':' , $ phone_book -> { $ name }, "\ n" ; }
Perl 6 (Raku)
Perl 6 , переименованный в «Raku», также имеет встроенную поддержку на уровне языка для ассоциативных массивов, которые называются хешами или объектами, выполняющими «ассоциативную» роль. Как и в Perl 5, хэши по умолчанию в Perl 6 плоские: ключи - это строки, а значения - скаляры. Можно определить хеш, чтобы не приводить все ключи к строкам автоматически: они называются «хешами объектов», потому что ключи таких хешей остаются исходным объектом, а не его преобразованием в строку.
Переменная хэш , как правило , отмечено %
сигилой , чтобы визуально отличить его от скаляра, массива и других типов данных, и определить его поведение по отношению к итерации. Хэш-литерал - это список значений ключа и предпочтительной формы с использованием =>
токена Perl , что делает ассоциацию "ключ-значение" более понятной:
my % phone-book = 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Случайный хакер ' => ' 553-1337 ' ,;
Для доступа к хэш-элементу используется синтаксис %hash_name{$key}
- ключ заключен в фигурные скобки и хеш-имя (обратите внимание, что сигил не изменяется, в отличие от Perl 5). Стоимость %phone-book{'John Doe'}
составляет '555-1212'
.
Список ключей и значений можно извлечь с помощью встроенных функций keys
и values
, соответственно. Так, например, чтобы распечатать все ключи хэша:
для % телефонной книги . ключи -> $ name { скажем $ name ;}
По умолчанию при итерации хеша получаются пары ключ-значение.
для % phone-book -> $ entry { скажите "Номер для $ entry.key (): $ entry.value ()" ; # использование расширенных функций интерполяции}
Также возможно получить чередующиеся значения ключей и значений значений с помощью kv
метода:
для % телефонной книги . kv -> $ name , $ number { скажите "Число для $ name: $ number" ;}
У Раку нет упоминаний. Хэши могут передаваться как отдельные параметры, которые не сглаживаются. Если вы хотите убедиться, что подпрограмма принимает только хеши, используйте сигил % в подписи.
sub list-phone-book ( % pb ) { для % pb . kv -> $ name , $ number { скажите "Число для $ name: $ number" ; }}список-телефонная книга ( % phone-book );
В соответствии с постепенной типизацией хэши могут подвергаться ограничениям типа, ограничивая набор допустимых ключей определенным типом.
# Определите хэш, ключи которого могут быть только целыми числами (тип "Int"). мой % numbersWithNames { Int };# Ключи должны быть целыми числами, как в этом случае. % numbersWithNames . push ( 1 => «один» );# Это вызовет ошибку, поскольку строки в качестве ключей недействительны. % numbersWithNames . push ( "ключ" => "два" );
PHP
Тип встроенного массива PHP на самом деле является ассоциативным массивом. Даже при использовании числовых индексов PHP внутренне хранит массивы как ассоциативные массивы. [13] Итак, PHP может иметь массивы с не последовательной числовой индексацией. Ключи должны быть целыми (числа с плавающей запятой обрезаются до целых) или строкового типа, а значения могут быть произвольного типа, включая другие массивы и объекты. Массивы неоднородны: один массив может иметь ключи разных типов. Ассоциативные массивы PHP могут использоваться для представления деревьев, списков, стеков, очередей и других общих структур данных, не встроенных в PHP.
Ассоциативный массив может быть объявлен с использованием следующего синтаксиса:
$ phonebook = массив (); $ phonebook [ 'Салли Смарт' ] = '555-9999' ; $ phonebook [ 'John Doe' ] = '555-1212' ; $ phonebook [ 'J. Случайный хакер ' ] = ' 555-1337 ' ;// или же$ phonebook = array ( 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Random Hacker' => '555-1337' , );// или, начиная с PHP 5.4$ phonebook = [ 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Случайный хакер ' => ' 555-1337 ' , ];// или же$ phonebook [ 'контакты' ] [ 'Салли Смарт' ] [ 'номер' ] = '555-9999' ; $ phonebook [ 'контакты' ] [ 'Джон Доу' ] [ 'номер' ] = '555-1212' ; $ phonebook [ 'контакты' ] [ 'J. Случайный хакер ' ] [ ' число ' ] = ' 555-1337 ' ;
PHP может обрабатывать ассоциативный массив следующим образом:
foreach ( $ phonebook as $ name => $ number ) { echo 'Номер для' , $ name , ':' , $ number , " \ n " ; }// В последнем примере массива он используется следующим образом: foreach ( $ phonebook [ 'contacts' ] as $ name => $ num ) { echo 'Name:' , $ name , ', number:' , $ num [ 'number ' ], " \ n " ; }
PHP имеет обширный набор функций для работы с массивами. [14]
Ассоциативные массивы, которые могут использовать объекты в качестве ключей вместо строк и целых чисел, могут быть реализованы с помощью SplObjectStorage
класса из стандартной библиотеки PHP (SPL). [15]
Щука
Pike имеет встроенную поддержку ассоциативных массивов, которые называются отображениями. Сопоставления создаются следующим образом:
сопоставление ( строка : строка ) phonebook = ([ "Салли Смарт" : "555-9999" , "Джон Доу" : "555-1212" , "J. Random Hacker" : "555-1337" ]);
Доступ и проверка присутствия в сопоставлениях выполняется с помощью оператора индексации. Так phonebook["Sally Smart"]
что вернет строку "555-9999"
и phonebook["John Smith"]
вернет 0.
Итерацию по отображению можно выполнить с помощью foreach
:
foreach ( телефонная книга ; строковый ключ ; строковое значение ) { запись ( "% s:% s \ n " , ключ , значение ); }
Или используя объект-итератор:
Отображение . Итератор i = get_iterator ( телефонная книга ); while ( i -> index ()) { write ( "% s:% s \ n " , i -> index (), i -> значение ()); я -> следующий (); }
Элементы сопоставления могут быть удалены с помощью m_delete
, который возвращает значение удаленного индекса:
строка sallys_number = m_delete ( телефонная книга , «Салли Смарт» );
PostScript
В PostScript ассоциативные массивы называются словарями. В PostScript уровня 1 они должны быть созданы явно, но уровень 2 ввел прямое объявление с использованием синтаксиса с двойными угловыми скобками:
% Объявление уровня 1 3 dict dup begin / red (rouge) def / green (vert) def / blue (bleu) def end % Декларация уровня 2 << / красный (гниль) / зеленый (грюн) / синий ( синий ) >> % Оба метода оставляют словарь в стеке операндов
Доступ get
к словарям можно получить напрямую, используя или неявно, поместив словарь в стек словарей, используя begin
:
% С двумя предыдущими словарями все еще в стеке операндов / red get print % выводит 'rot' начало зеленая печать % выводит 'верт' конец
Содержимое словаря можно повторять с помощью forall
, но не в каком-либо определенном порядке:
% Пример 2 уровня << / This 1 / That 2 / Other 3 >> { exch = print (is) print == } forall
Что может выводить:
То есть 2 Это является 1 Другой является 3
Словари могут быть расширены (до их определенного размера только на уровне 1) или изменены с помощью put
, а записи могут быть удалены с помощью undef
:
% определить словарь для повторного использования: / MyDict << / rouge (красный) / vert (gruen) >> def % добавить к нему MyDict / bleu (синий) поставить % изменить MyDict / vert (зеленый) поставить % удалить что-нибудь MyDict / rouge undef
Пролог
Некоторые версии Пролога включают в себя словарные утилиты («dict»). [16]
Python
В Python ассоциативные массивы называются словарями . Словарные литералы разделяются фигурными скобками:
phonebook = { "Салли Смарт" : "555-9999" , "Джон Доу" : "555-1212" , "J. Random Hacker" : "553-1337" , }
Чтобы получить доступ к записи в Python, просто используйте оператор индексации массива:
>>> Телефонная книга [ "Салли Смарт" ] '555-9999'
Цикл перебора всех ключей словаря:
>>> для ключа в телефонной книге : ... печати ( ключа , телефонная книга [ ключ ]) Sally Смарт 555 - 9999 Дж . Случайный хакер 553 - 1337 Джон Доу 555 - 1212
Итерирование кортежей (ключ, значение):
>>> для ключа , значения в телефонной книге . items (): ... print ( key , value ) Салли Смарт 555 - 9999 Дж . Случайный хакер 553 - 1337 Джон Доу 555 - 1212
Ключи словаря можно удалить индивидуально с помощью del
оператора. Соответствующее значение может быть возвращено до удаления пары ключ-значение с помощью метода pop типа dict:
>>> del phonebook [ "Джон Доу" ] >>> val = phonebook . pop ( "Салли Смарт" ) >>> телефонная книга . keys () # Осталась только одна клавиша [ 'J. Случайный хакер ' ]
Python 2.7 и 3.x также поддерживают понимание списка словарей , компактный синтаксис для создания словаря из любого итератора:
>>> square_dict = { i : i * i for i in range ( 5 )} >>> square_dict { 0 : 0 , 1 : 1 , 2 : 4 , 3 : 9 , 4 : 16 } >>> { key : значение для ключа , значения в телефонной книге . items (), если в ключе "J" } { 'J. Random Hacker ' : ' 553-1337 ' , ' John Doe ' : ' 555-1212 ' }
Строго говоря, словарь - это надмножество ассоциативного массива, поскольку ни ключи, ни значения не ограничены одним типом данных. Можно представить словарь как «ассоциативный список», использующий номенклатуру Python. Например, также допустимо следующее:
phonebook = { "Салли Смарт" : "555-9999" , "Джон Доу" : Нет , "J. Random Hacker" : - 3.32 , 14 : "555-3322" , }
Ключи словаря должны иметь неизменяемый тип данных. В Python строки неизменяемы из-за их метода реализации.
красный
В Red встроенный тип данных map!
[17] предоставляет ассоциативный массив, который отображает значения типов слов, строк и скалярных ключей на значения любого типа. Для поиска внутри используется хеш-таблица.
Карта может быть записана как литерал, например #(key1 value1 key2 value2 ...)
, или может быть создана с помощью make map! [key1 value1 key2 value2 ...]
:
Красный [ Название: «Моя карта» ]my-map: сделать карту! [ "Салли Смарт" "555-9999" "Джон Доу" "555-1212" "Дж. Рэндом Хакер" "553-1337" ]; Красный сохраняет регистр как для ключей, так и для значений, однако поиск по умолчанию нечувствителен к регистру; можно настроить чувствительность к регистру, используя уточнение / case
для select
и put
.; Конечно, можно использовать значения word!
в качестве ключей, и в этом случае обычно предпочтительнее использовать значения set-word!
при создании карты, но любой тип слова может использоваться для поиска или создания.my-other-map: сделать карту! [ foo: 42 bar: false ]; Обратите внимание, что блок никоим образом не уменьшается и не оценивается, поэтому в приведенном выше примере клавиша bar
связана со словом word!
false
, а чем значение false logic!
; буквальный синтаксис может использоваться, если последнее желательно:my-other-map: сделать карту! [ foo: 42 bar: # [ false ]]; или ключи можно добавить после создания:my-other-map: сделать карту! [ foo: 42 ] my-other-map / bar: false; Поиск можно записать с использованием нотации path!
или с помощью действия select
:выберите my-map "Sally Smart" my-other-map / foo; Вы также можете просмотреть все ключи и значения с помощью foreach
:foreach [ значение ключа ] my-map [ print [ ключ "связан с" значением ] ] ; Ключ можно удалить с помощью remove / key
:удалить / ключ my-map "Салли Смарт"
REXX
В REXX ассоциативные массивы называются «основополагающими переменными» или «составными переменными».
КЛЮЧ = "Салли Смарт" ТЕЛЕФОННАЯ КНИГА . КЛЮЧ = '555-9999' КЛЮЧ = 'Джон Доу' ТЕЛЕФОННАЯ КНИГА . КЛЮЧ = '555-1212' KEY = 'J. Случайный хакер ' ТЕЛЕФОННАЯ КНИГА . КЛЮЧ = '553-1337'
Стволовые переменные с цифровыми клавишами обычно начинаются с 1 и идут оттуда вверх. Переменная основы с нулевым ключом по соглашению содержит общее количество элементов в основе:
ИМЯ . 1 = «Салли Смарт» ИМЯ . 2 = "Джон Доу" ИМЯ . 3 = 'Дж. Случайный хакер ' ИМЯ . 0 = 3
REXX не имеет простого способа автоматического доступа к ключам основной переменной; и обычно ключи хранятся в отдельном ассоциативном массиве с числовыми ключами.
Рубин
В Ruby хеш-таблица используется следующим образом:
IRB (основной): 001: 0> Телефонная книга = { IRB (основной): 002: 1 * 'Sally извилины => '555-9999' , IRB (основной): 003: 1 * 'John Doe' => «555 -1212 ' , irb (main): 004: 1 * ' J. Random Hacker ' => ' 553-1337 ' irb (main): 005: 1> } => {"Салли Смарт" => "555-9999", "John Doe" => "555-1212", "J. Random Hacker "=>" 553-1337 "} irb (main): 006: 0> телефонная книга [ 'John Doe' ] =>" 555-1212 "
Ruby поддерживает хэш-цикл и итерацию со следующим синтаксисом:
irb (main): 007: 0> ### перебирать ключи и значения irb (main): 008: 0 * phonebook . каждый { | ключ , значение | помещает ключ + "=>" + значение } Салли Смарт => 555-9999 Джон Доу => 555-1212 Дж. Случайный хакер => 553-1337 => {"Салли Смарт" => "555-9999", "Джон Doe "=>" 555-1212 "," J. Random Hacker "=>" 553-1337 "} irb (main): 009: 0> ### итерация только ключей irb (main): 010: 0 * телефонная книга . each_key { | ключ | ставит ключ } Салли Смарт Джон Доу Дж. Случайный хакер => {"Салли Смарт" => "555-9999", "Джон Доу" => "555-1212", "Дж. Случайный хакер" => "553-1337 "} irb (main): 011: 0> ### повторять только значения irb (main): 012: 0 * phonebook . each_value { | значение | помещает значение } 555-9999 555-1212 553-1337 => {"Салли Смарт" => "555-9999", "Джон Доу" => "555-1212", "J. Random Hacker" => "553- 1337 "}
Ruby также поддерживает многие другие полезные операции с хешами, такие как слияние хешей, выбор или отклонение элементов, которые соответствуют некоторым критериям, инвертирование (замена ключей и значений) и преобразование хэша в массив.
Ржавчина
Ржавчина стандартная библиотека содержит хэш - карту ( std::collections::HashMap
и В-дерево карту ( std::collections::BTreeMap
). Они имеют несколько методов с одинаковыми именами, но имеют разные требования к типам ключей , которые могут быть вставлены. HashMap
Требует ключей для реализации Eq
( отношения эквивалентности ) и Hash
(хэшируемость), и он хранит записи в неопределенном порядке, а для своих ключей BTreeMap
требует трейта Ord
( общий порядок ) и хранит записи в порядке, определенном типом ключа.Порядок отражается итераторами по умолчанию.
используйте std :: collections :: HashMap ; пусть mut phone_book = HashMap :: new (); phone_book . вставить ( «Салли Смарт» , «555-9999» ); phone_book . вставить ( «Джон Доу» , «555-1212» ); phone_book . вставить ( "J. Random Hacker" , "555-1337" );
Итераторы по умолчанию обращаются ко всем записям в виде кортежей. В HashMap
итераторах посещение записей в неустановленном порядке и BTreeMap
посещены итераторы записи в порядке , определяемый типом ключа.
для ( имя , номер ) в & phone_book { println! ( "{} {}" , имя , номер ); }
Также есть итератор для ключей:
для имени в phone_book . keys () { println! ( "{}" , имя ); }
Сленг
S-Lang имеет тип ассоциативного массива:
телефонная книга = Assoc_Type [];телефонная книга ["Sally Smart"] = "555-9999"телефонная книга ["John Doe"] = "555-1212"телефонная книга ["J. Random Hacker"] = "555-1337"
Вы также можете просмотреть связанный массив несколькими способами:
foreach имя (телефонная книга) {vmessage ("% s% s", имя, телефонная книга [имя]);}
Чтобы напечатать отсортированный список, лучше воспользоваться сильной поддержкой S-lang стандартных массивов:
keys = assoc_get_keys (телефонная книга);i = array_sort (ключи);vals = assoc_get_values (телефонная книга);array_map (Void_Type, & vmessage, "% s% s", keys [i], vals [i]);
Scala
Scala предоставляет неизменяемый Map
класс как часть scala.collection
фреймворка:
val phonebook = Map ( "Салли Смарт" -> "555-9999" , "Джон Доу" -> "555-1212" , "J. Random Hacker" -> "553-1337" )
Вывод типа Scala решит, что это файл Map[String, String]
. Чтобы получить доступ к массиву:
телефонная книга . получить ( "Салли Смарт" )
Это возвращает Option
тип, эквивалент Scala монады Maybe в Haskell.
Болтовня
В SmalltalkDictionary
используется:
телефонная книга : = Словарь новый . в телефонной книге : «Салли Смарт » введите : «555-9999» . Телефонная книга на: 'John Doe' пут: '555-1212' . телефонная книга по адресу: 'J. Случайный хакер поставил: «553-1337» .
Для доступа к записи в #at:
объект словаря отправляется сообщение :
телефонная книга по адресу: «Салли Смарт»
Который дает:
"555-9999"
Словарь хеширует или сравнивает на основе равенства и помечает ключ и значение как сильные ссылки . Существуют варианты, в которых хэширование / сравнение идентичности (IdentityDictionary) или сохранение слабых ссылок (WeakKeyDictionary / WeakValueDictionary). Поскольку каждый объект реализует #hash, любой объект может использоваться как ключ (и, конечно, также как значение).
СНОБОЛ
SNOBOL - один из первых (если не первый) языков программирования, использующий ассоциативные массивы. Ассоциативные массивы в СНОБОЛ называются таблицами.
ТЕЛЕФОННАЯ КНИГА = ТАБЛИЦА () ТЕЛЕФОННАЯ КНИГА [ 'Салли Смарт' ] = '555-9999' ТЕЛЕФОННАЯ КНИГА [ 'Джон Доу' ] = '555-1212' ТЕЛЕФОННАЯ КНИГА [ 'Дж. Random Hacker ' ] = ' 553-1337 '
Стандартный ML
Стандарт SML'97 языка программирования Standard ML не предоставляет никаких ассоциативных контейнеров. Однако различные реализации Standard ML предоставляют ассоциативные контейнеры.
Библиотека популярной реализации Standard ML of New Jersey (SML / NJ) предоставляет подпись (что-то вроде «интерфейса») ORD_MAP
, которая определяет общий интерфейс для упорядоченных функциональных (неизменяемых) ассоциативных массивов. Есть несколько общих functors- BinaryMapFn
, ListMapFn
, RedBlackMapFn
и SplayMapFn
-Вот позволяет создать соответствующий тип заказанной карты (типы являются самобалансировкой бинарного дерево поиска , сортированный ассоциативным список , красно-черного дерево , и скошенное дерево , соответственно) с использованием предоставляемая пользователем структура для описания типа ключа и компаратора. Функтор возвращает структуру в соответствии с ORD_MAP
интерфейсом. Кроме того, есть два предопределенных модуля для ассоциативных массивов, использующих целочисленные ключи: IntBinaryMap
и IntListMap
.
- структура StringMap = BinaryMapFn ( тип структуры ord_key = string val compare = String . compare end ); структура StringMap : ORD_MAP - val m = StringMap . insert ( StringMap . empty , «Салли Смарт» , «555-9999» ) val m = StringMap . insert ( m , «Джон Доу» , «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" } : строка StringMap . карта - StringMap . find ( м , "Джон Доу" ); val it = НЕКОТОРЫЕ "555-1212" : строковый параметр
SML / NJ также предоставляет полиморфную хеш-таблицу:
- исключение NotFound ; исключение NotFound - val m : ( строка , строка ) 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 , ... | ]} : ( строка , строка ) HashTable . hash_table - HashTable . вставить m ( «Салли Смарт» , «555-9999» ); val it = () : unit - HashTable . вставить m ( "Джон Доу" , "555-1212" ); val it = () : unit - HashTable . вставить m ( "J. Random Hacker" , "553-1337" ); val it = () : unit HashTable . найти м "Джон Доу" ; (* возвращает NONE, если не найден *) val it = НЕКОТОРЫЕ "555-1212" : строковый параметр - HashTable . поиск м «Джон Доу» ; (* вызывает исключение, если не найдено *) val it = "555-1212" : строка
Также поддерживаются мономорфные хеш-таблицы с использованием HashTableFn
функтора.
Другая реализация Standard ML, Moscow ML , также предоставляет несколько ассоциативных контейнеров. Во-первых, он предоставляет в Polyhash
структуру полиморфные хеш-таблицы . Кроме того , некоторые функциональные карты из библиотеки SML / NJ выше доступны как Binarymap
, Splaymap
и Intmap
структуры.
Tcl
Есть две возможности Tcl , которые поддерживают семантику ассоциативных массивов. «Массив» - это набор переменных. «Дикт» - это полная реализация ассоциативных массивов.
множество
set { phonebook ( Sally Smart )} 555 - 9999 set john { John Doe } set phonebook ( $ john ) 555 - 1212 set { phonebook ( J. Random Hacker )} 553 - 1337
Если в имени переменной есть пробел, имя должно быть сгруппировано с использованием фигурных скобок (подстановка не производится) или двойных кавычек (подстановка выполняется).
В качестве альтернативы несколько элементов массива могут быть установлены с помощью одной команды, представив их сопоставления в виде списка (слова, содержащие пробелы, заключены в скобки):
массив набор Телефонная книга [ список { Sally Смарт } 555 - +9999 { John Doe } 555 - 1212 { J. Random Hacker } +553 - +1337 ]
Чтобы получить доступ к одной записи массива и вывести ее на стандартный вывод:
помещает $ телефонную книгу ( Салли \ Смарт )
Что возвращает этот результат:
555-9999
Чтобы получить весь массив в виде словаря:
массив получить телефонную книгу
Результатом может быть (порядок ключей не указан не потому, что словарь неупорядочен, а потому, что массив):
{ Салли Смарт } 555-9999 { J. Random Hacker } 553 - 1337 { John Doe } +555 - 1 212
диктовать
набор телефонной книги [ Dict создать { Салли Смарт } 555 - 9999 { John Doe } 555 - 1212 { J. Random Hacker } +553 - +1337 ]
Чтобы найти элемент:
dict получить $ phonebook { Джон Доу }
Чтобы перебрать dict:
Еогеасп { имя номер } $ телефонной книги { путы "Имя: $ \ имя nnumber: $ номер" }
Visual Basic
Visual Basic может использовать класс Dictionary из среды выполнения сценариев Microsoft (которая входит в состав Visual Basic 6). Нет стандартной реализации, общей для всех версий:
'Требуется ссылка на SCRRUN.DLL в свойствах проекта Dim phoneBook As New Dictionary phoneBook . Добавьте телефонную книгу «Салли Смарт» , «555-9999» . Item ( "John Doe" ) = "555-1212" phoneBook ( "J. Random Hacker" ) = "553-1337" Для каждого имени в телефонной книге MsgBox name & "=" & phoneBook ( name ) Далее
Visual Basic .NET
Visual Basic .NET использует классы коллекций, предоставляемые .NET Framework .
Создание
Следующий код демонстрирует создание и заполнение словаря ( дополнительную информацию см. В примере C # на этой странице ):
Dim dic как новая система . Коллекции . Универсальный . Словарь ( Of String , , Струнный ) вий . Добавьте ( "Салли Смарт" , "555-9999" ) dic ( "John Doe" ) = "555-1212" dic . Item ( "J. Random Hacker" ) = "553-1337"
Альтернативный синтаксис - использовать инициализатор коллекции , который компилируется до отдельных вызовов Add
:
Dim dic как новая система . Коллекции . Словарь ( Of String , , Струнный ) С { { "Салли Смарт" , "555-9999" }, { "John Doe" , "555-1212" }, { "J. Random Hacker" , "553-1337" } }
Доступ по ключу
Пример демонстрации доступа (см. Доступ C # ):
Dim sallyNumber = dic ( "Салли Смарт" ) 'или Dim sallyNumber = dic . Предмет ( "Салли Смарт" )
Уменьшить результат как String = Nothing Dim sallyNumber = If ( dic . TryGetValue ( "Sally Smart" , result ), result , "n / a" )
Перечисление
Пример, демонстрирующий перечисление (см. # C # перечисление ):
'просмотреть коллекцию и отобразить каждую запись. Для каждого KVP Как KeyValuePair ( Of String , , строка ) В выпо консоли . WriteLine ( "Номер телефона для {0}: {1}" , kvp . Key , kvp . Value ) Далее
Windows PowerShell
В отличие от многих других интерпретаторов командной строки , Windows PowerShell имеет встроенную поддержку на уровне языка для определения ассоциативных массивов:
$ phonebook = @ { 'Салли Смарт' = '555-9999' ; 'Джон Доу' = '555-1212' ; Дж. Случайный хакер ' = ' 553-1337 ' }
Как и в JavaScript, если имя свойства является допустимым идентификатором, кавычки можно опустить:
$ myOtherObject = @ { foo = 42 ; bar = $ false }
Записи можно разделять точкой с запятой или новой строкой:
$ myOtherObject = @ { foo = 42 bar = $ false ; zaz = 3 }
Ключи и значения могут быть любого типа объекта .NET :
$ now = [DateTime] :: сейчас $ завтра = $ сейчас . AddDays ( 1 ) $ ProcessDeletionSchedule = @ { ( Блокнот Get-Process ) = $ now ( Get-Process calc ) = $ завтра }
Также возможно создать пустой ассоциативный массив и добавить к нему отдельные записи или даже другие ассоциативные массивы позже:
$ phonebook = @ {} $ phonebook + = @ { 'Sally Smart' = '555-9999' } $ phonebook + = @ { 'John Doe' = '555-1212' ; Дж. Случайный хакер ' = ' 553-1337 ' }
Новые записи также могут быть добавлены с помощью оператора индексации массива, оператора свойства или Add()
метода базового объекта .NET:
$ phonebook = @ {} $ phonebook [ 'Sally Smart' ] = '555-9999' $ phonebook . 'John Doe' = '555-1212' $ телефонная книга . Добавить ( 'J. Random Hacker' , '553-1337' )
Для разыменования назначенных объектов можно использовать оператор индексации массива, оператор свойства или параметризованное свойство Item()
объекта .NET:
$ phonebook [ 'Sally Smart' ] $ phonebook . Телефонная книга «Джон Доу» . Предмет ( 'J. Случайный хакер' )
Вы можете просмотреть ассоциативный массив следующим образом:
Телефонная книга $ . Ключи | foreach { "Номер для {0}: {1}" -f $ _ , $ phonebook . $ _ }
Запись может быть удалена с помощью Remove()
метода базового объекта .NET:
Телефонная книга $ . Удалить ( "Салли Смарт" )
Могут быть добавлены хеш-таблицы:
$ hash1 = @ { a = 1 ; b = 2 } $ hash2 = @ { c = 3 ; d = 4 } $ hash3 = $ hash1 + $ hash2
Поддержка форматов сериализации данных
Многие форматы сериализации данных также поддерживают ассоциативные массивы (см. Эту таблицу )
JSON
В JSON ассоциативные массивы также называются объектами. Ключи могут быть только строками.
{ "Салли Смарт" : "555-9999" , "Джон Доу" : "555-1212" , "J. Random Hacker" : "555-1337" }
YAML
Ассоциативные массивы YAML также называются элементами карты или парами ключ-значение. YAML не накладывает ограничений на типы ключей; в частности, они не ограничиваются скалярными или строковыми значениями.
Салли Смарт : 555-9999 Джон Доу : 555-1212 Дж. Случайный хакер : 555-1337
Рекомендации
- ^ здесь , заархивировано здесь , а исходный код доступен здесь . POSIX 1003.1-2001 описывает функции
hcreate()
,hdestroy()
иhsearch()
- ^ "uthash: хеш-таблица для структур C" . Github . Дата обращения 3 августа 2020 .
- ^ «Хеш-таблицы» . Разработчик Gnome . Дата обращения 3 августа 2020 .
- ^ "Ассоциативные массивы - язык программирования D" . dlang.org . Проверено 7 мая 2021 .
- ^ «Эрланг - карты» . erlang.org . Проверено 7 марта 2021 .
- ^ "Common Lisp the Language, 2nd Edition: 15.6. Association Lists" . Университет Карнеги-Меллона . Дата обращения 3 августа 2020 .
- ^ «Ассоциация (<-...->) - Документация по языку Wolfram Language» . reference.wolfram.com .
- ^ «Ключ - документация по языку Wolfram Language» . reference.wolfram.com .
- ^ «Ключи - документация по языку Wolfram Language» . reference.wolfram.com .
- ^ «Ценности - документация по языку Wolfram Language» . reference.wolfram.com .
- ^ «Справочник по протоколу NSFastEnumeration» . Библиотека разработчика Mac . 2011. Архивировано из оригинального 13 марта 2016 года . Дата обращения 3 августа 2020 .
- ^ «Модуль PMap» . Ocaml-extlib . 2008. Архивировано из оригинала 11 декабря 2008 года . Дата обращения 3 августа 2020 .
- ^ О реализации массивов в PHP
- ^ «Массивы» . PHP.net . Дата обращения 3 августа 2020 .
- ^ «Класс SplObjectStorage» . PHP.net . Дата обращения 3 августа 2020 .
- ^ "Dicts: структуры с именованными аргументами"
- ^ «Карта! Тип данных» . doc.red-lang.org .