Comparison of programming languages (associative array)

This comparison of programming languages (associative arrays) compares the features of associative array data structures or array-lookup processing for over 40 computer programming languages.

Language support
The following is a comparison of associative arrays (also "mapping", "hash", and "dictionary") in various programming languages.

AWK
AWK has built-in, language-level support for associative arrays.

For example:

The following code loops through an associated array and prints its contents:

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 AWK using concatenation and the built-in string-separator variable SUBSEP:

C
There is no standard implementation of associative arrays in C, but a 3rd-party library, C Hash Table, with BSD license, is available.

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.

Finally, the GLib library also supports associative arrays, along with many other advanced data types and is the recommended implementation of the GNU Project.

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

C#
C# uses the collection classes provided by the .NET Framework. The most commonly used associative array type is, which is implemented as a mutable hash table. The relatively new   package, available in .NET Framework versions 4.5 and above, and in all versions of .NET Core, also includes the   type, which is implemented using an AVL tree. The methods that would normally mutate the object in-place instead return a new object that represents the state of the original object after mutation.

Creation
The following demonstrates three means of populating a mutable dictionary:
 * the  method, which adds a key and value and throws an exception if the key already exists in the dictionary;
 * assigning to the indexer, which overwrites any existing value, if present; and
 * assigning to the backing property of the indexer, for which the indexer is syntactic sugar (not applicable to C#, see F# or VB.NET examples).

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

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

In this example, the  value will now contain the string.

Enumeration
A dictionary can be viewed as a sequence of keys, sequence of values, or sequence of pairs of keys and values represented by instances of the  type, although there is no guarantee of order. For a sorted dictionary, the programmer could choose to use a  or use the   LINQ extension method when enumerating.

The following demonstrates enumeration using a foreach loop:

C++
C++ has a form of associative array called  (see Standard Template Library). One could create a phone-book map with the following code in C++:

Or less efficiently, as this creates temporary  values:

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

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

The same task in C++11:

Using the structured binding available in C++17:

In C++, the  class is templated which allows the data types of keys and values to be different for different   instances. For a given instance of the  class the keys must be of the same base type. The same must be true for all of the values. Although  is typically implemented using a self-balancing binary search tree, C++11 defines a second map called , 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, available from such implementations as SGI and STLPort.

Cobra
Initializing an empty dictionary and adding items in Cobra:

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

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

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

D
D offers direct support for associative arrays in the core language; such arrays are implemented as a chaining hash table with binary trees. The equivalent example would be:

Keys and values can be any types, but all the keys in an associative array must be of the same type, and the same goes for dependent values.

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

A property can be removed as follows:

Delphi
Delphi supports several standard containers, including TDictionary:

Pre-2009 Delphi versions do not support associative arrays directly. Such arrays can be simulated using the TStrings class:

Erlang
Erlang offers many ways to represent mappings; three of the most common in the standard library are keylists, dictionaries, and maps.

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  module.

Accessing an element of the keylist can be done with the  function:

Dictionaries
Dictionaries are implemented in the  module of the standard library. A new dictionary is created using the  function and new key/value pairs are stored using the   function:

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

The dictionary can be accessed using the  function:

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

Maps
Maps were introduced in OTP 17.0, and combine the strengths of keylists and dictionaries. A map is defined using the syntax :

Basic functions to interact with maps are available from the  module. For example, the  function returns the value associated with a key:

Unlike dictionaries, maps can be pattern matched upon:

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

Map<'Key,'Value>
At runtime, F# provides the  type, which is an immutable AVL tree.

Creation
The following example calls the  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).

Access by key
Values can be looked up via one of the  members, such as its indexer or   property (which throw an exception if the key does not exist) or the   function, which returns an option type with a value of , for a successful lookup, or  , 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.

In both examples above, the  value would contain the string.

Dictionary<'TKey,'TValue>
Because F# is a .NET language, it also has access to features of the .NET Framework, including the System.Collections.Generic.Dictionary<'TKey,'TValue> 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  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.

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

Access by key
instances have an indexer that is used in the same way as, although the equivalent to   is  , which has an output parameter for the sought value and a Boolean return value indicating whether the key was found.

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:

Enumeration
A dictionary or map can be enumerated using.

FoxPro
Visual FoxPro implements mapping with the Collection Class.

GetKey returns 0 if the key is not found.

Go
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:

Adding elements one at a time:

A map literal:

Iterating through a map:

Haskell
The Haskell programming language provides only one kind of associative container – a list of pairs:

output: Just "555-1212"

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), the most commonly used implementation of Haskell, provides two more types of associative containers. Other implementations may also provide these.

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

output: Just "555-1212"

A specialized version for integer keys also exists as Data.IntMap.

Finally, a polymorphic hash table:

output: 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 IO monad.

Java
In Java associative arrays are implemented as "maps", which are part of the Java collections framework. Since J2SE 5.0 and the introduction of generics into Java, collections can have a type specified; for example, an associative array that maps strings to strings might be specified as follows:

The method is used to access a key; for example, the value of the expression   is. This code uses a hash map to store the associative array, by calling the constructor of the class. However, since the code only uses methods common to the interface, a self-balancing binary tree could be used by calling the constructor of the class (which implements the subinterface ), without changing the definition of the   variable, or the rest of the code, or using other underlying data structures that implement the   interface.

The hash function in Java, used by HashMap and HashSet, is provided by the method. Since every class in Java inherits from, every object has a hash function. A class can override the default implementation of  to provide a custom hash function more in accordance with the properties of the object.

The  class also contains the  method, which tests an object for equality with another object. Hashed data structures in Java rely on objects maintaining the following contract between their  and   methods:

For two objects a and b,

In order to maintain this contract, a class that overrides  must also override , and vice versa, so that   is based on the same properties (or a subset of the properties) as.

A further contract that a hashed data structure has with the object is that the results of the  and   methods will not change once the object has been inserted into the map. For this reason, it is generally a good practice to base the hash function on immutable properties of the object.

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 interface; or a custom  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 object-oriented language.

Map and WeakMap
Modern JavaScript handles associative arrays, using the  and   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
A map can be initialized with all items during construction:

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

Access by key
Accessing an element of the map can be done with the  method:

In this example, the value  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:

A key can be removed as follows:

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 literal is written as. For example:

To prevent the lookup from using the prototype's properties, you can use the  function:

As of ECMAScript 5 (ES5), the prototype can also be bypassed by using :

If the property name is a valid identifier, the quotes can be omitted, e.g.:

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

You can also loop through all enumerable properties and associated values as follows (a for-in loop):

Or (a for-of loop):

A property can be removed as follows:

As mentioned before, properties are strings and symbols. Since every native object and primitive can be implicitly converted to a string, you can do:

In modern JavaScript it's considered bad form to use the Array type as an associative array. Consensus is that the Object type and /  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 brought to the fore by the popularity of JavaScript frameworks that make heavy and sometimes indiscriminate use of prototypes to extend JavaScript's inbuilt types.

See JavaScript Array And Object Prototype Awareness Day for more information on the issue.

Julia
In Julia, the following operations manage associative arrays.

Declare dictionary:

Access element:

phonebook["Sally Smart"]

Add element:

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

Delete element:

delete!(phonebook, "Sally Smart")

Get keys and values as iterables:

keys(phonebook) values(phonebook)

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

Definition:

Dereference:

Lisp
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").

The syntax  is used to indicate a  ed pair. Keys and values need not be the same type within an alist. Lisp and Scheme provide operators such as  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  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.

This function can be construed as an accommodation for  operations.

Of course, the destructive  operation also allows inserting entries into an association list, an entry having to constitute a key-value cons in order to retain the mapping's validity.

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

Two generalizations of  exist:   expects a predicate function that tests each entry's key, returning the first entry for which the predicate produces a non-  value upon invocation. inverts the logic, accepting the same arguments, but returning the first entry generating.

The inverse process, the detection of an entry by its value, utilizes.

The corresponding generalizations  and   exist.

All of the previous entry search functions can be replaced by general list-centric variants, such as,  ,  , as well as pertinent functions like   and its derivates.

Deletion, lacking a specific counterpart, is based upon the list facilities, including destructive ones.

Iteration is accomplished with the aid of any function that expects a list.

These being structured lists, processing and transformation operations can be applied without constraints.

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 they are implemented in SRFI 69. Hash tables have greater overhead than alists, but provide much faster access when there are many elements. A further characteristic is 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  function, whose arguments encompass, among other configurations, a predicate to test the entry key. While tolerating arbitrary objects, even heterogeneity within a single hash table instance, the specification of this key  function is confined to distinguishable entities: the Common Lisp standard only mandates the support of ,  ,  , and  , yet designating additional or custom operations as permissive for concrete implementations.

The  function permits obtaining the value associated with a key.

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

An invocation of  actually returns two values: the value or substitute value for the key and a boolean indicator, returning   if the hash table contains the key and   to signal its absence.

Use  for deleting the entry associated with a key.

completely empties the hash table.

The dedicated  function specializes in iterating hash tables.

Alternatively, the  construct makes provisions for iterations, through keys, values, or conjunctions of both.

A further option invokes, an iterator-creating macro, the processing of which is intended to be driven by the caller.

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

LPC
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. Procedural code looks like:

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.

Deletion is accomplished using a function called either m_delete or map_delete, depending on the driver:

LPC drivers of the Amylaar family implement multivalued mappings using a secondary, numeric index (other drivers of the MudOS family do not support multivalued mappings.) Example syntax:

LPC drivers modern enough to support a foreach construct use it to iterate through their mapping types.

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

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

A table literal is written as. For example:

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

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

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

An entry can be removed by setting it to nil:

Likewise, you can overwrite values or add them:

Mathematica and Wolfram Language
Mathematica and Wolfram Language use the Association expression to represent associative arrays.

To access:

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

To list keys: and values

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 to multiple jobs. The name for globals is preceded by the circumflex "^" to distinguish them from local variables.

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

Accessing the value of an element simply requires using the name with the subscript:

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

You can also loop through an associated array as follows:

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

Objective-C (Cocoa/GNUstep)
Cocoa and GNUstep, written in Objective-C, handle associative arrays using  (a mutable version of  ) class cluster. This class allows assignments between any two objects. A copy of the key object is made before it is inserted into, therefore the keys must conform to the   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 (either explicitly or by adding to the dictionary a different object with the same key).

To access assigned objects, this command may be used:

All keys or values can be enumerated using :

In Mac OS X 10.5+ and iPhone OS, dictionary keys can be enumerated more concisely using the  construct:

What is even more practical, structured data graphs may be easily created using Cocoa, especially. This can be illustrated with this compact example:

Relevant fields can be quickly accessed using key paths:

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

The second is a polymorphic hash table:

The code above uses OCaml's default hash function, which is defined automatically for all types. To use a modified hash function, use the functor interface  to create a module, such as with.

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

Note that in order to use, you have to provide the functor   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, which is given a comparison function upon creation.

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

OptimJ
The OptimJ programming language is an extension of Java 5. As does Java, Optimj provides maps; but OptimJ also provides true associative arrays. Java arrays are indexed with non-negative integers; associative arrays are indexed with any type of key.

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

Perl 5
Perl 5 has built-in, language-level support for associative arrays. Modern Perl 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 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  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  token, which is semantically mostly identical to the comma and makes the key-value association clearer:

Accessing a hash element uses the syntax  – the key is surrounded by curly braces and the hash name is prefixed by a , indicating that the hash element itself is a scalar value, even though it is part of a hash. The value of  is. The  sigil is only used when referring to the hash as a whole, such as when asking for.

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

One can iterate through (key, value) pairs using the  function:

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:

Values in a hash reference are accessed using the dereferencing operator:

When the hash contained in the hash reference needs to be referred to as a whole, as with the  function, the syntax is as follows:

Perl 6 (Raku)
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" role. As in 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  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  token, which makes the key-value association clearer:

Accessing a hash element uses the syntax  – 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  is.

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

By default, when iterating through a hash, one gets key–value pairs.

It is also possible to get alternating key values and value values by using the  method:

Raku doesn't have any references. Hashes can be passed as single parameters that are not flattened. If you want to make sure that a subroutine only accepts hashes, use the % sigil in the Signature.

In compliance with gradual typing, hashes may be subjected to type constraints, confining a set of valid keys to a certain type.

PHP
PHP's built-in array type is, in reality, an associative array. Even when using numerical indexes, PHP internally stores arrays as associative arrays. So, PHP can have non-consecutively numerically indexed arrays. The keys have to be of integer (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:

PHP can loop through an associative array as follows:

PHP has an extensive set of functions to operate on arrays.

Associative arrays that can use objects as keys, instead of strings and integers, can be implemented with the  class from the Standard PHP Library (SPL).

Pike
Pike has built-in support for associative arrays, which are referred to as mappings. Mappings are created as follows:

Accessing and testing for presence in mappings is done using the indexing operator. So  would return the string , and   would return 0.

Iterating through a mapping can be done using :

Or using an iterator object:

Elements of a mapping can be removed using, which returns the value of the removed index:

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

Dictionaries can be accessed directly, using, or implicitly, by placing the dictionary on the dictionary stack using  :

Dictionary contents can be iterated through using, though not in any particular order:

Which may output:

Dictionaries can be augmented (up to their defined size only in Level 1) or altered using, and entries can be removed using  :

Prolog
Some versions of Prolog include dictionary ("dict") utilities.

Python
In Python, associative arrays are called "dictionaries". Dictionary literals are delimited by curly braces:

Dictionary items can be accessed using the array indexing operator:

Loop iterating through all the keys of the dictionary:

Iterating through (key, value) tuples:

Dictionary keys can be individually deleted using the  statement. The corresponding value can be returned before the key-value pair is deleted using the "pop" method of "dict" type:

Python 2.7 and 3.x also support dict comprehensions (similar to list comprehensions), a compact syntax for generating a dictionary from any iterator:

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:

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

Red
In Red the built-in datatype provides an associative array that maps values of word, string, and scalar key types to values of any type. A hash table is used internally for lookup.

A map can be written as a literal, such as, or can be created using  :

refinement for  and.


 * It is of course possible to use  values as keys, in which case it is generally preferred to use   values when creating the map, but any word type can be used for lookup or creation.

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


 * Notice that the block is not reduced or evaluated in any way, therefore in the above example the key  is associated with the     rather than the   value false; literal syntax can be used if the latter is desired:

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


 * or keys can be added after creation:

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


 * Lookup can be written using  notation or using the   action:

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


 * You can also loop through all keys and values with :

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


 * A key can be removed using :

remove/key my-map "Sally Smart"

REXX
In REXX, associative arrays are called "stem variables" or "Compound variables".

Stem variables with numeric keys typically start at 1 and go up from there. The 0-key stem variable by convention contains the total number of items in the stem:

REXX has no easy way of automatically accessing the keys of a stem variable; and typically the keys are stored in a separate associative array, with numeric keys.

Ruby
In Ruby a hash table is used as follows:

Ruby supports hash looping and iteration with the following syntax:

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
The Rust standard library provides a hash map and a B-tree map. They share several methods with the same names, but have different requirements for the types of keys that can be inserted. The  requires keys to implement the   (equivalence relation) and   (hashability) traits and it stores entries in an unspecified order, and the   requires the   (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.

The default iterators visit all entries as tuples. The  iterators visit entries in an unspecified order and the   iterator visits entries in the order defined by the key type.

There is also an iterator for keys:

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

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

To print a sorted-list, it is better to take advantage of S-lang's strong support for standard arrays:

Scala
Scala provides an immutable  class as part of the   framework:

Scala's type inference will decide that this is a. To access the array:

This returns an  type, Scala's equivalent of the Maybe monad in Haskell.

Smalltalk
In Smalltalk a  is used:

To access an entry the message  is sent to the dictionary object:

Which gives:

A dictionary hashes, or compares, based on equality and marks both key and value as strong references. Variants exist in which hash/compare on identity (IdentityDictionary) or keep 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.

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"),, which defines a common interface for ordered functional (immutable) associative arrays. There are several general functors—, ,  , and  —that allow you to create the corresponding type of ordered map (the types are a self-balancing binary search tree, sorted association list, red–black tree, and splay tree, respectively) using a user-provided structure to describe the key type and comparator. The functor returns a structure in accordance with the  interface. In addition, there are two pre-defined modules for associative arrays that employ integer keys:  and.

SML/NJ also provides a polymorphic hash table:

Monomorphic hash tables are also supported, using the  functor.

Another Standard ML implementation, Moscow ML, also provides some associative containers. First, it provides polymorphic hash tables in the  structure. Also, some functional maps from the SML/NJ library above are available as,  , and   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.

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

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

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

Which returns this result:

To retrieve the entire array as a dictionary:

The result can be (order of keys is unspecified, not because the dictionary is unordered, but because the array is):

dict
To look up an item:

To iterate through a dict:

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

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 the C# example on this page for additional information):

An alternate syntax would be to use a collection initializer, which compiles down to individual calls to :

Access by key
Example demonstrating access (see C# access):

Enumeration
Example demonstrating enumeration (see ):

Windows PowerShell
Unlike many other command line interpreters, Windows PowerShell has built-in, language-level support for defining associative arrays:

As in JavaScript, if the property name is a valid identifier, the quotes can be omitted:

Entries can be separated by either a semicolon or a newline:

Keys and values can be any .NET object type:

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

New entries can also be added by using the array index operator, the property operator, or the  method of the underlying .NET object:

To dereference assigned objects, the array index operator, the property operator, or the parameterized property  of the .NET object can be used:

You can loop through an associative array as follows:

An entry can be removed using the  method of the underlying .NET object:

Hash tables can be added:

Data serialization formats support
Many data serialization formats also support associative arrays (see this table)

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

YAML
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.