Associative arrays/Creation

From Rosetta Code

In this task, the goal is to create an associative array (also known as a dictionary, map, or hash).

[edit] 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.

var map:Object = {key1: "value1", key2: "value2"};
trace(map['key1']); // outputs "value1"
 
// Dot notation can also be used
trace(map.key2); // outputs "value2"
 
// More keys and values can then be added
map['key3'] = "value3";
trace(map['key3']); // outputs "value3"

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

[edit] Ada

Works with: GNAT version GPL 2007

with Ada.Containers.Ordered_Maps;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Text_IO;
 
procedure Associative_Array is
 
   -- Instantiate the generic package Ada.Containers.Ordered_Maps
 
   package Associative_Int is new Ada.Containers.Ordered_Maps(Unbounded_String, Integer);
   use Associative_Int;
 
   Color_Map : Map;
   Color_Cursor : Cursor;
   Success : Boolean;
   Value : Integer;
begin
 
   -- Add values to the ordered map
 
   Color_Map.Insert(To_Unbounded_String("Red"), 10, Color_Cursor, Success);
   Color_Map.Insert(To_Unbounded_String("Blue"), 20, Color_Cursor, Success);
   Color_Map.Insert(To_Unbounded_String("Yellow"), 5, Color_Cursor, Success);
 
   -- retrieve values from the ordered map and print the value and key
   -- to the screen
 
   Value := Color_Map.Element(To_Unbounded_String("Red"));
   Ada.Text_Io.Put_Line("Red:" & Integer'Image(Value));
   Value := Color_Map.Element(To_Unbounded_String("Blue"));
   Ada.Text_IO.Put_Line("Blue:" & Integer'Image(Value));
   Value := Color_Map.Element(To_Unbounded_String("Yellow"));
   Ada.Text_IO.Put_Line("Yellow:" & Integer'Image(Value));
end Associative_Array;

[edit] Aikido

Aikido provides a native map 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"
names[3] = 4
 
// initialized map
var names2 = {"foo": bar, 3:4}
 
// lookup map
var name = names["foo"]
if (typeof(name) == "none") {
    println ("not found")
} else {
    println (name)
}
 
// remove from map
delete names["foo"]

[edit] ALGOL 68

Translation of: C++

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

main:(
 
  MODE COLOR = BITS;
  FORMAT color repr = $"16r"16r6d$;
 
  # This is an associative array which maps strings to ints #
  MODE ITEM = STRUCT(STRING key, COLOR value);
  REF[]ITEM color map items := LOC[0]ITEM;
 
  PROC color map find = (STRING color)REF COLOR:(
    REF COLOR out;
# linear search! #
    FOR index FROM LWB key OF color map items TO UPB key OF color map items DO
      IF color = key OF color map items[index] THEN 
        out := value OF color map items[index]; GO TO found
      FI
    OD;
      NIL EXIT
    found:
      out
  );
 
  PROC color map = (STRING color)REF COLOR:(
    REF COLOR out = color map find(color);
    IF out :=: REF COLOR(NIL) THEN # extend color map array #
      HEAP[UPB key OF color map items + 1]ITEM color map append;
      color map append[:UPB key OF color map items] := color map items;
      color map items := color map append;
      value OF (color map items[UPB value OF color map items] := (color, 16r000000)) # black #
    ELSE
      out
    FI
  );
 
  # First, populate it with some values #
  color map("red") := 16rff0000;
  color map("green") := 16r00ff00;
  color map("blue") := 16r0000ff;
  color map("my favourite color") := 16r00ffff;
 
  # then, get some values out #
  COLOR color := color map("green"); # color gets 16r00ff00 # 
  color := color map("black"); # accessing unassigned values assigns them to 16r0 #
 
  # get some value out without accidentally inserting new ones #
  REF COLOR value = color map find("green");
  IF value :=: REF COLOR(NIL) THEN
    put(stand error, ("color not found!", new line))
  ELSE
    printf(($"green: "f(color repr)l$, value))
  FI;
 
  # Now I changed my mind about my favourite color, so change it #
  color map("my favourite color") := 16r337733;
 
  # print out all defined colors #
  FOR index FROM LWB color map items TO UPB color map items DO
    ITEM item = color map items[index];
    putf(stand error, ($"color map("""g""") = "f(color repr)l$, item))
  OD;
 
  FORMAT fmt;
  FORMAT comma sep = $"("n(UPB color map items-1)(f(fmt)", ")f(fmt)")"$;
 
  fmt := $""""g""""$;
  printf(($g$,"keys: ", comma sep, key OF color map items, $l$));
  fmt := color repr;
  printf(($g$,"values: ", comma sep, value OF color map items, $l$))
 
)

Output:

green: 16r00ff00
color map("red") = 16rff0000
color map("green") = 16r00ff00
color map("blue") = 16r0000ff
color map("my favourite color") = 16r337733
color map("black") = 16r000000
keys: ("red", "green", "blue", "my favourite color", "black")
values: (16rff0000, 16r00ff00, 16r0000ff, 16r337733, 16r000000)

[edit] APL

Works with: Dyalog APL

⍝  Create a namespace ("hash")
      X←⎕NS ⍬
 
      ⍝ Assign some names
      X.this←'that'
      X.foo←88
 
      ⍝  Access the names
      X.this
that
 
      ⍝  Or do it the array way
      X.(foo this)
88  that 
 
      ⍝  Namespaces are first class objects
      sales ← ⎕NS ⍬
      sales.(prices quantities) ← (100 98.4 103.4 110.16) (10  12 8  10)
      sales.(revenue ← prices +.× quantities)
      sales.revenue
4109.6

[edit] AWK

Arrays in AWK are indeed associative arrays.

BEGIN {
  a["red"] = 0xff0000
  a["green"] = 0x00ff00
  a["blue"] = 0x0000ff
  for (i in a) {
    printf "%8s %06x\n", i, a[i] 
  }
  # deleting a key/value
  delete a["red"]
  for (i in a) {
    print i
  }
  # check if a key exists
  print ( "red" in a )   # print 0
  print ( "blue" in a )  # print 1
}

[edit] AutoHotkey

AutoHotkey does not have typical arrays. However, variable names can be concatenated, simulating associative arrays. Just without the syntactic sugar of '[]'.

arrayX1 = first
arrayX2 = second
arrayX3 = foo
arrayX4 = bar
Loop, 4
  Msgbox % arrayX%A_Index%

[edit] Batch File

This is cheating, I'm sure of it.

::assocarrays.cmd
@echo off
setlocal ENABLEDELAYEDEXPANSION
set array.dog=1
set array.cat=2
set array.wolf=3
set array.cow=4
for %%i in (dog cat wolf cow) do call :showit array.%%i !array.%% class="re2">i!
set c=-27
call :mkarray sicko flu 5 measles 6 mumps 7 bromodrosis 8
for %%i in (flu measles mumps bromodrosis) do call :showit "sicko^&%%i" !sicko^&%%i!
endlocal
goto :eof
 
:mkarray
set %1^&%2=%3
shift /2
shift /2
if "%2" neq "" goto :mkarray
goto :eof
 
:showit
echo %1 = %2
goto :eof

Output:

array.dog = 1
array.cat = 2
array.wolf = 3
array.cow = 4
"sicko&flu" = 5
"sicko&measles" = 6
"sicko&mumps" = 7
"sicko&bromodrosis" = 8

Standard C libraries have not an associative array facility. So programmer must implement their own hashes, or use existing non standard libraries. I have not found de facto standard libraries (i.e. libraries so widespread and well-known that could be considered standard).

Here I have used Judy.

Library: Judy

#include <stdio.h>
#include <Judy.h>
 
int main()
{
  Pvoid_t assarray = (Pvoid_t) NULL;
  PWord_t value;
  int retval;
 
  /* populating */
  JSLI(value, assarray, "red");
  *value = 0xff0000;
  JSLI(value, assarray, "green");
  *value = 0x00ff00;
  JSLI(value, assarray, "blue");
  *value = 0x0000ff;
 
  /* retrieving existent */
  JSLG(value, assarray, "blue");
  printf("blue is #%06x\n", *value);
 
  /* unknown key */
  JSLG(value, assarray, "nonexistingkey");
  if ( value == NULL ) { fprintf(stderr, "key 'nonexistingkey' does not exists\n"); }
 
  /* deleting */
  JSLD(retval, assarray, "red");
  JSLG(value, assarray, "red");
  if ( value == NULL ) { fprintf(stderr, "key red does not exist anymore\n"); }
 
  JudySLFreeArray(&assarray, PJE0);
 
  return 0;
}

[edit] 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.

#include <map>

[edit] 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:

std::map<A, B> exampleMap

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

std::map<int, double> exampleMap

[edit] Insertion

Once we've created our map, we've got a couple different ways to insert the value. Let's use an example key of 7, and an exable value of 3.14.

[edit] Operator[]

The first method is using the [] operator.

exampleMap[7] = 3.14

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

int myKey = 7;
double myValue = 3.14;
exampleMap[myKey] = myValue;

[edit] insert()

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

exampleMap.insert(std::pair<int, double>(7,3.14));

[edit] Lookup

As with insertion, there are a couple ways we can retrieve the value.

[edit] operator[]

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

myValue = exampleMap[myKey]

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.

[edit] 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:

double myValue = 0.0;
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.

This code assigns a 0 to myValue if the map contained a value.

[edit] 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 <map>
#include <iostreams>
 
int main()
{
  // Create the map.
  std::map<int, double> exampleMap;
 
  // Choose our key
  int myKey = 7;
 
  // Choose our value
  double myValue = 3.14;
 
  // Assign a value to the map with the specified key.
  exampleMap[myKey] = myValue;
 
  // Retrieve the value
  double myRetrievedValue = exampleMap[myKey];
 
  // Display our retrieved value.
  std::cout << myRetrievedValue << std::endl;
 
  // main() must return 0 on success.
  return 0;
}

[edit] C#

Platform: .NET 1.x

System.Collections.HashTable map = new System.Collections.HashTable();
map["key1"] = "foo";

Platform: .NET 2.0

Dictionary<string, string> map = new Dictionary<string,string>();
map[ "key1" ] = "foo";

Works with: C# version 3.0+

var map = new Dictionary<string, string> {{"key1", "foo"}};

[edit] Clojure

{:key "value"
 :key2 "value2"
 :key3 "value3"}

[edit] ColdFusion

<cfset myHash = structNew()>
<cfset myHash.key1 = "foo">
<cfset myHash["key2"] = "bar">
<cfset myHash.put("key3","java-style")>

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

[edit] Common Lisp

;; default :test is #'eql, which is suitable for numbers only,
;; or for implementation identity for other types!
;; Use #'equalp if you want case-insensitive keying on strings.
 
(setf my-hash (make-hash-table :test #'equal))
(setf (gethash "H2O" my-hash) "Water")
(setf (gethash "HCl" my-hash) "Hydrochloric Acid")
(setf (gethash "CO" my-hash) "Carbon Monoxide")
 
;; That was actually a hash table, an associative array or
;; alist is written like this:
(defparameter *legs* '((cow . 4) (flamingo . 2) (centipede . 100)))
;; you can use assoc to do lookups and cons new elements onto it to make it longer.

[edit] D

void main() {
    auto hash = ["foo":42, "bar":100];
    assert("foo" in hash);
}

[edit] Dao

m = { => } # empty, future inserted keys will be ordered
h = { : } # empty, future inserted keys will not be ordered
 
m = { 'foo' => 42, 'bar' => 100 } # with ordered keys
h = { 'foo' : 42, 'bar' : 100 } # with unordered keys

[edit] E

[].asMap()                             # immutable, empty
["one" => 1, "two" => 2]               # immutable, 2 mappings
[].asMap().diverge()                   # mutable, empty
["one" => 2].diverge(String, float64)  # mutable, initial contents,
                                        #   typed (coerces to float)

[edit] 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")
 
let takeVal (d:Map<string,string>) = 
    match d.TryFind("key") with
        | Some(v) -> printfn "%s" v
        | None -> printfn "not found"

[edit] Factor

Associative mappings follow the associative protocol. See the docs. Here's an example using a hashtable that can be run in the listener :

H{ { "one" 1 } { "two" 2 } }
{ [ "one" swap at . ]
  [ 2 swap value-at . ]
  [ "three" swap at . ]
  [ [ 3 "three" ] dip set-at ]
  [ "three" swap at . ] } cleave

[edit] Forth

Works with: GNU Forth version 0.6.2

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.

: get ( key len table -- data )     \ 0 if not present
  search-wordlist if
    >body @
  else 0 then ;
 
: put ( data key len table -- )
  >r 2dup r@ search-wordlist if
    r> drop nip nip
    >body !
  else
    r> get-current >r set-current      \ switch definition word lists
    nextname create ,
    r> set-current
  then ;
 wordlist constant bar
5 s" alpha" bar put
9 s" beta"  bar put
2 s" gamma" bar put
s" alpha" bar get .    \ 5
8 s" Alpha" bar put    \ Forth dictionaries are normally case-insensitive
s" alpha" bar get .   \ 8

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 table and table-find, replacing wordlist and search-wordlist, respectively.

(The use of nextname ( str len -- ) is a GNU Forth extension to create; there is no means in the ANS standard to use a string on the stack to create a dictionary entry.)

Library: Forth Foundation Library

Hashtable for mapping strings to integer

include ffl/hct.fs
 
\ Create a hash table 'table' in the dictionary with a starting size of 10
 
10 hct-create htable
 
\ Insert entries
 
 5 s" foo" htable hct-insert
10 s" bar" htable hct-insert
15 s" baz" htable hct-insert
 
\ Get entry from the table
 
s" bar" htable hct-get [IF]
  .( Value:) . cr
[ELSE]
  .( Entry not present.) cr
[THEN]

[edit] Go

Go's maps can only have a key type that is boolean, numeric, string, pointer, function, interface, map, or channel; you cannot use a key type of array, slice, or struct.

// declare a nil map variable, for maps from string to int
var x map[string] int
 
// make an empty map
x = make(map[string] int)
 
// make an empty map with an optional initial capacity
x = make(map[string] int, 42)
 
// set a value
x["foo"] = 3
 
// make a map with a literal
x = map[string] int {
  "foo": 2, "bar": 42, "baz": -1,
}

[edit] Groovy

Create an empty map and add values

map = [:]
map[7] = 7
map['foo'] = 'foovalue'
map.put('bar', 'barvalue')
map.moo = 'moovalue'
 
assert 7 == map[7]
assert 'foovalue' == map.foo
assert 'barvalue' == map['bar']
assert 'moovalue' == map.get('moo')

Create a pre-populated map and verify values

map = [7:7, foo:'foovalue', bar:'barvalue', moo:'moovalue']
 
assert 7 == map[7]
assert 'foovalue' == map.foo
assert 'barvalue' == map['bar']
assert 'moovalue' == map.get('moo')

[edit] Haskell

Works with: GHC

import Data.Map
 
dict = fromList [("key1","val1"), ("key2","val2")]

[edit] Icon and 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.

[edit] Icon

procedure main() 
   local t
   t := table() 
   t["foo"] := "bar"
   write(t["foo"])
end

[edit] Unicon

This Icon solution works in Unicon.

[edit] Ioke

{a: "a", b: "b"}

[edit] J

 coclass 'assocArray'
  create=: 3 :'erase ''COCREATOR'''
  get=: ".
  set=:4 :'(x)=:y'

Example use:

   example=: conew~'assocArray'
   'foo' set__example 1 2 3
1 2 3
   'bar' set__example 4 5 6
4 5 6
   get__example 'foo'
1 2 3
   foo__example
1 2 3
   bletch__example=: 7 8 9
   get__example 'bletch'
7 8 9

[edit] Java

Works with: Java version 1.5+

Defining the Map:

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("foo", 5);
map.put("bar", 10);
map.put("baz", 15);
map.put("foo", 6);

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

Initializing a Map as a class member:

public static Map<String, Integer> map = new HashMap<String, Integer>(){{
   put("foo", 5);
   put("bar", 10);
   put("baz", 15);
   put("foo", 6);
}};

Retrieving a value:

map.get("foo"); // => 5
map.get("invalid"); // => null

Note that it is possible to put null as a value, so null being returned by get is not sufficient for determining that the key is not in the Map. There is a containsKey method for that.

Iterate over keys:

for (String key: map.keySet()) 
   System.out.println(key);

Iterate over values:

for (int value: map.values())
   System.out.println(value);

Iterate over key, value pairs:

for (Map.Entry<String, Integer> entry: map.entrySet())
   System.out.println(entry.getKey() + " => " + entry.getValue());

[edit] JavaScript

In Javascript we make an associative array from an empty object, otherwise if we make it from an array we'll get all the Array object's method and properties when we iterate over it. Note that this associative array uses strings as its key, but automagically casts other types to strings if used as indices:

var assoc = {};
assoc['foo'] = 'bar';
assoc['another-key'] = 3;
assoc.thirdKey = 'we can also do this!';
assoc[2] = 'the index here is the string "2"';
assoc[null] = 'this also works';
 
for(key in assoc)
{
  alert('key:"'+key+'", value:"'+assoc[key]+'"');
}

The above associative array can also be constructed using Javascript's object literal syntax

var assoc = {
  foo:'bar',
  'another-key':3, //the key can either be enclosed by quotes or not
};

Notice the quotes on some names. When quoting the names you avoid potential collisions with reserved JavaScript key words. http://www.quackit.com/javascript/javascript_reserved_words.cfm

We can also check whether a key exists in an object or not:

'foo' in assoc // true

[edit] Logo

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

pprop "animals "cat 5
pprop "animals "dog 4
pprop "animals "mouse 11
print gprop "animals "cat    ; 5
remprop "animals "dog
show plist "animals    ;  [mouse 11 cat 5]

[edit] Lua

Lua tables are Hashes

hash = {}
hash[ "key-1" ] = "val1"
hash[ "key-2" ] = 1
hash[ "key-3" ] = {}

Returns nil on unknown key.

[edit] Objective-C

Works with: Cocoa and Works with: GNUstep

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.

NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
    @"Joe Doe", @"name",
    [NSNumber numberWithUnsignedInt:42], @"age",
    [NSNull null], @"extra",
    nil];

To create a mutable dictionary, use NSMutableDictionary:

NSMutableDictionary *dict = [NSMutableDictionary dictionary];
[dict setObject:@"Joe Doe" forKey:@"name"];
[dict setObject:[NSNumber numberWithInt:42] forKey:@"age"];

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

NSString *name = [dict objectForKey:@"name"];
unsigned age = [dict objectForKey:@"age"] unsignedIntValue];
id missing = [dict objectForKey:@"missing"];

[edit] OCaml

[edit] Hash table

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

let hash = Hashtbl.create 0;;
List.iter (fun (key, value) -> Hashtbl.add hash key value)
  ["foo", 5; "bar", 10; "baz", 15];;

To retrieve a value:

let bar = Hashtbl.find hash "bar";; (* bar = 10 *)

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

let quux = try Hashtbl.find hash "quux" with Not_found -> some_value;;

[edit] Binary tree

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

module String = struct
   type t = string
   let compare = Pervasives.compare
end
module StringMap = Map.Make(String);;
 
let map =
  List.fold_left
    (fun map (key, value) -> StringMap.add key value map)
    StringMap.empty
    ["foo", 5; "bar", 10; "baz", 15]
;;

To retrieve a value:

let bar = StringMap.find "bar" map;; (* bar = 10 *)

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

let quux = try StringMap.find "quux" map with Not_found -> some_value;;

[edit] Oz

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

declare
  Dict = {Dictionary.new}
in
  Dict.foo := 5
  Dict.bar := 10
  Dict.baz := 15
  Dict.foo := 20
 
  {Inspect Dict}

'Records' can be consideres immutable maps:

declare
  Rec = name(foo:5 bar:10 baz:20)
in
  {Inspect Rec}

[edit] Perl

[edit] Hash

Definition:

# using => key does not need to be quoted unless it contains special chars
my %hash = (
  key1 => 'val1',
  'key-2' => 2,
  three => -238.83,
  4 => 'val3',
);
 
# using , both key and value need to be quoted if containing something non-numeric in nature
my %hash = (
  'key1', 'val1',
  'key-2', 2,
  'three', -238.83,
  4, 'val3',
);

Use:

print $hash{key1};
 
$hash{key1} = 'val1';
 
@hash{'key1', 'three'} = ('val1', -238.83);

[edit] HashRef

Definition:

my $hashref = {
 key1 => 'val1',
  'key-2' => 2,
  three => -238.83,
  4 => 'val3',
}

Use:

print $hash->{key1};
 
$hash->{key1} = 'val1';
 
@hash->{'key1', 'three'} = ('val1', -238.83);

[edit] Perl 6

Works with: Rakudo version #22 "Thousand Oaks"

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

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

Hash elements and hash slices now use the same sigil as the whole hash. This is construed as a feature. Curly braces no longer auto-quote, but Perl 6's qw (shortcut < ... >) now auto-subscripts.

say %h1{'key1'};
say %h1<key1>;
%h1<key1> = 'val1';
%h1<key1 three> = 'val1', -238.83;

Special syntax is no longer necessary to access a hash stored in a scalar.

my $h = {key1 => 'val1', 'key-2' => 2, three => -238.83, 4 => 'val3'};
say $h<key1>;

[edit] PHP

$array = array();
$array['foo'] = 'bar';
$array['bar'] = 'foo';
 
echo($array['foo']); // bar
echo($array['moo']); // Undefined index
 
//alternative (inline) way
$array2 = array('fruit' => 'apple',
                'price' => 12.96,
                'colour' => 'green');

[edit] Iterate over key/value

foreach($array as $key => $value)
{
   echo "Key: $key Value: $value";
}

[edit] PicoLisp

Here we use symbol properties. Other possiblities could be index trees or association lists.

(put 'A 'foo 5)
(put 'A 'bar 10)
(put 'A 'baz 15)
(put 'A 'foo 20)
 
: (get 'A 'bar)
-> 10
 
: (get 'A 'foo)
-> 20
 
: (show 'A)
A NIL
   foo 20
   bar 10
   baz 15

[edit] Pop11

;;; Create expandable hash table of initial size 50 and with default
;;; value 0 (default value is returned when the item is absent).
vars ht = newmapping([], 50, 0, true);
;;; Set value corresponding to string 'foo'
12 -> ht('foo');
;;; print it
ht('foo') =>
;;; Set value corresponding to vector {1 2 3}
17 -> ht({1 2 3});
;;; print it
ht({1 2 3}) =>
;;; Set value corresponding to number 42 to vector {0 1}
{0 1} -> ht(42);
;;; print it
ht(42) =>
 
;;; Iterate over keys printing keys and values.  
 appproperty(ht,
    procedure (key, value);
      printf(value, '%p\t');
      printf(key, '%p\n');
     endprocedure);

[edit] PowerShell

Am empty hash table can be created with

$hashtable = @{}

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

$hashtable = @{
    "key1" = "value 1"
    "key2" = 5
}

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.foo    = "bar"
$hashtable['bar'] = 42
$hashtable."a b"  = 3.14  # keys can contain spaces, property-style access needs quotation marks, then
$hashtable[5]     = 8     # keys don't need to be strings

Similarly, values can be retrieved using either syntax:

$hashtable.key1     # value 1
$hashtable['key2']  # 5

[edit] Prolog

We use the facts table for this purpose.

 
mymap(key1,value1).
mymap(key2,value2).
 
?- mymap(key1,V).
   V = value1

[edit] PureBasic

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

NewMap dict.s()
dict("country") = "Germany"
Debug dict("country")

[edit] Python

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

hash = dict()  # 'dict' is the dictionary type.
hash = dict(red="FF0000", green="00FF00", blue="0000FF")
hash = { 'key1':1, 'key2':2, }
value = hash[key]

Numerous methods exist for the mapping type http://docs.python.org/lib/typesmapping.html

# empty dictionary
d = {}
d['spam'] = 1
d['eggs'] = 2  
 
# dictionaries with two keys
d1 = {'spam': 1, 'eggs': 2}
d2 = dict(spam=1, eggs=2)
 
# dictionaries from tuple list
d1 = dict([('spam', 1), ('eggs', 2)])
d2 = dict(zip(['spam', 'eggs'], [1, 2]))
 
# iterating over keys
for key in d:
  print key, d[key]
 
# iterating over (key, value) pairs
for key, value in d.iteritems():
  print key, value

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

myDict = { '1': 'a string', 1: 'an integer', 1.0: 'a floating point number', (1,): 'a tuple' }

(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).

User defined classes which implement the __hash__() special method can also be used as dictionary keys. It's the responsibility of the programmer to ensure the properties of the resultant hash value. The instance object's unique ID (accessible via the id() built-in function) is commonly used for this purpose.

[edit] R

The R object which is the most similar to an associative array is called list; a list can take labels (tags)

a <- list(a=1, b=2, c=3.14, d="xyz")

If tags are omitted, numerical tags in increasing order (from 1) are assigned.

print(a$a)   # [1] 1
print(a$d)   # [1] "xyz"

But we can always access the element of a list with its numeric index, or take directly the value:

print(a[4])

outputs:

$d
[1] "xyz"

while

print(a[[4]])

outputs "xyz"

[edit] Raven

{ 'a' 1 'b' 2 'c' 3.14 'd' 'xyz' } as a_hash
a_hash print
 
hash (4 items)
 a => 1
 b => 2
 c => 3.14
 d => "xyz"
 
a_hash 'c' get         # get key 'c'
6.28 a_hash 'c' set    # set key 'c'
a_hash.'c'             # get key 'c' shorthand
6.28 a_hash:'c'        # set key 'c' shorthand

Null is returned for unknown keys.

[edit] 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.green = strtod("0x00ff00");  // convert it to real numbers using ''strtod'' function.
x.blue  = strtod("0x0000ff");
 
// print content of a list
for (i in members(x))
{ printf("%8s %06x\n", i, int(x.[i])); }  // we have to use ''int'' function to convert reals to integers so "%x" format works
 
// deleting a key/value
clear (x.red);
 
// we can also use numeric identifiers in the above example
xid = members(x);  // this is a string array
 
for (i in 1:length(xid))
{ printf("%8s %06x\n", xid[i], int(x.[ xid[i] ])); }
 
// Finally, we can use numerical identifiers
// Note: ''members'' function orders the list identifiers lexicographically, in other words
// instead of, say, 1,2,3,4,5,6,7,8,9,10,11 ''members'' returns 1,10,11,2,3,4,5,6,7,8,9
x = <<>>;  // create an empty list
for (i in 1:5)
{ x.[i] = i; }  // assign to the element of list ''i'' the real value equal to i.

[edit] Ruby

A hash object that returns nil for unknown keys

hash={}
hash[666]='devil'
hash[777]  # => nil
hash[666]  # => 'devil'

A hash object that returns 'unknown key' for unknown keys

hash=Hash.new('unknown key')
hash[666]='devil'
hash[777]  # => 'unknown key'
hash[666]  # => 'devil'

A hash object that returns "unknown key #{key}" for unknown keys

hash=Hash.new{|h,k|h[k]="unknown key #{k}"}
hash[666]='devil'
hash[777]  # => 'unknown key 777'
hash[666]  # => 'devil'

[edit] Sather

class MAIN is
  main is
    -- creation of a map between strings and integers
    map ::= #MAP{STR, INT};
 
    -- add some values
    map := map.insert("red", 0xff0000);
    map := map.insert("green", 0xff00);
    map := map.insert("blue", 0xff);
 
    #OUT + map + "\n"; -- show the map...
 
    -- test if "indexes" exist
    #OUT +  map.has_ind("red") + "\n";
    #OUT +  map.has_ind("carpet") + "\n";
 
    -- retrieve a value by index
    #OUT + map["green"] + "\n";
  end;
end;

[edit] Scala

// immutable maps
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
map.isDefinedAt(44) // true

// mutable maps (HashSets)
import scala.collection.mutable.HashMap
val hash = new HashMap[int, int]
hash(1) = 2
hash += (1 -> 2)  // same as hash(1) = 2
hash += (3 -> 4, 5 -> 6, 44 -> 99)
hash(44) // 99
hash.contains(33) // false
hash.isDefinedAt(33) // same as contains
hash.contains(44) // true

// iterate over key/value
hash.foreach {e => println("key "+e._1+" value "+e._2)} // e is a 2 element Tuple
// same with for syntax
for((k,v) <- hash) println("key " + k + " value " + v)

// items in map where the key is greater than 3
map.filter {k => k._1 > 3} //  Map(5 -> 6, 44 -> 99)
// same with for syntax
for((k, v) <- map; if k > 3) yield (k,v)

[edit] Slate

{'MI' -> 'Michigan'. 'MN' -> 'Minnesota'} as: Dictionary.

[edit] Smalltalk

states := Dictionary new.
states at: 'MI' put: 'Michigan'.
states at: 'MN' put: 'Minnesota'.

[edit] SNOBOL4

	t = table()
	t<"red"> = "#ff0000"
	t<"green"> = "#00ff00"
	t<"blue"> = "#0000ff"
 
	output = t<"red">
	output = t<"blue"> 
	output = t<"green">
end

[edit] Tcl

All arrays in Tcl are associative.

# Create one element at a time:
set hash(foo) 5
 
# Create in bulk:
array set hash {
    foo 5
    bar 10
    baz 15
}
 
# Access one element:
set value $hash(foo)
 
# Output all values:
foreach key [array names hash] {
    puts $hash($key)
}

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

# Create in bulk
set d [dict create  foo 5  bar 10  baz 15]
 
# Create/update one element
dict set d foo 5
 
# Access one value
set value [dict get $d foo]
 
# Output all values
dict for {key value} $d {
    puts $value
}
# Alternatively...
foreach value [dict values $d] {
    puts $value
}
 
# Output the whole dictionary (since it is a Tcl value itself)
puts $d

[edit] Toka

Toka provides associative arrays via a library.

needs asarray
 
( create an associative array )
1024 cells is-asarray foo
 
( store 100 as the "first" element in the array )
100 " first" foo asarray.put
 
( store 200 as the "second" element in the array )
200 " second" foo asarray.put
 
( obtain and print the values )
" first" foo asarray.get .
" second" foo asarray.get .

[edit] UnixPipes

A key value file can be considered as an associative array

map='p.map'
 
function init() {
cat <<EOF > $map
apple a
boy b
cat c
dog d
elephant e
EOF
}
 
function put() {
    k=$1; v=$2;
    del $k
    echo $v $k >> $map
 }
 
function get() {
    k=$1
    for v in $(cat $map | grep "$k$"); do
        echo $v
        break
    done
 }
 
function del() {
    k=$1
    temp=$(mktemp)
    mv $map $temp
    cat $temp | grep -v "$k$" > $map
}
 
function dump() {
    echo "-- Dump begin --"
    cat $map
    echo "-- Dump complete --"
}
 
init
get c
put c cow
get c
dump