Comparison of programming languages (associative array): Difference between revisions

Revision as of 22:37, 26 July 2020

Latest revision as of 08:42, 13 August 2025

(98 intermediate revisions by 25 users not shown)

Line 1:

<!-- {{you|date=June 2020}} starting copy edit 21 July 2020 -->

{{ProgLangCompare}}

{{TOC limit|3}}

This '''Comparisoncomparison of programming languages (associative arrays)''' compares the features of [[associative array]] [[data structure]]s or array-lookup processing for over 3940 computer [[programming language]]s.

==Language support==

Line 9 ⟶ 8:

The following is a comparison of [[associative array]]s (also "mapping", "hash", and "dictionary") in various programming languages.

===AwkAWK===

[[AwkAWK]] has built-in, language-level support for associative arrays.

For example:

<syntaxhighlight lang="awk">

phonebook["Sally Smart"] = "555-9999"

phonebook["John Doe"] = "555-1212"

Line 30 ⟶ 29:

The user can search for elements in an associative array, and delete elements from the array.

The following shows how multi-dimensional associative arrays can be simulated in standard AwkAWK using concatenation and the built-in string-separator variable SUBSEP:

<syntaxhighlight lang=awk>

Line 48 ⟶ 47:

There is no standard implementation of associative arrays in [[C (programming language)|C]], but a 3rd-party library, C Hash Table, with BSD license, is available.<ref>[https://web.archive.org/web/20071015024120/http://www.cl.cam.ac.uk/~cwc22/hashtable/ here], archived [https://web.archive.org/web/20040902160534/http://www.cl.cam.ac.uk/~cwc22/hashtable/ here], with the source code available [https://github.com/davidar/c-hashtable/ here]. [[POSIX]] 1003.1-2001 describes the functions <code>hcreate()</code>, <code>hdestroy()</code> and <code>hsearch()</code></ref>

Another 3rd-party library, uthash, also creates associative arrays from C structures. A structure represents a value, and one of the structure fields serves as the key.<ref>http{{cite web |title=uthash: a hash table for C structures |url=https://uthash.sourceforge.net/ uthash|website=Github |access-date=3 August 2020}}</ref>

Finally, the [[GLib]] library also supports associative arrays, along with many other advanced data types and is the recommended implementation of the GNU Project.<ref>{{cite web |title=Hash Tables |url=https://developer.gnome.org/glib/stable/glib-Hash-Tables.html |website=Gnome Developer |access-date=3 August 2020}}</ref>

Similar to [[GLib]], [[Apple Inc.|Apple]]'s cross-platform [[Core Foundation]] framework provides several basic data types. In particular, there are reference-counted CFDictionary and CFMutableDictionary.

Line 64 ⟶ 63:

* assigning to the backing property of the indexer, for which the indexer is [[syntactic sugar]] (not applicable to C#, see [[#F#|F#]] or [[#Visual Basic .NET|VB.NET]] examples).

<syntaxhighlight lang=CSharp"csharp">

Dictionary<string,var string> dicdictionary = new Dictionary<string, string>();

dicdictionary.Add("Sally Smart", "555-9999");

dicdictionary["John Doe"] = "555-1212";

// Not allowed in C#.

// dicdictionary.Item("J. Random Hacker") = "553-1337";

dicdictionary["J. Random Hacker"] = "553-1337";

</syntaxhighlight>

The dictionary can also be initialized during construction using a "collection initializer", which compiles to repeated calls to <code>Add</code>.

<syntaxhighlight lang=CSharp"csharp">

var dicdictionary = new Dictionary<string, string> {

{ "Sally Smart", "555-9999" },

{ "John Doe", "555-1212" },

Line 86 ⟶ 85:

Values are primarily retrieved using the indexer (which throws an exception if the key does not exist) and the <code>TryGetValue</code> method, which has an output parameter for the sought value and a Boolean return-value indicating whether the key was found.

<syntaxhighlight lang=CSharp"csharp">

var sallyNumber = dicdictionary["Sally Smart"];

</syntaxhighlight>

<syntaxhighlight lang=CSharp"csharp">

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

</syntaxhighlight>

In this example, the <code>sallyNumber</code> value will now contain the string <code>"555-9999"</code>.

Line 98 ⟶ 97:

The following demonstrates enumeration using a [[foreach loop]]:

<syntaxhighlight lang=CSharp"csharp">

// loop through the collection and display each entry.

foreach (KeyValuePair<string,string> kvp in dicdictionary)

{

Console.WriteLine("Phone number for {0} is {1}", kvp.Key, kvp.Value);

Line 109 ⟶ 108:

[[C++]] has a form of associative array called [[map (C++)|<code>std::map</code>]] (see [[Standard Template Library#Containers]]). One could create a phone-book map with the following code in C++:

<syntaxhighlight lang=Cpp"cpp">

#include <map>

#include <string>

Line 123 ⟶ 122:

Or less efficiently, as this creates temporary <code>std::string</code> values:

<syntaxhighlight lang=Cpp"cpp">

#include <map>

#include <string>

Line 137 ⟶ 136:

With the extension of [[C++11#Initializer lists|initialization lists]] in C++11, entries can be added during a map's construction as shown below:

<syntaxhighlight lang=Cpp"cpp">

#include <map>

#include <string>

Line 152 ⟶ 151:

You can iterate through the list with the following code (C++03):

<syntaxhighlight lang=Cpp"cpp">

std::map<std::string, std::string>::iterator curr, end;

for(curr = phone_book.begin(), end = phone_book.end(); curr != end; ++curr)

Line 160 ⟶ 159:

The same task in C++11:

<syntaxhighlight lang=Cpp"cpp">

for(const auto& curr : phone_book)

std::cout << curr.first << " = " << curr.second << std::endl;

Line 167 ⟶ 166:

Using the structured binding available in [[C++17]]:

<syntaxhighlight lang=Cpp"cpp">

for (const auto& [name, number] : phone_book) {

std::cout << name << " = " << number << std::endl;

Line 175 ⟶ 174:

In C++, the <code>std::map</code> class is [[Generic programming#Templates in C.2B.2B|templated]] which allows the [[data type]]s of keys and values to be different for different <code>map</code> instances. For a given instance of the <code>map</code> class the keys must be of the same base type. The same must be true for all of the values. Although <code>std::map</code> is typically implemented using a [[self-balancing binary search tree]], C++11 defines a second map called <code>[[std::unordered_map]]</code>, which has the algorithmic characteristics of a hash table. This is a common vendor extension to the [[Standard Template Library]] (STL) as well, usually called <code>hash_map</code>, available from such implementations as SGI and STLPort.

===CFMLCobra===

Initializing an empty dictionary and adding items in [[Cobra (programming language)|Cobra]]:

A structure in [[CFML]] is equivalent to an associative array:

{{sxhl|2=python|1=<nowiki/>

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'

}}

Alternatively, a dictionary can be initialized with all items during construction:

{{sxhl|2=python|1=<nowiki/>

dic = {

'Sally Smart':'555-9999',

'John Doe':'555-1212',

'J. Random Hacker':'553-1337'

}

}}

The dictionary can be enumerated by a for-loop, but there is no guaranteed order:

{{sxhl|2=python|1=<nowiki/>

for key, val in dic

print "[key]'s phone number is [val]"

}}

===ColdFusion Markup Language===

A structure in [[ColdFusion Markup Language]] (CFML) is equivalent to an associative array:

<syntaxhighlight lang=CFS>

Line 189 ⟶ 212:

writeDump(phoneBook); // entire struct

</syntaxhighlight>

===Cobra===

Initializing an empty dictionary and adding items in [[Cobra (programming language)|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'

Alternatively, a dictionary can be initialized with all items during construction:

dic = {

'Sally Smart':'555-9999',

'John Doe':'555-1212',

'J. Random Hacker':'553-1337'

}

The dictionary can be enumerated by a for-loop, but there is no guaranteed order:

for key, val in dic

print "[key]'s phone number is [val]"

===D===

[[D programming language|D]] offers direct support for associative arrays in the core language; such arrays are implemented as a chaining hash table with binary trees.<ref>{{Cite web|title=Associative Arrays - D Programming Language|url=httphttps://digitalmarsdlang.comorg/d/2.0spec/hash-map.html |title=Associative Arrays |accessdateaccess-date=20112021-0205-01 07|workwebsite= |date= dlang.org}}</ref> The equivalent example would be:

<syntaxhighlight lang=D"d">

int main() {

string[ string ] phone_book;

Line 230:

Looping through all properties and associated values, and printing them, can be coded as follows:

<syntaxhighlight lang=D"d">

foreach (key, value; phone_book) {

writeln("Number for " ~ key ~ ": " ~ value );

Line 238:

A property can be removed as follows:

<syntaxhighlight lang=D"d">

phone_book.remove("Sally Smart");

</syntaxhighlight>

===Delphi===

[[Borland Delphi (software)|Delphi]] supports several standard containers, including TDictionary<T>:

<syntaxhighlight lang=Delphi"delphi">

uses

SysUtils,

Line 265:

</syntaxhighlight>

Versions ofPre-2009 Delphi prior to 2009versions do not offer direct support for associative arrays directly. However, associativeSuch arrays can be simulated using the TStrings class:

<syntaxhighlight lang=Delphi"delphi">

procedure TForm1.Button1Click(Sender: TObject);

var

Line 293:

===Erlang===

[[Erlang (programming language)|Erlang]] offers many ways to represent mappings; twothree of the most common in the standard library are keylists, dictionaries, and dictionariesmaps.

====Keylists====

Keylists are lists of tuples, where the first element of each [[tuple]] is a key, and the second is a value. Functions for operating on keylists are provided in the <code>lists</code> module.

Keylists are lists of [[tuple]]s, where the first element of each tuple is a key, and the second is a value. Functions for operating on keylists are provided in the <code>lists</code> module.

<syntaxhighlight lang=Erlang"erlang">

PhoneBook = [{"Sally SmartSmith", "555-9999"},

{"John Doe", "555-1212"},

{"J. Random Hacker", "553-1337"}].

Line 305 ⟶ 306:

Accessing an element of the keylist can be done with the <code>lists:keyfind/3</code> function:

<syntaxhighlight lang=Erlang"erlang">

{_, Phone} = lists:keyfind("Sally SmartSmith", 1, PhoneBook),

io:format("Phone number: ~s~n", [Phone]).

</syntaxhighlight>

====Dictionaries====

Dictionaries are implemented in the <code>dict</code> of the standard library. A new dictionary is created using the <code>dict:new/0</code> function and new key/value pairs are stored using the <code>dict:store/3</code> function:

Dictionaries are implemented in the <code>dict</code> module of the standard library. A new dictionary is created using the <code>dict:new/0</code> function and new key/value pairs are stored using the <code>dict:store/3</code> function:

<syntaxhighlight lang=Erlang"erlang">

PhoneBook1 = dict:new(),

PhoneBook2 = dict:store("Sally Smith", "555-9999", Dict1),

Line 321 ⟶ 323:

Such a serial initialization would be more idiomatically represented in Erlang with the appropriate function:

<syntaxhighlight lang=Erlang"erlang">

PhoneBook = dict:from_list([{"Sally Smith", "555-9999"},
{"John Doe", "555-1212"},

{"J. Random Hacker", "553-1337"}]).

</syntaxhighlight>

The dictionary can be accessed using the <code>dict:find/2</code> function:

<syntaxhighlight lang=Erlang"erlang">

{ok, Phone} = dict:find("Sally Smith", PhoneBook),

io:format("Phone: ~s~n", [Phone]).

Line 334 ⟶ 337:

In both cases, any Erlang term can be used as the key. Variations include the <code>orddict</code> module, implementing ordered dictionaries, and <code>gb_trees</code>, implementing general balanced trees.

====Maps====

Maps were introduced in OTP 17.0,<ref>{{Cite web|title=Erlang -- maps|url=https://erlang.org/doc/man/maps.html|access-date=2021-03-07|website=erlang.org}}</ref> and combine the strengths of keylists and dictionaries. A map is defined using the syntax <code>#{ K1 => V1, ... Kn => Vn }</code>:

<syntaxhighlight lang="erlang">

PhoneBook = #{"Sally Smith" => "555-9999",

"John Doe" => "555-1212",

"J. Random Hacker" => "553-1337"}.

</syntaxhighlight>

Basic functions to interact with maps are available from the <code>maps</code> module. For example, the <code>maps:find/2</code> function returns the value associated with a key:

<syntaxhighlight lang="erlang">

{ok, Phone} = maps:find("Sally Smith", PhoneBook),

io:format("Phone: ~s~n", [Phone]).

</syntaxhighlight>

Unlike dictionaries, maps can be pattern matched upon:

<syntaxhighlight lang="erlang">

#{"Sally Smith", Phone} = PhoneBook,

io:format("Phone: ~s~n", [Phone]).

</syntaxhighlight>

Erlang also provides syntax sugar for functional updates—creating a new map based on an existing one, but with modified values or additional keys:

<syntaxhighlight lang="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"

}

</syntaxhighlight>

===F#===

===={{code|Map<'Key,'Value>}}====

At runtime, [[F Sharp (programming language)|F#]] provides the <code>Collections.Map<'Key,'Value></code> type, which is an immutable [[AVL tree]].

Line 343 ⟶ 381:

The following example calls the <code>Map</code> constructor, which operates on a list (a semicolon delimited sequence of elements enclosed in square brackets) of tuples (which in F# are comma-delimited sequences of elements).

<syntaxhighlight lang="fsharp">

let numbers =

[

Line 353 ⟶ 391:

=====Access by key=====

Values can be looked up via one of the <code>Map</code> members, such as its indexer or <code>Item</code> property (which throw an [[Exception handling|exception]] if the key does not exist) or the <code>TryFind</code> function, which returns an [[option type]] with a value of <{{code>|Some <result></code>|f#}}, for a successful lookup, or <code>None</code>, for an unsuccessful one. [[Pattern matching]] can then be used to extract the raw value from the result, or a default value can be set.

<syntaxhighlight lang="fsharp">

let sallyNumber = numbers.["Sally Smart"]

// or

Line 369 ⟶ 407:

In both examples above, the <code>sallyNumber</code> value would contain the string <code>"555-9999"</code>.

===={{code|Dictionary<'TKey,'TValue>}}====

Because F# is a .NET language, it also has access to features of the [[.NET Framework]], including the <{{code>|System.Collections.Generic.Dictionary<'TKey,'TValue></code>|f#}} type (which is implemented as a [[hash table]]), which is the primary associative array type used in C# and Visual Basic. This type may be preferred when writing code that is intended to operate with other languages on the .NET Framework, or when the performance characteristics of a hash table are preferred over those of an AVL tree.

=====Creation=====

The <code>dict</code> function provides a means of conveniently creating a .NET dictionary that is not intended to be mutated; it accepts a sequence of tuples and returns an immutable object that implements <{{code>|IDictionary<'TKey,'TValue></code>|f#}}.

<syntaxhighlight lang="fsharp">

let numbers =

[

Line 384 ⟶ 422:

</syntaxhighlight>

When a mutable dictionary is needed, the constructor of <{{code>|System.Collections.Generic.Dictionary<'TKey,'TValue></code>|f#}} can be called directly. See [[#C#|the C# example on this page]] for additional information.

<syntaxhighlight lang="fsharp">

let numbers = System.Collections.Generic.Dictionary<string, string>()

numbers.Add("Sally Smart", "555-9999")

Line 396 ⟶ 434:

<code>IDictionary</code> instances have an indexer that is used in the same way as <code>Map</code>, although the equivalent to <code>TryFind</code> is <code>TryGetValue</code>, which has an output parameter for the sought value and a Boolean return value indicating whether the key was found.

<syntaxhighlight lang="fsharp">

let sallyNumber =

let mutable result = ""

Line 403 ⟶ 441:

F# also allows the function to be called as if it had no output parameter and instead returned a tuple containing its regular return value and the value assigned to the output parameter:

<syntaxhighlight lang="fsharp">

let sallyNumber =

match numbers.TryGetValue("Sally Smart") with

Line 421 ⟶ 459:

[[Visual FoxPro]] implements mapping with the Collection Class.

<syntaxhighlight lang="visualfoxprofoxpro">

mapping = NEWOBJECT("Collection")

mapping.Add("Daffodils", "flower2") && Add(object, key) – key must be character

Line 434 ⟶ 472:

[[Go (programming language)|Go]] has built-in, language-level support for associative arrays, called "maps". A map's key type may only be a boolean, numeric, string, array, struct, pointer, interface, or channel type.

A map type is written: <ttcode>map[keytype]valuetype</ttcode>

Adding elements one at a time:

<syntaxhighlight lang=Go"go">

phone_book := make(map[string] string) // make an empty map

phone_book["Sally Smart"] = "555-9999"

Line 447 ⟶ 485:

A map literal:

<syntaxhighlight lang=Go"go">

phone_book := map[string] string {

"Sally Smart": "555-9999",

Line 457 ⟶ 495:

Iterating through a map:

<syntaxhighlight lang=Go"go">

// over both keys and values

for key, value := range phone_book {

Line 470 ⟶ 508:

===Haskell===

The [[Haskell (programming language)|Haskell]] programming language provides only one kind of associative container – a list of pairs:

<syntaxhighlight lang="Haskellhaskell">

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

Line 482 ⟶ 520:

Note that the lookup function returns a "Maybe" value, which is "Nothing" if not found, or "Just 'result{{' "}} when found.

The [[Glasgow Haskell Compiler|GHC]] (GHC), the most commonly used implementation of Haskell, provides two more types of associative containers. Other implementations mightmay also provide these.

One is polymorphic functional maps (represented as immutable balanced binary trees):

<syntaxhighlight lang="Haskellhaskell" highlight="1">

import qualified Data.Map as M

Line 515 ⟶ 553:

Just "555-1212"

Lists of pairs and functional maps both provide a purely functional interface, which is more idiomatic in Haskell. In contrast, hash tables provide an imperative interface in the [[Monad_Monad (functional_programmingfunctional programming)#IO_monadIO monad|IO monad]].

===Java===

In [[Java (programming language)|Java]] associative arrays are implemented as "maps", which are part of the [[Java collections framework]]. Since [[Java Platform, Standard Edition|J2SE]] 5.0 and the introduction of [[generic programming|generics]] into Java, collections can have a type specified; for example, an associative array that maps strings to strings might be specified as follows:

<syntaxhighlight lang=Java"java">

Map<String, String> phoneBook = new HashMap<String, String>();

phoneBook.put("Sally Smart", "555-9999");

Line 529 ⟶ 567:

The {{Javadoc:SE|java/util|Map|get(java.lang.Object)|name=get}} method is used to access a key; for example, the value of the expression <code>phoneBook.get("Sally Smart")</code> is <code>"555-9999"</code>. This code uses a hash map to store the associative array, by calling the constructor of the {{Javadoc:SE|java/util|HashMap}} class. However, since the code only uses methods common to the interface {{Javadoc:SE|java/util|Map}}, a self-balancing binary tree could be used by calling the constructor of the {{Javadoc:SE|java/util|TreeMap}} class (which implements the subinterface {{Javadoc:SE|java/util|SortedMap}}), without changing the definition of the <code>phoneBook</code> variable, or the rest of the code, or using other underlying data structures that implement the <code>Map</code> interface.

The hash function in Java, used by HashMap and HashSet, is provided by the {{Javadoc:SE|java/lang|Object|hashCode()}} method. Since every class in Java [[Inheritance (computerobject-oriented scienceprogramming)|inherits]] from {{Javadoc:SE|java/lang|Object}}, every object has a hash function. A class can [[Method overriding (programming)|override]] the default implementation of <code>hashCode()</code> to provide a custom hash function more in accordance with the properties of the object.

The <code>Object</code> class also contains the {{Javadoc:SE|name=equals(Object)|java/lang|Object|equals(java.lang.Object)}} method, which tests an object for equality with another object. Hashed data structures in Java rely on objects maintaining the following contract between their <code>hashCode()</code> and <code>equals()</code> methods:

Line 535 ⟶ 573:

For two objects ''a'' and ''b'',

<syntaxhighlight lang=Java"java">

a.equals(b) == b.equals(a)

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

Line 546 ⟶ 584:

Analogously, TreeMap, and other sorted data structures, require that an ordering be defined on the data type. Either the data type must already have defined its own ordering, by implementing the {{Javadoc:SE|java/lang|Comparable}} interface; or a custom {{Javadoc:SE|java/util|Comparator}} must be provided at the time the map is constructed. As with HashMap above, the relative ordering of keys in a TreeMap should not change once they have been inserted into the map.

=== [[JavaScript]] ===

[[JavaScript]] (and its standardized version:, [[ECMAScript]]) is a [[Prototype-based programming|prototype-based]] [[Object-oriented programming|object-oriented]] language.

====Map and WeakMap====

Modern JavaScript handles associative arrays, using the <code>Map</code> and <code>WeakMap</code> classes. A map does not contain any keys by default; it only contains what is explicitly put into it. The keys and values can be any type (including functions, objects, or any primitive).

=====Creation=====

Modern JavaScript handles associative arrays using Map and WeakMap classes. A map does not contain any keys by default. It only contains what is explicitly put into it. The keys and values can be any value (including functions, objects, or any primitive).

=====''Creation''=====

A map can be initialized with all items during construction:

<syntaxhighlight lang=JavaScript"javascript">

varconst phoneBook = new Map([

["Sally Smart", "555-9999"],

["John Doe", "555-1212"],

["J. Random Hacker", "553-1337"],

]);

</syntaxhighlight>

Line 568 ⟶ 604:

Alternatively, you can initialize an empty map and then add items:

<syntaxhighlight lang=JavaScript"javascript">

varconst phoneBook = new Map();

phoneBook.set("Sally Smart", "555-9999");

phoneBook.set("John Doe", "555-1212");

Line 575 ⟶ 611:

</syntaxhighlight>

=====''Access by key''=====

Accessing an element of the map can be done with the <code>get</code> method:

<syntaxhighlight lang="javascript">

Accessing an element of the map can be done with the get method:

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

<syntaxhighlight lang=JavaScript>

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

</syntaxhighlight>

In this example, the sallyNumber value <code>sallyNumber</code> will now contain the string "555-9999".

=====''Enumeration''=====

The keys in a map are ordered. Thus, when iterating through it, a map object returns keys in order of insertion. The following demonstrates enumeration using a for-loop:

<syntaxhighlight lang="javascript">

The keys in a map are ordered. Thus, when iterating over it, a map object returns keys in order of insertion. The following demonstrates enumeration using a for-loop:

<syntaxhighlight lang=JavaScript>

// loop through the collection and display each entry.

for (const [name, number] of phoneBook) {

console.log(`Phone number for ${name} is ${number}`);

}

Line 598 ⟶ 632:

A key can be removed as follows:

<syntaxhighlight lang=JavaScript"javascript">

phoneBook.delete("Sally Smart");

</syntaxhighlight>

====Object====

An object is similar to a map—both let you set keys to values, retrieve those values, delete keys, and detect whether a value is stored at a key. For this reason (and because there were no built-in alternatives), objects historically have been used as maps.

However, there are important differences that make a map preferable in certain cases. In JavaScript an object is a mapping from property names to values—that is, an associative array with one caveat: the keys of an object must be either a string or a symbol (native objects and primitives implicitly converted to a string keys are allowed). Objects also include one feature unrelated to associative arrays: an object has a prototype, so it contains default keys that could conflict with user-defined keys. So, doing a lookup for a property will point the lookup to the prototype's definition if the object does not define the property.

An object is similar to a map—both let you set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. For this reason (and because there were no built-in alternatives), objects have been used as maps historically.

However, there are important differences that make a map preferable in certain cases. In JavaScript an object is a mapping from property names to values—that is, an associative array with one caveat: the keys of an object must be either a string or a symbol (native objects and primitives implicitly converted to a string keys are allowed). Objects also include one feature unrelated to associative arrays: an object has a prototype, so it contains default keys that could collide with your own keys if you're not careful. So doing a lookup for a property will forward the lookup to the prototype if the object does not define the property itself.

An object literal is written as <code>{ property1 : value1, property2 : value2, ... }</code>. For example:

<syntaxhighlight lang=JavaScript"javascript">

varconst myObject = {

"Sally Smart" : "555-9999",

"John Doe" : "555-1212",

"J. Random Hacker" : "553-1337",

};

</syntaxhighlight>

To prevent the lookup tofrom using the prototype's properties, you can use the <code>Object.setPrototypeOf</code> function:

<syntaxhighlight lang=JavaScript>

Object.setPrototypeOf(myObject, null);

</syntaxhighlight>

As of ECMAScript 5 (ES5), thisthe prototype can also be bypassed by using <code>Object.create(null)</code>:

<syntaxhighlight lang=JavaScript>

varconst myObject = Object.create(null);

Object.assign(myObject, {

"Sally Smart" : "555-9999",

"John Doe" : "555-1212",

"J. Random Hacker" : "553-1337",

});

</syntaxhighlight>

Line 638 ⟶ 672:

<syntaxhighlight lang=JavaScript>

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

</syntaxhighlight>

Lookup is written using property -access notation, either square brackets, which always workswork, or dot notation, which only works for identifier keys:

<syntaxhighlight lang=JavaScript>

Line 651 ⟶ 685:

<syntaxhighlight lang=JavaScript>

for (varconst property in myObject) {

var const value = myObject[property];

console.log("`myObject[" + ${property + "}] = " + ${value}`);

}

</syntaxhighlight>

Line 660 ⟶ 694:

<syntaxhighlight lang=JavaScript>

for (const [property, value] of Object.entries(myObject)) {

console.log(`${property} = ${value}`);

}

</syntaxhighlight>

Line 674 ⟶ 708:

<syntaxhighlight lang=JavaScript>

myObject[1] // key is "1"; note that myObject[1] == myObject['"1'"]

myObject[['"a'",' "b'"]] // key is "a,b"

myObject[{ toString:function() { return '"hello world'"; } }] // key is "hello world"

</syntaxhighlight>

In modern JavaScript it's considered bad form to use the Array type as an associative array. Consensus is that the Object type and <code>Map</code>/<code>WeakMap</code> classes are best for this purpose. The reasoning behind this is that if Array is extended via prototype and Object is kept pristine, 'for( and for-in)' loops will work as expected on associative 'arrays'. This issue has been drawnbrought intoto focusthe fore by the popularity of JavaScript frameworks that make heavy and sometimes indiscriminate use of prototypeprototypes to extend JavaScript's inbuilt types.

See [http://blog.metawrap.com/2006/05/30/june-6th-is-javascript-array-and-object-prototype-awareness-day/ JavaScript Array And Object Prototype Awareness Day] for more information on the issue.

=== [[Julia (programming language)|Julia]] ===

In [[Julia (programming language)|Julia]], the following operations manage associative arrays.

Declare dictionary:

<syntaxhighlight lang="julia">

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

</syntaxhighlight>

Access element:

<syntaxhighlight lang="julia">

phonebook["Sally Smart"]

phonebook["Sally Smart"]

</syntaxhighlight>

Add element:

<syntaxhighlight lang="julia">

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

</syntaxhighlight>

Delete element:

<syntaxhighlight lang="julia">

delete!(phonebook, "Sally Smart")

</syntaxhighlight>

Get keys and values as [[Iterator#Implicit iterators|iterables]]:

delete!(phonebook, "Sally Smart")

<syntaxhighlight lang="julia">

keys(phonebook)

values(phonebook)

</syntaxhighlight>

===KornShell 93, and compliant shells===

Get keys and values as iterables:

In [[Korn Shell|KornShell]] 93, and compliant shells (ksh93, bash4...), the following operations can be used with associative arrays.

keys(phonebook)

values(phonebook)

=== [[Korn Shell|KornShell]] 93 (and compliant shells: ksh93, bash4...) ===

<!-- Tested in ksh93 r -->

Definition:

<syntaxhighlight lang="ksh">

typeset -A phonebook; # ksh93; in bash4+, "typeset" is a synonym of the more preferred "declare", which works identically in this case

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

declare -A phonebook; # bash4

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

</syntaxhighlight>

Dereference:

<syntaxhighlight lang="ksh">

${phonebook["John Doe"]};

</syntaxhighlight>

=== [[Lisp programming language|Lisp]] ===

[[Lisp programming language|Lisp]] was originally conceived as a "LISt Processing" language, and one of its most important data types is the linked list, which can be treated as an [[association list]] ("alist").

<syntaxhighlight lang=Lisp>

Line 729 ⟶ 772:

</syntaxhighlight>

The syntax <code>(x . y)</code> is used to indicate a [[cons|<code>cons</code>ed]] pair. Keys and values need not be the same type within an alist. Lisp and [[Scheme (programming language)|Scheme]] provide operators such as <code>assoc</code> to manipulate alists in ways similar to associative arrays.

A set of operations specific to the handling of association lists exists for [[Common Lisp]], each of these working non-destructively.

To add an entry the <code>acons</code> function is employed, creating and returning a new association list. An association list in Common Lisp mimicks a stack, that is, adheres to the last-in-first-out (LIFO) principle, and hence prepends to the list head.

Line 742 ⟶ 785:

</syntaxhighlight>

This function can actually be construed as aan convenience accommodatingaccommodation for <code>cons</code> operations.[<ref>{{cite web |title=Common Lisp the Language, 2nd Edition: 15.6. Association Lists |url=https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node153.html] |website=Carnegie Mellon University |access-date=3 August 2020}}</ref>

<syntaxhighlight lang=Lisp>

Line 759 ⟶ 802:

</syntaxhighlight>

Searching for an entry by its key is performed via <code>assoc</code>, which might be configured regardingfor the test predicate and direction, especially searching from the association list from its end to its front. The result, if positive, constitutesreturns the entire entry cons, not only its value. Failure to obtain a matching key ledsleads to a return of the <code>NIL</code> value.

<syntaxhighlight lang=Lisp>

Line 765 ⟶ 808:

</syntaxhighlight>

Two generalizations of <code>assoc</code> exist: <code>assoc-if</code> expects a predicate function testingthat tests each entry's key instead of directly specifying the desiderated key, returning the first entry for which the predicate produces a non-<code>NIL</code> value upon invocation. <code>assoc-if-not</code> inverts the logic, accepting the same arguments, but replying withreturning the first entry generating <code>NIL</code>.

<syntaxhighlight lang=Lisp>

Line 805 ⟶ 848:

</syntaxhighlight>

All of the above explicatedprevious entry search functions can be replaced by general list-centric variants, thatsuch is,as <code>find</code>, <code>find-if</code>, <code>find-if-not</code>, as well as pertinent functions like <code>position</code> and its derivates.

<syntaxhighlight lang=Lisp>

Line 822 ⟶ 865:

</syntaxhighlight>

Iteration is accomplished bywith the aid of any function expectingthat expects a list.

<syntaxhighlight lang=Lisp>

Line 838 ⟶ 881:

</syntaxhighlight>

BeingThese a particularlybeing structured listlists, processing and transformation operations can be applied without constraints.

<syntaxhighlight lang=Lisp>

Line 852 ⟶ 895:

</syntaxhighlight>

Because of their linear nature, alists are used for relatively small sets of data. [[Common Lisp]] also supports a [[hash table]] data type, and for [[Scheme (programming language)|Scheme]] they are implemented in [[Scheme Requests for Implementation|SRFI]] 69. Hash tables have greater overhead than alists, but provide much faster access when there are many elements. A further characteristic mark lies inis the fact that Common Lisp hash tables do not, as opposed to association lists, maintain the order of entry insertion.

Common Lisp hash tables are constructed via the <code>make-hash-table</code> function, whose arguments encompass, among other configurations, a predicate to test the entry key against. While tolerating arbitrary objects, even of heterogeneity inwithin a single hash table instance, the specification of this key <code>:test</code> function confinesis theconfined to distinguishable entities: Thethe Common Lisp standard only mandates the support of <code>eq</code>, <code>eql</code>, <code>equal</code>, and <code>equalp</code>, yet designating additional or custom operations as permissive for concrete implementations.

<syntaxhighlight lang=Lisp>

Line 863 ⟶ 906:

</syntaxhighlight>

The <code>gethash</code> function permits obtention ofobtaining the value associated with a key.

<syntaxhighlight lang=Lisp>

Line 869 ⟶ 912:

</syntaxhighlight>

Additionally, an optionala default value for the case of an absent key may be specified.

<syntaxhighlight lang=Lisp>

Line 875 ⟶ 918:

</syntaxhighlight>

An invocation of <code>gethash</code> actually returns two values: the value or substitute value for the key and a boolean indicator, resolving toreturning <code>T</code> if the hash table contains the key and <code>NIL</code> to signal its absence.

<syntaxhighlight lang=Lisp>

Line 890 ⟶ 933:

</syntaxhighlight>

<code>clrhash</code> completely empties the complete hash table.

<syntaxhighlight lang=Lisp>

Line 896 ⟶ 939:

</syntaxhighlight>

The dedicated <code>maphash</code> function isspecializes specialized onin iterating hash tables.

<syntaxhighlight lang=Lisp>

Line 905 ⟶ 948:

</syntaxhighlight>

Alternatively, the <code>loop</code> construct makes provisions for iterations, either over thethrough keys, values, or the conjunctions of both.

<syntaxhighlight lang=Lisp>

Line 920 ⟶ 963:

</syntaxhighlight>

A further option comprises the invocation ofinvokes <code>with-hash-table-iterator</code>, an iterator-creating macro, the processing of which is intended to be driven by the caller.

<syntaxhighlight lang=Lisp>

Line 931 ⟶ 974:

</syntaxhighlight>

It is easy to construct composite abstract data types in Lisp, using structures and/or the object-oriented programming features, in conjunction with lists, arrays, and hash tables.

=== [[LPC (programming language)|LPC]] ===

[[LPC (programming language)|LPC]] implements associative arrays as a fundamental type known as either "map" or "mapping", depending on the driver. The keys and values can be of any type. A mapping literal is written as <code>([ key_1 : value_1, key_2 : value_2 ])</code>. Procedural usecode looks like:

<syntaxhighlight lang=C>

Line 945 ⟶ 988:

Mappings are accessed for reading using the indexing operator in the same way as they are for writing, as shown above. So phone_book["Sally Smart"] would return the string "555-9999", and phone_book["John Smith"] would return 0. Testing for presence is done using the function member(), e.g. <code>if(member(phone_book, "John Smith")) write("John Smith is listed.\n");</code>

Deletion is accomplished using a function called either m_delete() or map_delete(), depending on the driver, used like: <code>m_delete(phone_book, "Sally Smart");</code>

LPC drivers of the "[[LPMud#Amylaar"|Amylaar]] family implement multivalued mappings using a secondary, numeric index. (Driversother drivers of the [[MudOS]] family do not support multivalued mappings.) Example syntax:

<syntaxhighlight lang=C>

Line 959 ⟶ 1,002:

</syntaxhighlight>

LPC drivers modern enough to support a foreach() construct allowuse iterationit overto iterate through their mapping types using it.

===Lua===

In [[Lua programming language|Lua]], "table" is a fundamental type that can be used either as an array (numerical index, fast) or as an associative array.

=== [[Lua programming language|Lua]] ===

In Lua, table is a fundamental type that can be used either as array (numerical index, fast) or as associative array.

The keys and values can be of any type, except nil. The following focuses on non-numerical indexes.

Line 983 ⟶ 1,027:

</syntaxhighlight>

If the key is a valid identifier (not a keywordreserved word), the quotes can be omitted. TheyIdentifiers are case sensitive.

Lookup is written using either square brackets, which always works, or dot notation, which only works for identifier keys:

Line 992 ⟶ 1,036:

</syntaxhighlight>

You can also loop through all keys and associated values with iterators or for -loops:

<syntaxhighlight lang=Lua>

Line 1,025 ⟶ 1,069:

</syntaxhighlight>

=== [[Mathematica]] and [[Wolfram Language]] ===

[[Mathematica]] and [[Wolfram Language]] use the Association expression to represent associative arrays.<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Association.html|title=Association (<-...->)—Wolfram Language Documentation|website=reference.wolfram.com}}</ref>

Mathematica uses the Association<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Association.html|title=Association (<-...->)—Wolfram Language Documentation|website=reference.wolfram.com}}</ref> expression to represent associative arrays.

<syntaxhighlight lang="mathematica">

phonebook = <| "Sally Smart" -> "555-9999",

"John Doe" -> "555-1212",

"J. Random Hacker" -> "553-1337" |>;

</syntaxhighlight>

To access<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Key.html|title=Key—Wolfram Language Documentation|website=reference.wolfram.com}}</ref>

To access:<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Key.html|title=Key—Wolfram Language Documentation|website=reference.wolfram.com}}</ref>

<syntaxhighlight lang="mathematica">

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

</syntaxhighlight>

If the keys are strings, the ''Key'' keyword is not necessary, so:

If the keys are strings, the Key keyword is not necessary, so:

<syntaxhighlight lang="mathematica">

phonebook[["Sally Smart"]]

</syntaxhighlight>

To list keys<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Keys.html|title=Keys—Wolfram Language Documentation|website=reference.wolfram.com}}</ref> and values<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Values.html|title=Values—Wolfram Language Documentation|website=reference.wolfram.com}}</ref>

To list keys:<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Keys.html|title=Keys—Wolfram Language Documentation|website=reference.wolfram.com}}</ref> and values<ref>{{cite web|url=https://reference.wolfram.com/language/ref/Values.html|title=Values—Wolfram Language Documentation|website=reference.wolfram.com}}</ref>

Keys[phonebook]

Values[phonebook]

=== [[MUMPS]] ===

In [[MUMPS]] every array is an associative array. The built-in, language-level, direct support for associative arrays

applies to private, process-specific arrays stored in memory called "locals" as well as to the permanent, shared, global arrays stored on disk which are available concurrently byto multiple jobs. The name for globals is preceded by the circumflex "^" to distinguish itthem from local variable namesvariables.

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

To accessAccessing the value of an element, simply requires using the name with the subscript:

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

Line 1,064 ⟶ 1,114:

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

=== [[Objective-C]] (Cocoa/GNUstep) ===

[[Cocoa (API)|Cocoa]] and [[GNUstep]], written in [[Objective-C]], handle associative arrays using <code>NSMutableDictionary</code> (a mutable version of <code>NSDictionary</code>) class cluster. This class allows assignments between any two objects to be made. A copy of the key object is made before it is inserted into <code>NSMutableDictionary</code>, therefore the keys must conform to the <code>NSCopying</code> protocol. When being inserted to a dictionary, the value object receives a retain message to increase its reference count. The value object will receive the release message when it will be deleted from the dictionary (botheither explicitly or by adding to the dictionary a different object with the same key).

<syntaxhighlight lang=ObjC>

Line 1,074 ⟶ 1,124:

</syntaxhighlight>

To access assigned objects, this command may be used:

<syntaxhighlight lang=ObjC>

Line 1,080 ⟶ 1,130:

</syntaxhighlight>

All keys or values can be simply enumerated using <code>NSEnumerator</code>:

<syntaxhighlight lang=ObjC>

Line 1,091 ⟶ 1,141:

</syntaxhighlight>

OnIn Mac OS X 10.5+ and iPhone OS, dictionary keys can also be enumerated more concisely using thisthe [<code>NSFastEnumeration</code> construct:<ref>{{cite web |title=NSFastEnumeration Protocol Reference |url=https://developer.apple.com/documentation/Cocoa/Reference/NSFastEnumeration_protocol/ NSFastEnumeration]|date=2011 construct|archive-url=https://web.archive.org/web/20160313082808/https://developer.apple.com/library/mac/documentation/Cocoa/Reference/NSFastEnumeration_protocol/ |archive-date=13 March 2016 |website=Mac Developer Library |access-date=3 August 2020}}</ref>

<syntaxhighlight lang=ObjC>

Line 1,114 ⟶ 1,164:

</syntaxhighlight>

And relevantRelevant fields can be quickly accessed using key paths:

<syntaxhighlight lang=ObjC>

Line 1,120 ⟶ 1,170:

</syntaxhighlight>

=== [[OCaml]] ===

The [[OCaml]] programming language provides three different associative containers. The simplest is a list of pairs:

<syntaxhighlight lang=OCaml>

Line 1,150 ⟶ 1,200:

</syntaxhighlight>

The code above uses OCaml's default hash function <code>Hashtbl.hash</code>, which is defined automatically for all types. If you wanted toTo use youra ownmodified hash function, you can use the functor interface <code>Hashtbl.Make</code> to create a module, likesuch as with <code>Map</code> below.

Finally, functional maps (represented as immutable balanced binary trees):

Line 1,165 ⟶ 1,215:

</syntaxhighlight>

Note that in order to use <code>Map</code>, you have to provide the functor <code>Map.Make</code> with a module which defines the key type and the comparison function. The third-party library ExtLib provides a polymorphic version of functional maps, called [<code>PMap</code>,<ref>{{cite web |title=Module PMap |url=http://ocaml-extlib.googlecode.com/svn/doc/apiref/PMap.html |date=2008 |archive-url=https://web.archive.org/web/20081211233540/http://ocaml-extlib.googlecode.com/svn/doc/apiref/PMap.html PMap],|archive-date=11 whereDecember you2008 provide|website=Ocaml-extlib the|access-date=3 comparisonAugust function2020}}</ref> whenwhich creatingis given a comparison function theupon mapcreation.

Lists of pairs and functional maps both provide a purely functional interface. InBy contrast, hash tables provide an imperative interface. For many operations, hash tables are significantly faster than lists of pairs and functional maps.

=== [[OptimJ]] ===

{{More citations needed section|date=February 2011}}

The [[OptimJ]] programming language is an extension of Java 5. As javadoes Java, Optimj provides maps.; But,but OptimJ also provides true associative arrays:. javaJava arrays are indexed with 0non-basednegative integers; associative arrays are indexed with any collectiontype of keyskey.

<syntaxhighlight lang=Java>

String[String] phoneBook = {

"Sally Smart" -> "555-9999",

"John Doe" -> "555-1212",

"J. Random Hacker" -> "553-1337"

};

Line 1,184 ⟶ 1,234:

// iterate over the values

for (String number : phoneBook) {

System.out.println(number);

}

Line 1,191 ⟶ 1,241:

// 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)

Line 1,199 ⟶ 1,249:

</syntaxhighlight>

Of course, it is possible to define multi-dimensional arrays, to mix javaJava arrayarrays and associative arrays, to mix maps and associative arrays.

<syntaxhighlight lang=Java>

int[String][][double] a;

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

</syntaxhighlight>

=== [[Perl 5]] ===

[[Perl 5]] has built-in, language-level support for associative arrays. Modern Perl vernacular refers to associative arrays as ''hashes''; the term ''associative array'' is found in older documentation, but is considered somewhat archaic. Perl 5 hashes are flat: keys are strings and values are scalars. However, values may be [[reference (computer science)|references]] to arrays or other hashes, and the standard Perl 5 module Tie::RefHash enables hashes to be used with reference keys.

A hash variable is marked by a <code>%</code> [[sigil (computer programming)|sigil]], to distinguish it from scalar, array, and other data types. A hash literal is a key-value list, with the preferred form using Perl's <code>=&gt;</code> token, which is mostly semantically mostly identical to the comma and makes the key-value association clearer:

<syntaxhighlight lang=Perl>

Line 1,219 ⟶ 1,269:

</syntaxhighlight>

Accessing a hash element uses the syntax <code>$hash_name{$key}</code> – the key is surrounded by ''[[Bracket#Curly bracket|curly braces'']] and the hash name is prefixed by a <code>$</code>, indicating that the hash element itself is a ''scalar'' value, even though it is part of a hash. The value of <code>$phone_book{'John Doe'}</code> is <code>'555-1212'</code>. The <code>%</code> sigil is only used when referring to the hash as a whole, such as when asking for <code>keys %phone_book</code>.

The list of keys and values can be extracted using the built-in functions <code>keys</code> and <code>values</code>, respectively. So, for example, to print all the keys of a hash:

Line 1,237 ⟶ 1,287:

</syntaxhighlight>

A hash ''"reference''", which is a scalar value that points to a hash, is specified in literal form using curly braces as delimiters, with syntax otherwise similar to specifying a hash literal:

<syntaxhighlight lang=Perl>

Line 1,261 ⟶ 1,311:

</syntaxhighlight>

===Perl [[Raku6 (programming languageRaku)|Raku]] ===

[[Raku (programming language)|Perl 6]], renamed as "Raku", also has built-in, language-level support for associative arrays, which are referred to as ''hashes'' or as objects performing the ''Associative''"associative" role. ByAs defaultin Perl 5, Perl 6 default hashes are flat: keys are strings and values are scalars. One can define a ''hash'' to not coerce all keys to strings automatically: these are referred to as ''"object hashes''", because the keys of such hashes remain the original object rather than a stringification thereof.

A hash variable is typically marked by a <code>%</code> [[sigil (computer programming)|sigil]], to visually distinguish it from scalar, array, and other data types, and to define its behaviour towards iteration. A hash literal is a key-value list, with the preferred form using Perl's <code>=&gt;</code> token, which makes the key-value association clearer:

<syntaxhighlight lang=Perl6>

Line 1,274 ⟶ 1,324:

</syntaxhighlight>

Accessing a hash element uses the syntax <code>%hash_name{$key}</code> – the key is surrounded by ''curly braces'' and the hash name (note that the sigil does '''not''' change, contrary to [[Perl 5]]). The value of <code>%phone-book{'John Doe'}</code> is <code>'555-1212'</code>.

The list of keys and values can be extracted using the built-in functions <code>keys</code> and <code>values</code>, respectively. So, for example, to print all the keys of a hash:

Line 1,284 ⟶ 1,334:

</syntaxhighlight>

By default, when iterating overthrough a ''hash'', one gets key/valuekey–value ''Pair''spairs.

<syntaxhighlight lang=Perl6>

Line 1,292 ⟶ 1,342:

</syntaxhighlight>

It's is also possible to get alternating key values and value values by using the ''<code>kv''</code> method:

<syntaxhighlight lang=Perl6>

Line 1,300 ⟶ 1,350:

</syntaxhighlight>

[[Raku (programming language)|Raku]] doesn't have any references. Hashes can be passed around as single parameters that doare not get flattened. If you want to make sure that a subroutine only accepts hashes, use the ''%'' sigil in the ''Signature''.

<syntaxhighlight lang=Perl6>

Line 1,311 ⟶ 1,361:

</syntaxhighlight>

CompliantIn compliance with the sense of [[gradual typing]], hashes may be subjected to type constraints, confining thea set of valid keys to a certain type.

<syntaxhighlight lang=Perl6>

Line 1,324 ⟶ 1,374:

</syntaxhighlight>

=== [[PHP]] ===

[[PHP]]'s built-in array type is, in reality, an associative array. Even when using numerical indexes, PHP internally stores itarrays as an associative arrayarrays.<ref>About the implementation of [http://se.php.net/manual/en/language.types.array.php Arrays] in PHP</ref> This is why one inSo, PHP can have non-consecutiveconsecutively numerically indexed arrays. The keys have to be of integer or string (floating point numbers are truncated to integer) or string type, while values can be of arbitrary types, including other arrays and objects. The arrays are heterogeneous;: a single array can have keys of different types. PHP's associative arrays can be used to represent trees, lists, stacks, queues, and other common data structures not built into PHP.

An associative array can be declared using the following syntax:

<syntaxhighlight lang=PHP"php">

$phonebook = array();

$phonebook['Sally Smart'] = '555-9999';

Line 1,360 ⟶ 1,410:

PHP can loop through an associative array as follows:

<syntaxhighlight lang=PHP"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";

}

</syntaxhighlight>

PHP has an [http://php.net/array extensive set of functions] to operate on arrays.<ref>{{cite web |title=Arrays |url=https://www.php.net/manual/en/language.types.array.php |website=PHP.net |access-date=3 August 2020}}</ref>

IfAssociative you want an associative arrayarrays that can use objects as keys, instead of strings and integers, you can usebe implemented with the [http://php.net<code>SplObjectStorage</SplObjectStorage SplObjectStorage]code> class from the Standard PHP Library (SPL).<ref>{{cite web |title=The SplObjectStorage class |url=http://php.net/SplObjectStorage |website=PHP.net |access-date=3 August 2020}}</ref>

=== [[Pike (programming language)|Pike]] ===

[[Pike (programming language)|Pike]] has built-in support for Associativeassociative Arraysarrays, which are referred to as mappings. Mappings are created as follows:

<syntaxhighlight lang=Pike"pike">

mapping(string:string) phonebook = ([

"Sally Smart":"555-9999",

Line 1,388 ⟶ 1,438:

Accessing and testing for presence in mappings is done using the indexing operator. So <code>phonebook["Sally Smart"]</code> would return the string <code>"555-9999"</code>, and <code>phonebook["John Smith"]</code> would return 0.

Iterating through a mapping can be done using either <code>foreach</code>:

<syntaxhighlight lang="pike">

foreach(phonebook; string key; string value) {

write("%s:%s\n", key, value);

Line 1,398 ⟶ 1,448:

Or using an iterator object:

<syntaxhighlight lang="pike">

Mapping.Iterator i = get_iterator(phonebook);

while (i->index()) {

Line 1,406 ⟶ 1,456:

</syntaxhighlight>

Elements of a mapping can be removed using <code>m_delete</code>, which returns the value of the removed index:

<syntaxhighlight lang="pike">

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

</syntaxhighlight>

=== PostScript ===

In [[PostScript]], associative arrays are called dictionaries. In Level 1 PostScript they must be created explicitly, but Level 2 introduced direct declaration using thea double-braceangled-bracket syntax:

<syntaxhighlight lang="postscript">

Line 1,432 ⟶ 1,482:

% Both methods leave the dictionary on the operand stack

</syntaxhighlight>

Dictionaries can be accessed directly using '''get''' or implicitly by placing the dictionary on the dictionary stack using '''begin''':

Dictionaries can be accessed directly, using <code>get</code>, or implicitly, by placing the dictionary on the dictionary stack using <code>begin</code>:

<syntaxhighlight lang="postscript">

Line 1,443 ⟶ 1,494:

</syntaxhighlight>

Dictionary contents can be iterated through using '''<code>forall'''</code>, though not in any particular order:

<syntaxhighlight lang="postscript">

Line 1,453 ⟶ 1,504:

>> {exch =print ( is ) print ==} forall

</syntaxhighlight>

May well output:

Which may output:

<syntaxhighlight lang="postscript">

That is 2

Line 1,460 ⟶ 1,513:

</syntaxhighlight>

Dictionaries can be augmented (up to their defined size only in Level 1) or altered using '''<code>put'''</code>, and entries can be removed using '''<code>undef'''</code>:

<syntaxhighlight lang="postscript">

% define a dictionary for easy reuse:

Line 1,480 ⟶ 1,533:

=== Prolog ===

Some versions of [[Prolog]] include dictionary ("dictsdict") utilities.<ref>[http://www.swi-prolog.org/pldoc/man?section=dicts "Dicts: structures with named arguments"]</ref>

[http://www.swi-prolog.org/pldoc/man?section=dicts "Dicts: structures with named arguments"].

</ref>

=== [[Python (programming language)|Python]] ===

In [[Python (programming language)|Python]], associative arrays are called ''"[[Python syntax and semantics#Collection types|dictionaries]]''". Dictionary literals are markeddelimited withby curly braces:

<syntaxhighlight lang=Python"python">

phonebook = {

'"Sally Smart'": '"555-9999'",

'"John Doe'": '"555-1212'",

'"J. Random Hacker'": '"553-1337'",

}

</syntaxhighlight>

ToDictionary accessitems ancan entrybe inaccessed Python simply useusing the array indexing operator. For example,:

<syntaxhighlight lang=Pycon"python">

>>> phonebook['"Sally Smart'"]

'555-9999'

</syntaxhighlight>

An example loop [[iterator#Python|iterating]] through all the keys of the dictionary:

Loop [[iterator#Python|iterating]] through all the keys of the dictionary:

<syntaxhighlight lang=Pycon>

<syntaxhighlight lang="python">

>>> for key in phonebook:

... print(key, phonebook[key])

Line 1,512 ⟶ 1,564:

Iterating through (key, value) tuples:

<syntaxhighlight lang=Pycon"python">

>>> for key, value in phonebook.items():

... print(key, value)

Line 1,520 ⟶ 1,572:

</syntaxhighlight>

Dictionary keys can be individually deleted using the <code>del</code> statement. The corresponding value can be returned before the key-value pair areis deleted using the "pop" method of "dict" typestype:

<syntaxhighlight lang=Pycon"python">

>>> del phonebook['"John Doe'"]

>>> val = phonebook.pop('"Sally Smart'")

>>> phonebook.keys() # Only one key left

['J. Random Hacker']

</syntaxhighlight>

Python 2.7 and 3.x also supportssupport dictionary[https://peps.python.org/pep-0274/ dict comprehensions] (similar to [[list comprehension]]s), a compact syntax for generating a dictionary from any iterator:

<syntaxhighlight lang=Pycon>

<syntaxhighlight lang="python">

>>> 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'}

</syntaxhighlight>

Strictly speaking, a dictionary is a super-set of an associative array, since neither the keys or values are limited to a single datatype. One could think of a dictionary as an ''"associative list''" using the nomenclature of Python. For example, the following is also legitimate:

<syntaxhighlight lang=Python"python">

phonebook = {

'"Sally Smart'": '"555-9999'",

'"John Doe'": None,

'"J. Random Hacker'": -3.32,

14: '"555-3322'",

}

</syntaxhighlight>

Line 1,551 ⟶ 1,604:

The dictionary keys must be of an [[Immutable object|immutable]] data type. In Python, strings are immutable due to their method of implementation.

=== [[Red (programming language)|Red]] ===

In [[Red (programming language)|Red]] the built-in <code>map!</code><ref>{{cite web|url=https://doc.red-lang.org/en/datatypes/map.html|title=Map! datatype|website=doc.red-lang.org}}</ref> datatype provides an associative array mappingthat maps values of word, string, and scalar key types to values of any type. A hash table is used internally for lookup of keys.

A map can be written as a literal, such likeas <code>#(key1 value1 key2 value2 ...)</code>, or can be created using <code>make map! [key1 value1 key2 value2 ...]</code>. For example:

<syntaxhighlight lang=Red"red">

Red [Title:"My map"]

Line 1,596 ⟶ 1,649:

</syntaxhighlight>

=== [[REXX]] ===

In [[REXX]], associative arrays are called ''Stem"stem variables''" or ''"Compound variables''".

<syntaxhighlight lang=REXX"rexx">

KEY = 'Sally Smart'

PHONEBOOK.KEY = '555-9999'

Line 1,608 ⟶ 1,661:

</syntaxhighlight>

Stem variables with numeric keys typically start at 1 and go up from there. The 0 -key stem variable

is used (by convention) ascontains the counttotal number of items in the whole stem.:

<syntaxhighlight lang=REXX"rexx">

NAME.1 = 'Sally Smart'

NAME.2 = 'John Doe'

Line 1,618 ⟶ 1,671:

</syntaxhighlight>

REXX has no easy way of automatically accessing the keys forof a stem variable; and typically the

keys are stored in a separate associative array, with numeric keys.

=== [[Ruby programming language|Ruby]] ===

In [[Ruby programming language|Ruby]] a hash table is used as follows:

<syntaxhighlight lang="rb">

In Ruby a [[hash table|hash]] is used as follows:

phonebook = {

'Sally Smart' => '555-9999',

<syntaxhighlight lang=irb>

'John Doe' => '555-1212',

irb(main):001:0> phonebook = {

irb(main):002:1* 'SallyJ. Random SmartHacker' => '555553-99991337',

}

irb(main):003:1* 'John Doe' => '555-1212',

phonebook['John Doe']

irb(main):004:1* 'J. Random Hacker' => '553-1337'

irb(main):005:1> }

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

irb(main):006:0> phonebook['John Doe']

=> "555-1212"

</syntaxhighlight>

Ruby supports hash looping and iteration with the following syntax:

<syntaxhighlight lang="irb">

irb(main):007:0> ### iterate over keys and values

irb(main):008:0* phonebook.each {|key, value| puts key + " => " + value}

Line 1,661 ⟶ 1,711:

Ruby also supports many other useful operations on hashes, such as merging hashes, selecting or rejecting elements that meet some criteria, inverting (swapping the keys and values), and flattening a hash into an array.

===Rust===

=== [[S-Lang (programming language)|S-Lang]] ===

The [[Rust (programming language)|Rust]] standard library provides a hash map (<code>std::collections::HashMap</code>) and a [[B-tree]] map (<code>std::collections::BTreeMap</code>). They share several methods with the same names, but have different requirements for the types of keys that can be inserted. The <code>HashMap</code> requires keys to implement the <code>Eq</code> ([[equivalence relation]]) and <code>Hash</code> (hashability) traits and it stores entries in an unspecified order, and the <code>BTreeMap</code> requires the <code>Ord</code> ([[total order]]) trait for its keys and it stores entries in an order defined by the key type. The order is reflected by the default iterators.

S-Lang has an associative array type.

<syntaxhighlight lang="rust">

For example:

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");

</syntaxhighlight>

The default iterators visit all entries as tuples. The <code>HashMap</code> iterators visit entries in an unspecified order and the <code>BTreeMap</code> iterator visits entries in the order defined by the key type.

<syntaxhighlight lang="rust">

for (name, number) in &phone_book {

println!("{} {}", name, number);

}

</syntaxhighlight>

There is also an iterator for keys:

<syntaxhighlight lang="rust">

for name in phone_book.keys() {

println!("{}", name);

}

</syntaxhighlight>

===S-Lang===

[[S-Lang]] has an associative array type:

<syntaxhighlight lang="text">

Line 1,673 ⟶ 1,746:

</syntaxhighlight>

You can also loop through an associated array in a number of ways.:

Here is one

<syntaxhighlight lang="text">

Line 1,692 ⟶ 1,764:

</syntaxhighlight>

=== [[Scala (programming language)|Scala]] ===

[[Scala (programming language)|Scala]] provides an immutable <code>Map</code> class as part of the <code>scala.collection</code> framework:

<syntaxhighlight lang=Scala"scala">

val phonebook = Map("Sally Smart" -> "555-9999",

"John Doe" -> "555-1212",

Line 1,701 ⟶ 1,773:

</syntaxhighlight>

Scala's [[type inference]] will work outdecide that this is a <code>Map[String, String]</code>. To access the array:

<syntaxhighlight lang=Scala"scala">

phonebook.get("Sally Smart")

</syntaxhighlight>

This returns an <code>Option</code> type, Scala's equivalent of athe [[Monad (functional programming)#The Maybe monad|the Maybe monad]] in Haskell.

=== [[Smalltalk]] ===

In [[Smalltalk]] a dictionary<code>Dictionary</code> is used:

<syntaxhighlight lang=Smalltalk"smalltalk">

phonebook := Dictionary new.

phonebook at: 'Sally Smart' put: '555-9999'.

Line 1,719 ⟶ 1,791:

</syntaxhighlight>

To access an entry the message <code>#at:</code> is sent to the dictionary object.:

<syntaxhighlight lang=Smalltalk"smalltalk">

phonebook at: 'Sally Smart'

</syntaxhighlight>

Which gives:

<syntaxhighlight lang=Text"text">

'555-9999'

</syntaxhighlight>

Dictionary hashes/compares based on equality and holds

A dictionary hashes, or compares, based on equality and marks both key and value as

[[Garbage collection (computer science)#Strong and weak references|strong references]] to both key and value. Variants exist which hash/compare on identity (IdentityDictionary) or keep [[Garbage collection (computer science)#Strong and weak references|weak references]] (WeakKeyDictionary / WeakValueDictionary).

[[Garbage collection (computer science)#Strong and weak references|strong references]]. Variants exist in which hash/compare on identity (IdentityDictionary) or keep [[Garbage collection (computer science)#Strong and weak references|weak references]] (WeakKeyDictionary / WeakValueDictionary).

Because every object implements #hash, any object can be used as key (and of course also as value).

=== [[SNOBOL]] ===

[[SNOBOL]] is one of the first (if not the first) programming languages to use associative arrays. Associative arrays in SNOBOL are called Tables.

Associative arrays in [[SNOBOL]] are called Tables.

<syntaxhighlight lang="snobol">

Line 1,745 ⟶ 1,817:

</syntaxhighlight>

=== [[Standard ML]] ===

The SML'97 standard of the [[Standard ML]] programming language does not provide any associative containers. However, various implementations of Standard ML do provide associative containers.

The library of the popular [[Standard ML of New Jersey]] (SML/NJ) implementation provides a signature (somewhat like an "interface"), <code>ORD_MAP</code>, which defines a common interface for ordered functional (immutable) associative arrays. There are several general functors, functors—<code>BinaryMapFn</code>, <code>ListMapFn</code>, <code>RedBlackMapFn</code>, and <code>SplayMapFn</code>, that—that allow you to create the corresponding type of ordered map (the types are a [[self-balancing binary search tree]], sorted [[association list]], [[red-blackred–black tree]], and [[splay tree]], respectively) using a user-provided structure to describe the key type and comparator. The functor returns a structure thatin followsaccordance with the <code>ORD_MAP</code> interface. In addition, there are two pre-defined modules for associative arrays withthat employ integer keys: <code>IntBinaryMap</code> and <code>IntListMap</code>.

<syntaxhighlight lang="sml">

Line 1,793 ⟶ 1,865:

</syntaxhighlight>

Monomorphic hash tables are also supported, using the <code>HashTableFn</code> functor.

Another Standard ML implementation, [[Moscow ML]], also provides some associative containers. First, it provides polymorphic hash tables in the <code>Polyhash</code> structure. Also, some functional maps from the SML/NJ library above are available as <code>Binarymap</code>, <code>Splaymap</code>, and <code>Intmap</code> structures.

=== [[Tcl]] ===

There are two [[Tcl]] facilities that support associative -array semantics. An "array" is a collection of ''variables''. A '''"dict'''" is a full implementation of associative arrays.

====dict====

<syntaxhighlight lang=Tcl>

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

</syntaxhighlight>

To look up an item:

<syntaxhighlight lang=Tcl>

dict get $phonebook {John Doe}

</syntaxhighlight>

To iterate through a dict:

<syntaxhighlight lang=Tcl>

foreach {name number} $phonebook {

puts "name: $name\nnumber: $number"

}

</syntaxhighlight>

====array====

<syntaxhighlight lang=Tcl>

set {phonebook(Sally Smart)} 555-9999

Line 1,829 ⟶ 1,880:

</syntaxhighlight>

If there is a literal space character in the variable name, itthe name must be grouped using either curly brackets (no substitution performed) or double quotes (substitution is performed).

Alternatively, several array elements can be set inby a single command, by providingpresenting their mappings as a list (words containing whitespace are braced):

<syntaxhighlight lang=Tcl>

Line 1,837 ⟶ 1,888:

</syntaxhighlight>

To access one array entry and put it onto standard output:

<syntaxhighlight lang=Tcl>

Line 1,843 ⟶ 1,894:

</syntaxhighlight>

Which returns this result:

The result is here

<syntaxhighlight lang=Text>

Line 1,861 ⟶ 1,912:

</syntaxhighlight>

=== [[Visual Basic]] =dict====

<syntaxhighlight lang=Tcl>

There is no standard implementation common to all dialects. Visual Basic can use the Dictionary class from the [[Windows Scripting Host|Microsoft Scripting Runtime]] (which is shipped with Visual Basic 6):

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

</syntaxhighlight>

To look up an item:

<syntaxhighlight lang=Tcl>

dict get $phonebook {John Doe}

</syntaxhighlight>

To iterate through a dict:

<syntaxhighlight lang=Tcl>

foreach {name number} $phonebook {

puts "name: $name\nnumber: $number"

}

</syntaxhighlight>

=== Visual Basic ===

[[Visual Basic]] can use the Dictionary class from the [[Windows Scripting Host|Microsoft Scripting Runtime]] (which is shipped with Visual Basic 6). There is no standard implementation common to all versions:

<syntaxhighlight lang=VB"vbnet">

' Requires a reference to SCRRUN.DLL in Project Properties

Dim phoneBook As New Dictionary

Line 1,875 ⟶ 1,945:

</syntaxhighlight>

=== [[Visual Basic .NET]] ===

[[Visual Basic .NET]] uses the collection classes provided by the [[.NET Framework]].

====Creation====

The following code demonstrates the creation and population of a dictionary (see [[#C#|the C# example on this page]] for additional information):

The following code demonstrates the creation and population of a dictionary. See [[#C#|the C# example on this page]] for additional information.

<syntaxhighlight lang=VBNet>

Dim dic As New System.Collections.Generic.Dictionary(Of String, String)

Line 1,888 ⟶ 1,958:

</syntaxhighlight>

An alternativealternate syntax would be to use a ''collection initializer'', which compiles down to individual calls to <code>Add</code>.:

<syntaxhighlight lang=VBNet>

Dim dic As New System.Collections.Dictionary(Of String, String) From {

Line 1,898 ⟶ 1,969:

====Access by key====

Example demonstrating access (see [[#C# access|C# access]]):

Example demonstrating access; see [[#C# access|this section of the C# example]] for explanation:

<syntaxhighlight lang=VBNet>

Dim sallyNumber = dic("Sally Smart")

Line 1,911 ⟶ 1,982:

====Enumeration====

Example demonstrating enumeration (see [[#C# enumeration]]):

Example demonstrating enumeration; see [[#C# enumeration|this section of the C# example]] for explanation:

<syntaxhighlight lang=VBNet>

' loop through the collection and display each entry.

Line 1,920 ⟶ 1,991:

</syntaxhighlight>

=== [[Windows PowerShell]] ===

Unlike many other [[command line interpreter]]s, [[Windows PowerShell]] has built-in, language-level support for defining associative arrays.:

For example:

<syntaxhighlight lang=PowerShell>

Line 1,933 ⟶ 2,002:

</syntaxhighlight>

LikeAs in JavaScript, if the property name is a valid identifier, the quotes can be omitted, e.g.:

<syntaxhighlight lang=PowerShell>

Line 1,939 ⟶ 2,008:

</syntaxhighlight>

Entries can be separated by either a semicolon or a newline, e.g.:

<syntaxhighlight lang=PowerShell>

Line 1,948 ⟶ 2,017:

</syntaxhighlight>

Keys and values can be any [[.NET Framework|.NET]] object type, e.g.:

<syntaxhighlight lang=PowerShell>

Line 1,959 ⟶ 2,028:

</syntaxhighlight>

It is also possible to create an empty associative array and add single entries, or even other associative arrays, to it later on.:

<syntaxhighlight lang=PowerShell>

Line 1,967 ⟶ 2,036:

</syntaxhighlight>

New entries can also be added by using the array index operator, the property operator, or the <code>Add()</code> method of the underlying .NET object:

<syntaxhighlight lang=PowerShell>

Line 1,976 ⟶ 2,045:

</syntaxhighlight>

To dereference assigned objects, the array index operator, the property operator, or the parameterized property <code>Item()</code> of the .NET object can be used:

<syntaxhighlight lang=PowerShell>

Line 1,996 ⟶ 2,065:

</syntaxhighlight>

Hash tables can be added, e.g.:

<syntaxhighlight lang=PowerShell>

Line 2,009 ⟶ 2,078:

Many data serialization formats also support associative arrays (see [[Comparison of data serialization formats#Syntax comparison of human-readable formats|this table]])

=== [[JSON]] ===

In [[JSON]], associative arrays are also referred to as objects. Keys can only be strings.

<syntaxhighlight lang=JavaScript>

{

Line 2,019 ⟶ 2,089:

</syntaxhighlight>

=== [[YAML]]TOML ===

[[TOML]] is designed to map directly to a hash map. TOML refers to associative arrays as tables. Tables within TOML can be expressed in either an "unfolded" or an inline approach. Keys can only be strings.<syntaxhighlight lang="toml">[phonebook]

"Sally Smart" = "555-9999"

"John Doe" = "555-1212"

"J. Random Hacker" = "555-1337"</syntaxhighlight><syntaxhighlight lang="toml">

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

</syntaxhighlight>

===YAML===

YAML associative arrays are also called map elements or key-value pairs. YAML places no restrictions on the type of keys; in particular, they are not restricted to being scalar or string values.

[[YAML]] associative arrays are also called map elements or key-value pairs. YAML places no restrictions on the types of keys; in particular, they are not restricted to being scalar or string values.

<syntaxhighlight lang=YAML>