Associative array/Creation: Difference between revisions

;Task:

The goal is to create an [[associative array]] (also known as a dictionary, map, or hash).

 

=={{header|11l}}==

 

=={{header|8th}}==

8th has 'maps' as built-in data types, and can use JSON to describe them:

{ "one" : 1, "two" : "bad" }

Alternatively, they can be created in code:

m:new "one" 1 m:! "two" "bad" m:!

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */

/* program hashmap64.s */

.include "../includeARM64.inc"

 

 

=={{header|ActionScript}}==

Because ActionScript does not have associative arrays in the normal sense, Object objects are used instead and keys are simply properties on those objects.

trace(map['key1']); // outputs "value1"

 

// More keys and values can then be added

map['key3'] = "value3";

''Note: The Object only supports String keys. To use an object as a key, try the flash.utils.Dictionary class.''

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2007}}

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

with Ada.Text_IO;

Value := Color_Map.Element(To_Unbounded_String("Yellow"));

Ada.Text_IO.Put_Line("Yellow:" & Integer'Image(Value));

 

=={{header|Aikido}}==

Aikido provides a native <em>map</em> for associative arrays. You can create them using a map literal and you can insert and remove items on the fly.

var names = {} // empty map

names["foo"] = "bar"

 

 

 

=={{header|Aime}}==

Aime records are heterogenous associative arrays. No creation procedure is required, declaration is fine.

r_put(r, "C", 2.5); # a real value

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

 

MODE COLOR = BITS;

printf(($g$,"values: ", comma sep, value OF color map items, $l$))

 

{{out}}

<pre>

 

Creating a new empty map of String to String:

Map<String, String> strMap = new Map<String, String>();

strMap.put('a', 'aval');

System.assertEquals( 'bval', strMap.get('b') );

// String keys are case-sensitive

 

Creating a new map of String to String with values initialized:

'a' => 'aval',

'b' => 'bval'

 

System.assert( strMap.containsKey('a') );

 

=={{header|APL}}==

{{works with|Dyalog APL}}

X←⎕NS ⍬

sales.revenue

4109.6

 

{{works with|GNU APL}}

⍝ Assign some names

X.this←'that'

sales.revenue

4109.6

 

=={{header|App Inventor}}==

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI or android 32 bits */

/* program hashmap.s */

.include "../affichage.inc"

 

=={{header|Arturo}}==

 

d: #[

name: "john"

]

 

 

{{out}}

 

<pre>[name:john surname:doe age:34]</pre>

 

=={{header|AutoHotkey}}==

=== True arrays ===

[[AutoHotkey_L]] has [http://ahkscript.org/docs/Objects.htm Objects] which function as associative arrays.

MsgBox % associative_array.key1

=== Legacy versions ===

[[AutoHotkey_Basic]] does not have typical arrays.

However, variable names can be concatenated, simulating associative arrays.

arrayX2 = second

arrayX3 = foo

arrayX4 = bar

Loop, 4

 

=={{header|AutoIt}}==

See '''[https://msdn.microsoft.com/en-us/library/x4k5wbx4.aspx here]''' in the MSDN the reference for the Dictionary object that can be used in VBA. The following example shows how to create a dictionary, add/remove keys, change a key or a value, and check the existence of a key.

; All the required functions are below the examples.

 

 

;; End AA Functions.

 

=={{header|AWK}}==

Arrays in AWK are indeed associative arrays.

a["red"] = 0xff0000

a["green"] = 0x00ff00

print ( "red" in a ) # print 0

print ( "blue" in a ) # print 1

 

=={{header|Babel}}==

 

(("foo" 13)

("bar" 42)

 

 

associative("abc") = "first three"

associative("xyz") = "last three"

 

 

{{out}}

String keys, with ASSOC to a given data type. Sizing is dynamic.

 

dim values$[1]

dim keys$[1]

next n

return ""

{{out}}

<pre>a apple

e endive

c carrot</pre>

 

=={{header|Batch File}}==

This is cheating, I'm sure of it.

 

@echo off

setlocal ENABLEDELAYEDEXPANSION

echo %1 = %2

goto :eof

 

{{out}}

"sicko&mumps" = 7

"sicko&bromodrosis" = 8</pre>

 

=={{header|Bracmat}}==

The hash is the only built-in Bracmat class. It is best used for e.g. a large dictionary, when manipulation of a very long list of key/value pairs with pattern matching would become too CPU-intensive. The same key can be stored with different values, as the example shows. If that is not desirable, the key (and its value) should be removed first.

& (myhash..insert)$(title."Some title")

& (myhash..insert)$(formula.a+b+x^7)

& (myhash..remove)$formula

& (myhash..insert)$(formula.x^2+y^2)

{{out}}

<pre>(fruit.melons bananas) (fruit.apples oranges kiwis)

 

=={{header|Brat}}==

 

h[:a] = 1 #Assign value

h2 = [a: 1, b: [1 2 3], 10 : "ten"] #Initialized hash

 

 

=={{header|C}}==

=={{header|C sharp|C#}}==

'''Platform:''' [[.NET]] 1.x

 

'''Platform:''' [[.NET]] 2.0

 

{{works with|C sharp|C#|3.0+}}

 

=={{header|C++}}==

The C++ standard defines std::map as a means of creating an association between a key of one arbitrary type and a value of another arbitrary type. This requires the inclusion of the standard header '''map'''.

 

 

===Creation===

To create a simple map whose key is of type A and whose value is of type B, one would define the variable like so:

 

If one wanted to us a key type of '''int''' and a value of '''double''', you would define it like so:

 

 

===Insertion===

====Operator[]====

The first method is using the [] operator.

 

Of course, you can use a variable (or any [[rvalue]] of the correct type) for the key or value parameters:

double myValue = 3.14;

====insert()====

The second approach is a little more complicated. We have to use the '''pair<>''' template:

or by using '''make_pair''' to avoid repeating key/value types:

 

===Lookup===

====operator[]====

We use it as an rvalue, supplying the correct key:

If the value doesn't already exist, a default-constructed object of the value's type will be inserted using the key you specified, and that default value will be returned.

 

====find()====

Alternatively, you can look up a value by using find(), storing its return value in an [[iterator]], and comparing the iterator against the map's end() [[sentinal value]]:

std::map<int, double>::iterator myIterator = exampleMap.find(myKey);

if(exampleMap.end() != myIterator)

// Return the value for that key.

myValue = myIterator->second;

 

The need for the '''->second''' code is because our iterator points to a '''pair<>()''', and our value is the second member of that pair.

===Example===

This simple program creates a map, assigns a value to that map, retrieves a value from that map, and prints the value to STDOUT.

#include <iostreams>

 

// main() must return 0 on success.

return 0;

 

=={{header|Ceylon}}==

 

ArrayList,

}

 

=={{header|Chapel}}==

The creation of the domain is independent from the creation of the array, and in fact the same domain can be used for multiple arrays, creating associative arrays with identical sets of keys. When the domain is changed, all arrays that use it will be reallocated.

 

var keys: domain(string);

var arr: [keys] int;

 

writeln("arr2 keys: ", arr2.domain);

 

{{out}}

 

=={{header|Clojure}}==

:key2 "value2"

 

=={{header|ColdFusion}}==

<cfset myHash.key1 = "foo">

<cfset myHash["key2"] = "bar">

 

In ColdFusion, a map is literally a java.util.HashMap, thus the above 3rd method is possible.

 

=={{header|Common Lisp}}==

;; or for implementation identity for other types!

;; Use #'equalp if you want case-insensitive keying on strings.

;; alist is written like this:

(defparameter *legs* '((cow . 4) (flamingo . 2) (centipede . 100)))

 

=={{header|Component Pascal}}==

BlackBox Componente Builder<br/>

Using a handmade collections module with the following interface<br/>

DEFINITION Collections;

 

 

END Collections.

The program:

MODULE BbtAssociativeArrays;

IMPORT StdLog, Collections, Boxes;

 

END BbtAssociativeArrays.

Execute:^Q BbtAssociativeArrays.Do<br/>

{{out}}

 

=={{header|Crystal}}==

 

# hash literals that don't perfectly match the intended hash type must be given an explicit type specification

# the following would fail without `of String => String|Int32`

 

=={{header|D}}==

auto hash = ["foo":42, "bar":100];

assert("foo" in hash);

 

=={{header|Dao}}==

h = { -> } # empty hash map, future inserted keys will not be ordered

 

m = { 'foo' => 42, 'bar' => 100 } # with ordered keys

 

=={{header|Dart}}==

main() {

var rosettaCode = { // Type is inferred to be Map<String, String>

}

 

{{out}}

<pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lDictionary.Free;

end;

 

=={{header|Dyalect}}==

Dyalect has a <code>Tuple</code> data type which allows to add labels to values:

 

 

{{out}}

 

 

=={{header|E}}==

["one" => 1, "two" => 2] # immutable, 2 mappings

[].asMap().diverge() # mutable, empty

["one" => 2].diverge(String, float64) # mutable, initial contents,

 

=={{header|EchoLisp}}==

(lib 'hash) ;; needs hash.lib

(define H (make-hash)) ;; new hash table

(hash-count H)

→ 3

 

=={{header|Elena}}==

ELENA 5.0:

public program()

map["key3"]:= "foo3";

map["key4"]:= "foo4";

 

=== Strong typed dictionary ===

 

public program()

map["key3"]:= "foo3";

map["key4"]:= "foo4";

 

=={{header|Elixir}}==

{{trans|Erlang}}

def test_create do

IO.puts "< create Map.new >"

end

 

 

{{out}}

 

=={{header|Emacs Lisp}}==

 

<code>make-hash-table</code> compares keys with <code>eql</code> by default. This suits symbols and numbers (including floating point). For string keys an <code>equal</code> test can be used,

 

 

<code>define-hash-table-test</code> can create other key comparison types.

 

=={{header|Erlang}}==

Erlang offers several associative array type data structures, this example uses the dictionary data structure.

-module(assoc).

-compile([export_all]).

io:format("~p: ~b~n",[K,dict:fetch(K,D)])

end, dict:fetch_keys(D)).

 

{{out}}

=={{header|F Sharp|F#}}==

.NET 3.5 Generic Dictionary (mutable)

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

dic.Add("key","val") ;

dic.["key"] <- "new val" ;

Functional dictionary (immutable)

let d = [("key","val");("other key","other val")] |> Map.ofList

let newd = d.Add("new key","new val")

| Some(v) -> printfn "%s" v

| None -> printfn "not found"

 

=={{header|Factor}}==

Associative mappings follow the associative protocol. See [http://docs.factorcode.org/content/article-assocs-protocol.html the docs].

Here's an example using a hashtable that can be run in the listener :

{ [ "one" swap at . ]

[ 2 swap value-at . ]

[ "three" swap at . ]

[ [ 3 "three" ] dip set-at ]

 

=={{header|Fantom}}==

Associative arrays are called 'maps' in Fantom:

 

class Main

{

}

}

 

=={{header|Forth}}==

The Forth dictionary is normally only used for function and symbol definitions, but you can also define separate ''wordlists'' for holding functions or data. There is no special syntax in the language for this, but you can define your own. All of Forth's defining words are available for adding things to the wordlist, but CREATE is most generic.

 

search-wordlist if

>body @

s" alpha" bar get . \ 5

8 s" Alpha" bar put \ Forth dictionaries are normally case-insensitive

This is not necessarily a good option in all Forths, as the dictionary may be implemented as a simple linked list (normally not a problem because the dictionary is only used for compiling and interactive interpretation). [[GNU Forth]] and many other hosted Forths use hash tables for the dictionary, so this is a fine choice. If you need case-sensitive keys, GNU Forth has <tt>table</tt> and <tt>table-find</tt>, replacing <tt>wordlist</tt> and <tt>search-wordlist</tt>, respectively.

 

 

Hashtable for mapping strings to integer

 

\ Create a hash table 'table' in the dictionary with a starting size of 10

[ELSE]

.( Entry not present.) cr

 

=={{header|FreeBASIC}}==

Uses unions to store the keys and associated values, and FreeBASIC's ability to resize arrays makes adding new entries easy.

 

enum datatype

 

print Dictionary(0).value.value.strng

{{out}}

<pre>

=={{header|Free Pascal}}==

FPC 3.2.0.+. Similar to Delphi.

{$IFDEF FPC}{$MODE DELPHI}{$ENDIF}

{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}

lDictionary.Free;

end;

FPC 2.4+. Using FGL instead of rtl-generics:

{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}

{$MODE DELPHI}

lDictionary.Free;

end;

 

=={{header|Futhark}}==

 

=={{header|Gambas}}==

=={{header|Go}}==

Allowable key types are those with == and != operators. This includes is boolean, numeric, string, pointer, channel, and interface types. It also includes structs and arrays containing only these types. Disallowed as map keys are all slice, function, and map types.

var x map[string]int

 

x = map[string]int{

"foo": 2, "bar": 42, "baz": -1,

 

=={{header|Gosu}}==

As an OOP language with generics Gosu can use any variety of Map classes. In addition Gosu provides associative array syntax for all objects.

var emptyMap = new HashMap<String, Integer>()

 

var scott = new Person()

scott["name"] = "Scott"

 

=={{header|Groovy}}==

Create an empty map and add values

map[7] = 7

map['foo'] = 'foovalue'

assert 'foovalue' == map.foo

assert 'barvalue' == map['bar']

 

Create a pre-populated map and verify values

 

assert 7 == map[7]

assert 'foovalue' == map.foo

assert 'barvalue' == map['bar']

 

=={{header|Harbour}}==

Create an empty array and add values:

arr[ 10 ] := "Val_10"

Create and initialize array:

// or

 

=={{header|Haskell}}==

Binary trees:

{{works with|GHC}}

 

dict = fromList [("key1","val1"), ("key2","val2")]

 

ans = Data.Map.lookup "key2" dict -- evaluates to Just "val2"

 

It is also possible to use association lists (lists of pairs). It is inefficient (O(n) lookup), but simple.

 

ans = lookup "key2" dict -- evaluates to Just "val2"

 

GHC also had an imperative hash table implementation in the <code>Data.HashTable</code> module, but was removed in <code>GHC 7.8</code>.

 

=={{header|hexiscript}}==

let d["test"] "test" # Strings can be used as index

let d[123] 123 # Integers can also be used as index

 

println d["test"]

 

=={{header|Icon}} and {{header|Unicon}}==

Icon and Unicon associative arrays are called tables. Any value may be used as a key including complex structures. Tables can have default values and they have no inherent size limitation growing from empty to whatever size is needed.

 

local t

t := table()

t["foo"] := "bar"

write(t["foo"])

 

=={{header|Inform 7}}==

 

===Static relation===

 

Connection relates various texts to one number. The verb to be connected to implies the connection relation.

let V be the number that "baz" relates to by the connection relation;

say "'baz' => [V].";

 

===Dynamic relation===

 

When play begins:

let V be the number that "baz" relates to by R;

say "'baz' => [V].";

 

=={{header|Ioke}}==

 

=={{header|J}}==

However, it's also possible to use the symbol table itself to hold the names. The symbol table has limitations (can only accept syntactically valid names), but we can turn arbitrary strings into valid symbols using base 62 encode and prefixing with a letter (hypothetically speaking, base 64 encode would let us build longer names than base 62, because of computational complexity issues - but the J symbol table also comes with a name length limit - 255 characters - and does not support 64 different characters in names):

 

encode=: 'z', (a.{~;48 65 97(+ i.)&.>10 26 26) {~ 62x #.inv 256x #. a.&i.

get=: ".@encode

has=: 0 <: nc@<@encode

 

Example use:

 

'foo' set__example 1 2 3

1 2 3

get__example 'bletch'

7 8 9

 

Note that J's symbols (http://www.jsoftware.com/help/dictionary/dsco.htm) might also be used for this purpose. However, symbols are not garbage collected within a J session (and, instead, a mechanism is provided to optionally preserve them across sessions).

 

 

 

=={{header|JavaScript}}==

 

Javascript object property names (keys) are strings. Other types and expressions can be used with square bracket notation, they are evaluated and converted to strings and the result used as the property name. Using quotes on property names avoids potential collisions with reserved JavaScript key words.

 

assoc['foo'] = 'bar';

alert('key:"' + key + '", value:"' + assoc[key] + '"');

}

 

ECMAScript 6 (ES6) offers both a map and a weak map implementation. While Objects must use strings, Maps may use objects, functions, and numbers as keys in addition to strings.

fn = function () {},

obj = {};

for (var key of map.keys()) {

console.log(key + ' => ' + map.get(key));

 

=={{header|jq}}==

===Associative Arrays with String-Valued Keys===

In jq, JSON objects can be used as associative arrays, it being understood that only strings can be used as keys. To avoid confusion, for the remainder of this section, we refer to JSON objects as such. Their type in jq is "object".

{}

 

 

# Alteration of the value of an existing key:

 

===Associative Arrays with JSON-Valued Keys===

In this subsection, we define addKey(key;value), getKey(key), and removeKey(key)

to operate on a hash table for which the keys may be any JSON entities. This is done by defining a collisionless hash function.

if type == "object" then with_entries(.value = (.value|collisionless))|tostring

elif type == "array" then map(collisionless)|tostring

def getKey(key): .[key|collisionless];

 

'''Example''':

produces:

 

=={{header|Jsish}}==

From Javascript. jsish warns of duplicate ''var'', in this case the ''assoc'' variable is reused.

assoc['foo'] = 'bar';

assoc ==> { "another-key":3, foo:"bar" }

=!EXPECTEND!=

{{out}}

<pre>prompt$ jsish -u associativeArray.jsi

{{works with|Julia|0.6}}

We build dictionaries associating to some characters their code points, by listing the key/value pairs, through a dictionary comprehension, by creating an empty dictionary and filling it, by using the specific syntax associated to typed dictionaries.

# Dict{Char,Int64} with 2 entries:

# 'b' => 98

typeof(dict) # type is infered correctly

# Dict{Char,Int64}

 

=={{header|K}}==

Keys in a dictionary must be symbols (`symbol).

d1:.((`foo;1); (`bar;2); (`baz;3))

 

/ extracting a value

d1[`bar]

Another approach.

d2[`"zero"]:0

d2[`"one"]:1

.((`zero;0;)

(`one;1;)

 

Extracting the keys and values.

`zero `one `two

 

d2[] / the values

 

=={{header|Kotlin}}==

{{trans|Java}}

// map definition:

val map = mapOf("foo" to 5,

// iterate over key, value pairs:

for ((k, v) in map) println("$k => $v")

 

=={{header|Lambdatalk}}==

Associative arrays are not currently built in the JS.js kernel of lambdatalk but are added via the lib_hash library page.

 

1) a (currently) reduced set of functions:

bar: Barcelona, Catalunya

]

 

=={{header|Lang5}}==

: first 0 extract nip ; : second 1 extract nip ;

 

'bar over at .

'hello 'bar rot set-at

 

=={{header|langur}}==

Hash keys in langur may be numbers or strings. Number keys are simplified, so that 1.0 is the same key as 1.

 

 

# may assign with existing or non-existing hash key (if hash is mutable)

# using an alternate value in case of invalid index; prevents exception

writeln .hash[1; 42]

 

{{out}}

 

=={{header|Lasso}}==

 

// Define an empty map

#1 -> reverse

}

 

=={{header|LFE}}==

(let* ((my-dict (: dict new))

(my-dict (: dict store 'key-1 '"value 1" my-dict))

(: io format '"some data: ~p~n" (list (: dict fetch 'key-1 my-dict))))

 

 

=={{header|Liberty BASIC}}==

Needs the sublist library from http://basic.wikispaces.com/SubList+Library since LB does not have built-in associative arrays.

data "red", "255 50 50", "green", "50 255 50", "blue", "50 50 255"

data "my fave", "220 120 120", "black", "0 0 0"

 

print " Key 'green' is associated with data item "; sl.Get$( myAssocList$, "green")

Key 'green' is associated with data item 50 255 50

 

=={{header|Lingo}}==

 

put props[#key2]

-- "value2"

put props.getProp(#key2)

 

=={{header|LiveCode}}==

Livecode arrays are only associative, but can be accessed by ordinal if they are used as the key.

local tArray

put "value 1" into tArray["key 1"]

"length of item 3:" && the length of tArray["abc"] & return & \

"keys:" && the keys of tArray

Output

length of item 3: 5

keys: key numbers

abc

 

=={{header|Logo}}==

[[UCB Logo]] has "property lists" which associate names with values. They have their own namespace.

pprop "animals "dog 4

pprop "animals "mouse 11

print gprop "animals "cat ; 5

remprop "animals "dog

 

=={{header|LOLCODE}}==

BUKKITs are associative arrays

I HAS A Hash ITZ A BUKKIT

Hash HAS A key1 ITZ "val1" BTW This works for identifier-like keys, like obj.key in JavaScript

VISIBLE Hash'Z SRS "key-2"

KTHXBYE

{{Out}}

<pre>1</pre>

=={{header|Lua}}==

Lua tables are Hashes

hash[ "key-1" ] = "val1"

hash[ "key-2" ] = 1

Returns nil on unknown key.

 

=={{header|M2000 Interpreter}}==

Μ2000 has Inventory object to use it as a Map. All keys converted to strings. If a key has no value then key is the value until we place one. A special type of Inventory is the Inventory Queue, where we can use same keys, and we can't delete except from the last append.

Inventory A="100":=1, "200":=5, 10:=500, 20:="Hello There"

Print len(A)

If Exist(A, "End") Then Print Eval(A)=5000

 

 

=={{header|Maple}}==

Maple tables are hashed arrays. A table can be constructed by using the table constructor.

T := table(["foo" = 1, sin(x) = cos(x), (2, 3) = 4])

 

 

> T["foo"];

New entries are added by assignment.

T["bar"] := 2

 

> T[ "bar" ];

Entries can be removed as follows.

T["foo"] := T["foo"]

 

> T[ "foo" ];

(The latter output indicates that T["foo"] is an unassigned name.)

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

Associative arrays are called structs. The following methods of creating hash are equivalent.

 

hash.b = 2;

alternatively

hash = setfield(hash,'a',1);

hash = setfield(hash,'b',2);

or

hash.('b') = 2;

 

<pre>>> disp(hash)

===MATLAB only: containers.Map===

Use of containers.Map removes some restrictions on key types that structs have. Keys can all be numeric or all be strings. Values can be of any type. Key and value types cannot be changed after creation of the containers.Map object.

is equivalent to

m('a') = 1;

m('b') = 2;

since the KeyType defaults to 'char'. For numeric keys, the key and value types must be specified at creation.

is equivalent to

m(51) = 'fiftyone';

m(72) = 'seventytwo';

Usage:

<pre>>> m = containers.Map([51 72 37], {'fiftyone' 'seventytwo' 'thirtyseven'});

 

=={{header|Maxima}}==

 

h[1]: 6;

 

arrayinfo(h);

 

=={{header|min}}==

{{works with|min|0.19.6}}

 

=={{header|MiniScript}}==

A map literal in MiniScript is enclosed in curly braces, with key:value pairs separated by commas. Keys and values may be any type. Retrieval or assignment is by putting the key in square brackets. As syntactic sugar, when a string key follows the rules of a MiniScript identifier (starts with a letter and contains only letters, numbers, and underscores), you may also access it with dot syntax.

 

print map[3]

print map["foo"]

print map.foo // same as map["foo"] (only for string keys that are valid identifiers)

 

=={{header|Nemerle}}==

This demonstrates two of several constructors, initializing the hashtable with a list of tuples or just specifying an initial capacity.

using System.Console;

using Nemerle.Collections;

WriteLine(hash1[entry]);

}

 

=={{header|NetRexx}}==

 

options replace format comments java crossref symbols

 

say '<hash key="'key0'" value="'hash[key0]'" />' -- Display a value for a key that wasn't set

 

{{out}}

 

=={{header|Nim}}==

 

var

echo "iterate values:" # iterating over values

for key in hash.values:

{{out}}

<pre>hash has 3 elements

=={{header|Oberon-2}}==

{{works with| oo2c Version 2}}

MODULE AssociativeArray;

IMPORT

END AssociativeArray.

 

 

=={{header|Objeck}}==

 

=== Associative map===

# create map

map := StringMap->New();

map->Find("thirteen")->As(IntHolder)->GetValue()->PrintLine();

map->Find("seven")->As(IntHolder)->GetValue()->PrintLine();

 

===Hash table===

# create map

map := StringHash->New();

map->Find("thirteen")->As(IntHolder)->GetValue()->PrintLine();

map->Find("seven")->As(IntHolder)->GetValue()->PrintLine();

 

=={{header|Objective-C}}==

 

You can use a NSDictionary to create an immutable hash. A dictionary can contain only objects; if you want store non objects like integer, you have to box it in NSNumber.

@"Joe Doe", @"name",

[NSNumber numberWithUnsignedInt:42], @"age",

[NSNull null], @"extra",

 

The same as the above with the new literal syntax in clang 3.1+ / Apple LLVM Compiler 4.0+ (XCode 4.4+) :

@"name": @"Joe Doe",

@"age": @42,

@"extra": [NSNull null],

 

To create a mutable dictionary, use NSMutableDictionary:

[dict setObject:@"Joe Doe" forKey:@"name"];

 

You can access value with objectForKey:. If a key does not exists, nil is returned.

unsigned age = [dict objectForKey:@"age"] unsignedIntValue];

 

=={{header|OCaml}}==

===Hash table===

A simple idiom to create a hash table mapping strings to integers:

List.iter (fun (key, value) -> Hashtbl.add hash key value)

To retrieve a value:

To retrieve a value, returning a default if the key is not found:

 

===Binary tree===

A simple idiom to create a persistent binary tree mapping strings to integers:

type t = string

let compare = Pervasives.compare

StringMap.empty

["foo", 5; "bar", 10; "baz", 15]

To retrieve a value:

To retrieve a value, returning a default if the key is not found:

===Association list===

Some list functions allow you to use a list as an associative map, although the access time is O(N) so a Hashtbl or binary tree should be used for larger data-sets.

 

(* retrieve value *)

 

(* see if key exists *)

 

=={{header|Ol}}==

You can use only values as keys (atomic numbers, constants) and, as exception, symbols (symbols are references, but unique). No strings, lists, vectors and other objects can be used directly. In such cases use hashes or similar mechanisms.

 

;;; empty associative array

#empty

(print my-new-map)

; ==> #((1 . 100) (2 . 200) (7 . 777) (the-key . the-value))

 

=={{header|ooRexx}}==

 

Defining the map:

map["foo"] = 5

map["bar"] = 10

map["baz"] = 15

map["foo"] = 6

"Putting" a value for a key that already exists ("map["foo"] = 6" in this example) will replace and return the old value for the key.

 

Retrieving a value:

Note that it is possible to put <code>.nil</code> as a value, so <code>.nil</code> being returned as a value is not sufficient for determining that the key is not in the collection. There is a <code>hasIndex</code> method for that.

 

Iterate over keys:

say key

end

Iterate over values:

say value

end

Iterate over key, value pairs:

s = map~supplier

loop while s~available

s~next

end

 

=={{header|OxygenBasic}}==

Not very efficient but the 'find' method could be optimised very easily.

def n 200

 

A.dat("computers")="LC99" '

print A.dat("computers") 'result LC99

 

=={{header|Oz}}==

A mutable map is called a 'dictionary' in Oz:

Dict = {Dictionary.new}

in

Dict.foo := 20

 

 

'Records' can be consideres immutable maps:

Rec = name(foo:5 bar:10 baz:20)

in

 

=={{header|PARI/GP}}==

 

GP's associative arrays are called maps, and can be created like so:

They can be used as follows:

mapput(M, 17, "different value");

mapput(M, "key2", Pi);

mapget(M, "key2") \\ returns Pi

mapisdefined(M, "key3") \\ returns 0

 

In PARI the commands are <code>gtomap</code>, <code>mapput</code>, <code>mapget</code>, <code>mapisdefined</code>, and <code>mapdelete</code>. You can also use the solutions in [[Associative arrays/Creation/C]].

===Hash===

Definition:

my %hash = (

key1 => 'val1',

'three', -238.83,

4, 'val3',

 

Use:

 

$hash{key1} = 'val1';

 

===HashRef===

Definition:

key1 => 'val1',

'key-2' => 2,

three => -238.83,

4 => 'val3',

 

Use:

 

$hashref->{key1} = 'val1';

 

 

===Key Types===

integer tid=new_dict(), and pass that as an additional (final) parameter to the other routines (taking care not to miss

any). When you have no further use for it, an entire dictionary can be removed by invoking destroy_dict(tid).

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">setd</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"one"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">deld</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">getd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- shows 0</span>

 

=={{header|Phixmonti}}==

 

def getd /# dict key -- dict data #/

PI getd tostr print nl

3 getd print

 

=={{header|PHP}}==

$array = []; // Simpler form of array initialization

$array['foo'] = 'bar';

// Check if key exists in the associative array

echo(isset($array['foo'])); // Faster, but returns false if the value of the element is set to null

 

===Iterate over key/value===

{

echo "Key: $key Value: $value";

 

=={{header|PicoLisp}}==

[http://software-lab.de/doc/refA.html#assoc association lists].

 

(put 'A 'bar 10)

(put 'A 'baz 15)

foo 20

bar 10

 

=={{header|Pike}}==

''indices()'' and ''values()'' can be used to enumerate the contents

of an existing mapping.

mapping m = ([ "apple": "fruit", 17: "seventeen" ]);

write("indices: %O\nvalues: %O\n17: %O\n",

values(m),

m[17]);

{{Out}}

<pre>

Since any data type can be used nested structures of arbitrary size can

be constructed.

mapping m2 = ([ "car": ([ "ford":17, "volvo":42 ]) ]);

write("#ford: %O, #volvo: %O\n",

m2->car->ford,

m2["car"]["volvo"]);

{{Out}}

<pre>

 

=={{header|PL/I}}==

assocarr: Proc Options(main);

Dcl 1 aa,

End;

 

{{out}}

<pre>added >1< -> spam<

 

The following example code is a "record definition", which has nothing to do with associative arrays:-

type ThisIsNotAnAssocArrayType is record (

myShape VARCHAR2(20),

dbms_output.put_line ('assocArray.mySize: ' || assocArray.mySize);

END;

 

=={{header|Pop11}}==

;;; value 0 (default value is returned when the item is absent).

vars ht = newmapping([], 50, 0, true);

printf(value, '%p\t');

printf(key, '%p\n');

 

=={{header|PostScript}}==

<</a 100 /b 200 /c 300>>

dup /a get =

 

=={{header|Potion}}==

 

redblue = "purple"

255 == mydictionary("blue")

65280 == mydictionary("green")

 

=={{header|PowerShell}}==

An empty hash table can be created with:

A hash table can be initialized with key/value pairs:

"key1" = "value 1"

key2 = 5 # if the key name has no spaces, no quotes are needed.

Individual values can be assigned or replaced by either using a property-style access method or indexing into the table with the given key:

$hashtable['bar'] = 42

$hashtable."a b" = 3.14 # keys can contain spaces, property-style access needs quotation marks, then

NB. PowerShell compares strings as case-insensitive, that means the hashtable keys 'a' and 'A' are considered the same key. This happens when @{} is turned into a hashtable, but can be overridden by an explicit long-form:

$h=@{}

$h['a'] = 1

---- -----

A 2

Similarly, values can be retrieved using either syntax:

It is common to see a hashtable literal used to create an object, by casting it to a new type:

"key1" = "value 1"

key2 = 5

This is a convenience syntax, has less code and runs faster than other ways to create objects.

 

=={{header|Prolog}}==

We use the facts table for this purpose.

mymap(key1,value1).

mymap(key2,value2).

?- mymap(key1,V).

V = value1

 

=={{header|PureBasic}}==

Hashes are a built-in type called Map in Purebasic.

 

dict("country") = "Germany"

 

=={{header|Python}}==

Hashes are a built-in type called dictionaries (or mappings) in Python.

 

hash = dict(red="FF0000", green="00FF00", blue="0000FF")

hash = { 'key1':1, 'key2':2, }

 

Numerous methods exist for the mapping type https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

 

d = {}

d['spam'] = 1

# iterating over (key, value) pairs

for key, value in d.iteritems():

 

Note: Python dictionary keys can be of any arbitrary "hashable" type. The following contains several distinct key value pairs:

 

 

(Some other languages such as ''awk'' and ''Perl'' evaluate all keys such that numerically or lexically equivalent expressions become identical entries in the hash or associative array).

=== environment example ===

 

> env[["x"]] <- 123

<pre>[1] 123</pre>

> env[[index]] <- "rainfed hay"

<pre>[1] "rainfed hay"</pre>

<pre>[1] "rainfed hay"</pre>

<pre><environment: 0xb7cd560></pre>

<pre><environment: 0xb7cd560></pre>

 

=== vector example ===

 

<pre>hello world !

1 2 3</pre>

<pre>[1] "hello" "world" "!"</pre>

<pre>[1] 1 2 3</pre>

 

=== list example ===

 

<pre>$a

[1] 1

$d

[1] "xyz"</pre>

<pre>[1] "a" "b" "c" "d"</pre>

<pre>[[1]]

[1] 1

In Racket, hash tables are natively supported and encouraged over association lists in many cases. Data structures that behave like dictionaries support a unified interface.

 

#lang racket

 

(dict-ref a-list 'a) ; => 5

(dict-ref table 'a) ; => 5

 

=={{header|Raku}}==

The fatarrow, <code>=></code>, is no longer just a quoting comma; it now constructs a <code>Pair</code> object. But you can still define a hash with an ordinary list of even length.

 

my %h2 = 'key1', 'val1', 'key-2', 2, 'three', -238.83, 4, 'val3';

 

class C {};

my %cash{C};

 

=={{header|Raven}}==

a_hash print

 

6.28 a_hash 'c' set # set key 'c'

a_hash.'c' # get key 'c' shorthand

 

Null is returned for unknown keys.

 

=={{header|Relation}}==

relation key, value

insert "foo", "bar"

select key == "fruit"

print

 

'''assert''' will show an error, if a key is used twice. However, it not stop the insertion.

 

=={{header|Retro}}==

hashTable constant table

 

 

table @" first" putn

 

=={{header|REXX}}==

===version 1===

Associative arrays are called ''stem variables'' in Rexx.

 

key0 = '0'

 

Say 'stem.key0= 'stem.key /* Display a value for a key that wasn't set */

{{out}}

<pre>stem.key0= .

 

===version 2===

/*┌────────────────────────────────────────────────────────────────────┐

│ The (below) two REXX statements aren't really necessary, but it │

yyy='RI'

say 'capital of' stateN.yyy "is" stateC.yyy

{{out}}

<pre>

 

=={{header|Ring}}==

# Project Associative array/Creation

 

see find(myarray,"two",1) + nl

see find(myarray,2,2) + nl

Output:

<pre>

=={{header|RLaB}}==

Associative arrays are called ''lists'' in RLaB.

x = <<>>; // create an empty list using strings as identifiers.

x.red = strtod("0xff0000"); // RLaB doesn't deal with hexadecimal numbers directly. Thus we

{ x.[i] = i; } // assign to the element of list ''i'' the real value equal to i.

 

 

=={{header|Ruby}}==

hash[777] # => nil

 

hash[777] # => 'unknown key'

 

hash[777] # => 'unknown key 777'

 

hash[777] # => 'key 777 was added at Sun Apr 03 13:49:57 -0700 2011'

hash[555] # => 'key 555 was added at Sun Apr 03 13:50:01 -0700 2011'

 

=={{header|Rust}}==

fn main() {

let mut olympic_medals = HashMap::new();

olympic_medals.insert("Germany", (252, 260, 270));

println!("{:?}", olympic_medals);

 

=={{header|Sather}}==

main is

-- creation of a map between strings and integers

end;

end;

 

=={{header|Scala}}==

var map = Map(1 -> 2, 3 -> 4, 5 -> 6)

map(3) // 4

map = map + (44 -> 99) // maps are immutable, so we have to assign the result of adding elements

map.isDefinedAt(33) // false

 

import scala.collection.mutable.HashMap

val hash = new HashMap[Int, Int]

hash.contains(33) // false

hash.isDefinedAt(33) // same as contains

 

hash.foreach {e => println("key "+e._1+" value "+e._2)} // e is a 2 element Tuple

// same with for syntax

 

map.filter {k => k._1 > 3} // Map(5 -> 6, 44 -> 99)

// same with for syntax

 

=={{header|Scheme}}==

 

Scheme has association lists (alists), which are inefficient, ordered maps with arbitrary keys and values.

 

 

Hash tables are provided by SRFI-69 [http://srfi.schemers.org/srfi-69/srfi-69.html]. Many Scheme implementation also provide native hash tables.

 

 

The R6RS standard specifies support for hashtables in the [http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-14.html#node_chap_13 standard libraries] document.

 

 

(import (rnrs base)

(hashtable-set! my-hash 'a 'b)

(hashtable-set! my-hash 1 'hello)

 

=={{header|Seed7}}==

Seed7 uses the type [http://seed7.sourceforge.net/manual/types.htm#hash hash] to support associative arrays.

 

 

# Define hash type

writeln("key: " <& stri <& ", value: " <& number);

end for;

 

=={{header|SenseTalk}}==

Associative arrays in SenseTalk are called property lists, or objects.

put an empty property list into emptyPlist2

 

put "!!!" after the occupation of Einstein

put Einstein

{{out}}

<pre>

=={{header|SETL}}==

Associative arrays (referred to in SETL terminology as <i>maps</i>) are implemented as sets whose only members are tuples of length 2. Create such a set:

We can then index the set, or map, with the first element of a constituent tuple to return that tuple's second element:

{{out}}

<pre>b</pre>

If the map might contain more than one value associated with the same key, we can return the set of them (in this instance a unit set because the keys are in fact unique):

{{out}}

<pre>{b}</pre>

 

=={{header|SETL4}}==

* Iterate over key-value pairs of a map

 

out('next domain entry',next(d)) :s(next)

done

 

=={{header|Sidef}}==

key1 => 'value1',

key2 => 'value2',

 

# Add a new key-value pair

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

states at: 'MI' put: 'Michigan'.

alternative:

 

=={{header|SNOBOL4}}==

t<"red"> = "#ff0000"

t<"green"> = "#00ff00"

output = t<"blue">

output = t<"green">

 

=={{header|SQL}}==

REM Create a table to associate keys with values

CREATE TABLE associative_array ( KEY_COLUMN VARCHAR2(10), VALUE_COLUMN VARCHAR2(100)); .

REM Retrieve a key value pair

SELECT aa.value_column FROM associative_array aa where aa.key_column = 'KEY';

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

CALL DBMS_OUTPUT.PUT_LINE(HASH['5']);

END@

Output:

<pre>

 

=={{header|Stata}}==

a=asarray_create()

 

 

// End Mata session

 

=={{header|Swift}}==

var a = [String: Int]()

// or

 

// make a map with a literal

 

=={{header|Symsyn}}==

Symsyn implements Hash as a list of strings. Each name/value or key/value pair is stored in another string. The name/value pair is in the format 'name=value', the '=' is reserved.

#+ 'name=bob' $hash | add to hash

#? 'name' $hash $S | find 'name' and return 'bob' in $S

#- 'name' $hash | delete 'name=bob' from hash

=={{header|Tcl}}==

All arrays in Tcl are associative.

 

set hash(foo) 5

 

foreach key [array names hash] {

puts $hash($key)

 

Tcl also provides associative map values (called “dictionaries”) from 8.5 onwards.

<br>

{{works with|Tcl|8.5}}

set d [dict create foo 5 bar 10 baz 15]

 

 

# Output the whole dictionary (since it is a Tcl value itself)

 

=={{header|Toka}}==

Toka provides associative arrays via a library.

 

 

( create an associative array )

( obtain and print the values )

" first" foo asarray.get .

 

=={{header|UNIX Shell}}==

{{works with|ksh}}

hash=( [key1]=val1 [key2]=val2 )

hash[key3]=val3

 

{{works with|bash}}

assigning values is the same as ksh, but to declare the variable as an associative array:

 

=={{header|UnixPipes}}==

A key value file can be considered as an associative array

 

function init() {

put c cow

get c

 

=={{header|Vala}}==

{{libheader|Gee}}

using Gee;

 

stdout.printf("%d\n", map.get("two"));

}

 

Compile with flag: <pre> --pkg gee-1.0 </pre>

See '''[https://msdn.microsoft.com/en-us/library/x4k5wbx4.aspx here]''' in the MSDN the reference for the Dictionary object that can be used in VBA. The following example shows how to create a dictionary, add/remove keys, change a key or a value, and check the existence of a key.

 

Sub Test()

Dim h As Object

h.RemoveAll

Debug.Print h.Count

 

=={{header|Vim Script}}==

Dictionary keys are always strings.

let dict = {"one": 1, "two": 2}

 

let one = remove(dict, "one")

unlet dict["two"]

 

=={{header|Visual FoxPro}}==

Visual FoxPro has a collection class which can be used for this.

LOCAL loCol As Collection, k, n, o

CLEAR

ENDPROC

ENDDEFINE

 

=={{header|Wart}}==

h 'a

 

=={{header|Wren}}==

Wren has a Map class built in.

fruit[1] = "orange" // associates a key of 1 with "orange"

fruit[2] = "apple" // associates a key of 2 with "apple"

System.print(capitals) // prints all remaining entries

System.print(capitals.count) // prints the number of remaining entries

 

{{out}}

null

</pre>

 

=={{header|XLISP}}==

XLISP refers to associative arrays as tables. The <tt>MAKE-TABLE</tt> function returns a new empty table, for instance:

Values can then be inserted using <tt>TABLE-SET!</tt>:

(table-set! starlings "Abbot's starling" "Poeoptera femoralis")

and retrieved using <tt>TABLE-REF</tt> with their keys:

Output in a REPL:

<pre>"Lamprotornis nitens"</pre>

Other functions provided for tables include <tt>MAP-OVER-TABLE-ENTRIES</tt>, which takes a table and a function of two arguments and applies the function to each entry (using the key and value as the two arguments), for instance:

Output in a REPL:

<pre>"Abbott's starling (Linnaean name Poeoptera femoralis)"

 

=={{header|XPL0}}==

char Dict(10,10);

int Entries;

ChOut(0, Lookup("beta")); CrLf(0);

ChOut(0, Lookup("omega")); CrLf(0);

 

For greater speed a hashing algorithm should be used to look up items in

 

=={{header|zkl}}==

D(two:2,three:3,one:1)

 

zkl: T("one",1, "two",2, "three",3).toDictionary()

 

{{omit from|Applesoft BASIC}}