Associative array/Iteration

Associative array/Iteration
You are encouraged to solve this task according to the task description, using any language you may know.

Show how to iterate over the key-value pairs of an associative array, and print each pair out. Also show how to iterate just over the keys, or the values, if there is a separate way to do that in your language.

• Related task: Associative arrays/Creation

Ada

<lang Ada>with Ada.Text_IO; use Ada.Text_IO; with Ada.Containers.Indefinite_Ordered_Maps;

procedure Test_Iteration is

  package String_Maps is
     new Ada.Containers.Indefinite_Ordered_Maps (String, Integer);
  use String_Maps;
  A     : Map;
  Index : Cursor;

begin

  A.Insert ("hello", 1);
  A.Insert ("world", 2);
  A.Insert ("!",     3);
  Index := A.First;
  while Index /= No_Element loop
     Put_Line (Key (Index) & Integer'Image (Element (Index)));
     Index := Next (Index);
  end loop;

end Test_Iteration;</lang> Sample output:

! 3
hello 1
world 2

AutoHotkey

Works with: AutoHotkey_L

From the documentation<lang AutoHotkey>; Create an associative array obj := Object("red", 0xFF0000, "blue", 0x0000FF, "green", 0x00FF00) enum := obj._NewEnum() While enum[key, value]

   t .= key "=" value "`n"

MsgBox % t</lang>

AWK

In AWK "arrays" are always associative arrays, and the only way to iterate over them is by keys (indexes in the AWK terminology)

<lang awk>BEGIN {

 a["hello"] = 1
 a["world"] = 2
 a["!"] = 3

 # iterate over keys
 for(key in a) {
   print key, a[key]
 }

}</lang>

BBC BASIC

<lang bbcbasic> REM Store some values with their keys:

     PROCputdict(mydict$, "FF0000", "red")
     PROCputdict(mydict$, "00FF00", "green")
     PROCputdict(mydict$, "0000FF", "blue")
     
     REM Iterate through the dictionary:
     i% = 1
     REPEAT
       i% = FNdict(mydict$, i%, v$, k$)
       PRINT v$, k$
     UNTIL i% = 0
     END
     
     DEF PROCputdict(RETURN dict$, value$, key$)
     IF dict$ = "" dict$ = CHR$(0)
     dict$ += key$ + CHR$(1) + value$ + CHR$(0)
     ENDPROC
     
     DEF FNdict(dict$, I%, RETURN value$, RETURN key$)
     LOCAL J%, K%
     J% = INSTR(dict$, CHR$(1), I%)
     K% = INSTR(dict$, CHR$(0), J%)
     value$ = MID$(dict$, I%+1, J%-I%-1)
     key$ = MID$(dict$, J%+1, K%-J%-1)
     IF K% >= LEN(dict$) THEN K% = 0
     = K%</lang>

Brat

<lang brat>h = [ hello: 1 world: 2 :! : 3]

1. Iterate over key, value pairs

h.each { k, v |

 p "Key: #{k} Value: #{v}"

}

1. Iterate over keys

h.each_key { k |

 p "Key: #{k}"

}

1. Iterate over values

h.each_value { v |

 p "Value: #{v}"

}</lang>

C

Solution is at Associative arrays/Creation/C.

C++

<lang cpp>std::map<std::string, int> myDict; myDict["hello"] = 1; myDict["world"] = 2; myDict["!"] = 3;

// iterating over key-value pairs: for (std::map<std::string, int>::iterator it = myDict.begin(); it != myDict.end(); it++) {

   // the thing pointed to by the iterator is a pair<std::string, int>
   std::string key = it->first;
   int value = it->second;
   std::cout << "key = " << key << ", value = " << value << std::endl;

}</lang>

An alternative version using for_each and lambda functions

Works with: C++11

<lang cpp>#include <map>

1. include <algorithm>
2. include <iostream>
3. include <string>

using namespace std;

int main() {

   map<string, int> myDict;
   myDict["hello"] = 1;
   myDict["world"] = 2;
   myDict["!"] = 3;

   for_each(myDict.begin(), myDict.end(),
       [](const pair<string,int>& p)
       { 
           cout << "key = " << p.first << ", value = " << p.second << endl;
       });
   return 0;

}</lang>

C#

<lang csharp>using System; using System.Collections.Generic;

namespace AssocArrays {

   class Program
   {
       static void Main(string[] args)
       {

           Dictionary<string,int> assocArray = new Dictionary<string,int>();

           assocArray["Hello"] = 1;
           assocArray.Add("World", 2);
           assocArray["!"] = 3;

           foreach (KeyValuePair<string, int> kvp in assocArray)
           {
               Console.WriteLine(kvp.Key + " : " + kvp.Value);
           }

           foreach (string key in assocArray.Keys)
           {
               Console.WriteLine(key);
           }

           foreach (int val in assocArray.Values)
           {
               Console.WriteLine(val.ToString());
           }
       }
   }

} </lang>

Clojure

<lang clojure> (doseq [[k v] {:a 1, :b 2, :c 3}]

 (println k "=" v))

(doseq [k (keys {:a 1, :b 2, :c 3})]

 (println k))

(doseq [v (vals {:a 1, :b 2, :c 3})]

 (println v))

</lang>

Common Lisp

Common Lisp has three common idioms for associating keys with values: association lists (alists), property lists (plists), and hash tables.

With association lists (alists)

The association list is a list of conses, each of whose car is a key and whose cdr is a value. The standard mapping and print functions can be used to print key/value pairs, keys, and values.

<lang lisp>;; iterate using dolist, destructure manually (dolist (pair alist)

 (destructuring-bind (key . value) pair
   (format t "~&Key: ~a, Value: ~a." key value)))

iterate and destructure with loop

(loop for (key . value) in alist

     do (format t "~&Key: ~a, Value: ~a." key value))</lang>

With property lists (plists)

Property lists are lists of alternating keys and values, where each value's key is the element of the list immediately following it. Printing could be done with standard mapping functions, but loop's destructuring makes things a bit easier.

<lang lisp>(loop for (key value) on plist :by 'cddr

     do (format t "~&Key: ~a, Value: ~a." key value))</lang>

With hash tables

Lisp also has built-in hash tables, and there are several ways to map over these. The first is maphash which takes a function of two arguments (the key and value) and the hash table.

<lang lisp>(maphash (lambda (key value)

          (format t "~&Key: ~a, Value: ~a." key value))
        hash-table)</lang>

The loop construct also supports extracting key/value pairs from hash tables.

<lang lisp>(loop for key being each hash-key of hash-table using (hash-value value)

     do (format t "~&Key: ~a, Value: ~a." key value))</lang>

There is also a macro with-hash-table-iterator which locally binds a name to produce associated keys and values of the hash table; while rarely used, it is the most powerful operation.

<lang lisp>(with-hash-table-iterator (next-entry hash-table)

 (loop
  (multiple-value-bind (nextp key value) (next-entry)
    (if (not nextp)
      (return)
      (format t "~&Key: ~a, Value: ~a." key value)))))</lang>

D

Works with: D version 2

<lang d>import std.stdio: writeln;

void main() {

   // the associative array
   auto aa = ["alice":2, "bob":97, "charlie":45];

   // how to iterate key/value pairs:
   foreach (key, value; aa)
       writeln("1) Got key ", key, " with value ", value);
   writeln();

   // how to iterate the keys:
   foreach (key, _; aa)
       writeln("2) Got key ", key);
   writeln();

   // how to iterate the values:
   foreach (value; aa)
       writeln("3) Got value ", value);
   writeln();

   // how to extract the values, lazy:
   foreach (value; aa.byValue())
       writeln("4) Got value ", value);
   writeln();

   // how to extract the keys, lazy:
   foreach (key; aa.byKey())
       writeln("5) Got key ", key);
   writeln();

   // how to extract all the keys:
   foreach (key; aa.keys)
       writeln("6) Got key ", key);
   writeln();

   // how to extract all the values:
   foreach (value; aa.values)
       writeln("7) Got value ", value);

}</lang>

Dao

<lang ruby> m = { 'def' => 1, 'abc' => 2 } for( kv in m ) io.writeln( kv ); for( k in m.keys(); v in m.values() ) io.writeln( k, v ) </lang>

Delphi

<lang Delphi>program AssociativeArrayIteration;

{$APPTYPE CONSOLE}

uses SysUtils, Generics.Collections;

var

 i: Integer;
 s: string;
 lDictionary: TDictionary<string, Integer>;
 lPair: TPair<string, Integer>;

begin

 lDictionary := TDictionary<string, Integer>.Create;
 try
   lDictionary.Add('foo', 5);
   lDictionary.Add('bar', 10);
   lDictionary.Add('baz', 15);
   lDictionary.AddOrSetValue('foo', 6);

   for lPair in lDictionary do
     Writeln(Format('Pair: %s = %d', [lPair.Key, lPair.Value]));
   for s in lDictionary.Keys do
     Writeln('Key: ' + s);
   for i in lDictionary.Values do
     Writeln('Value: ' + IntToStr(i));
 finally
   lDictionary.Free;
 end;

end.</lang>

E

In E, the basic iteration protocol and syntax work over key-value pairs. Therefore, any iteration over a map or other collection is always key-value, though the user may choose to ignore the keys or the values.

The for loop takes either one pattern, for the value, or two, for the key and value; for iterating over keys alone the value may be given an ignore-pattern (_).

<lang e>def map := [

 "a" => 1,
 "b" => 2,
 "c" => 3,

]

for key => value in map {

 println(`$key $value`)

}

for value in map { # ignore keys

 println(`. $value`)

}

for key => _ in map { # ignore values

 println(`$key .`)

}

for key in map.domain() { # iterate over the set whose values are the keys

 println(`$key .`)

}</lang>

Elena

<lang elena>#define std'dictionary'*.

1. define std'routines'*.
2. define std'collections'*.
3. define std'patterns'*.

1. symbol Program =>

[

   // 1. Create
   #var aMap := Dictionary.
   (aMap @ "key") set &content:"foo".
   (aMap @ "key2") set &content:"foo3".
   (aMap @ "key3") set &content:"foo3".

   (aMap enumerator)~foreach run: anItem =>
   [
       'program'Output << anItem dictionary_key << " : " << anItem content << "%n".
   ].

   // only values
   Scan::aMap run: aValue => ('program'Output << avalue << "%n").

]. </lang>

Factor

<lang factor>H{ { "hi" "there" } { "a" "b" } } [ ": " glue print ] assoc-each</lang> There's also assoc-map, assoc-find, assoc-filter and many more.

Fantom

Given a map, each iterates over pairs of values-keys. keys and vals retrieve a list of keys or values, respectively.

<lang fantom> class Main {

 public static Void main ()
 {
   Int:Str map := [1:"alpha", 2:"beta", 3:"gamma"]

   map.keys.each |Int key|
   {
     echo ("Key is: $key")
   }

   map.vals.each |Str value|
   {
     echo ("Value is: $value")
   }

   map.each |Str value, Int key|
   {
     echo ("Key $key maps to $value")
   }
 }

} </lang>

Forth

Library: Forth Foundation Library

<lang forth>include ffl/hct.fs include ffl/hci.fs

\ Create hashtable and iterator in dictionary 10 hct-create htable htable hci-create hiter

\ Insert entries 1 s" hello" htable hct-insert 2 s" world" htable hct-insert 3 s" !" htable hct-insert

iterate

 hiter hci-first
 BEGIN
 WHILE
   ." key = " hiter hci-key type ." , value = " . cr
   hiter hci-next
 REPEAT

iterate</lang>

F#

<lang fsharp>let myMap = Map.ofList [ ("Hello", 1); ("World", 2); ("!", 3)]

for KeyValue(k, v) in myMap do

 printfn "%s -> %d" k v</lang>

Go

<lang go>myMap := map[string]int { "hello": 13, "world": 31, "!"  : 71 }

// iterating over key-value pairs: for key, value := range myMap {

   fmt.Printf("key = %s, value = %d\n", key, value)

}

// iterating over keys: for key := range myMap {

   fmt.Printf("key = %s\n", key)

}

// iterating over values: for _, value := range myMap {

   fmt.Printf("value = %d\n", value)

}</lang>

Groovy

Solution: <lang groovy>def map = [lastName: "Anderson", firstName: "Thomas", nickname: "Neo", age: 24, address: "everywhere"]

println "Entries:" map.each { println it }

println() println "Keys:" map.keySet().each { println it }

println() println "Values:" map.values().each { println it }</lang>

Output:

Entries:
lastName=Anderson
firstName=Thomas
nickname=Neo
age=24
address=everywhere

Keys:
lastName
firstName
nickname
age
address

Values:
Anderson
Thomas
Neo
24
everywhere

Haskell

with Data.Map: <lang haskell>import qualified Data.Map as M

myMap = M.fromList [("hello", 13), ("world", 31), ("!", 71)]

main = do -- pairs

         print $ M.toList myMap
         -- keys
         print $ M.keys myMap
         -- values
         print $ M.elems myMap</lang>

Icon and Unicon

<lang icon>procedure main()

   t := table()
   every t[a := !"ABCDE"] := map(a)

   every pair := !sort(t) do
       write("\t",pair[1]," -> ",pair[2])

   writes("Keys:")
   every writes(" ",key(t))
   write()

   writes("Values:")
   every writes(" ",!t)
   write()

end</lang>

Sample output:

->aai
        A -> a
        B -> b
        C -> c
        D -> d
        E -> e
Keys: C E B D A
Values: c e b d a

J

Note that all J operations either iterate over the items of an array or can be made to do so. So to iterate over some sequence you need to refer to that sequence.

Using the J example from Creating an Associative Array...

Keys <lang J>nl__example 0</lang>

Values <lang J>get__example each nl__example 0</lang>

Both keys and values <lang J>(,&< get__example) each nl__example 0</lang>

Note that this last is not likely to be useful in any practical context outside of learning the language.

Java

<lang java>Map<String, Integer> myDict = new HashMap<String, Integer>(); myDict.put("hello", 1); myDict.put("world", 2); myDict.put("!", 3);

// iterating over key-value pairs: for (Map.Entry<String, Integer> e : myDict.entrySet()) {

   String key = e.getKey();
   Integer value = e.getValue();
   System.out.println("key = " + key + ", value = " + value);

}

// iterating over keys: for (String key : myDict.keySet()) {

   System.out.println("key = " + key);

}

// iterating over values: for (Integer value : myDict.values()) {

   System.out.println("value = " + value);

}</lang>

JavaScript

JavaScript does not have associative arrays. You can add properties to an empty object, and that works basically the same way: <lang javascript>var myhash = {}; // a new, empty object myhash["hello"] = 3; myhash.world = 6; // obj.name is equivalent to obj["name"] for certain values of name myhash["!"] = 9;

var output = , // initialise as string

   key;

for (key in myhash) {

   if (myhash.hasOwnProperty(key)) {
       output += "key is: " + key;
       output += " => ";
       output += "value is: " + myhash[key];  // cannot use myhash.key, that would be myhash["key"]
       output += "\n";
   }

}</lang>

To iterate over values in JavaScript 1.6+: <lang javascript>var myhash = {}; // a new, empty object myhash["hello"] = 3; myhash.world = 6; // obj.name is equivalent to obj["name"] for certain values of name myhash["!"] = 9;

var output = , // initialise as string

   val;

for (val in myhash) {

   if (myhash.hasOwnProperty(val)) {
       output += "myhash['" + val + "'] is: " + myhash[val];
       output += "\n";
   }

}</lang>

K

Creating a dictionary. <lang K> d: .((`"hello";1); (`"world";2);(`"!";3))</lang>

The keys are available via "!". <lang K> !d `hello `world `"!"

  $!d  / convert keys (symbols) as strings

("hello"

"world"
,"!")</lang>

Print the key value pairs. <lang K> `0:{,/$x,": ",d[x]}'!d hello: 1 world: 2 !: 3</lang>

The values are available via "[]". <lang K> d[] 1 2 3

 {x+1}'d[]

2 3 4</lang>

Liberty BASIC

Needs the sublist library from http://basic.wikispaces.com/SubList+Library since LB does not have built-in associative arrays. <lang lb> data "red", "255 50 50", "green", "50 255 50", "blue", "50 50 255" data "my fave", "220 120 120", "black", "0 0 0"

myAssocList$ =""

for i =1 to 5

   read k$
   read dat$
   call sl.Set myAssocList$, k$, dat$

next i

keys$ = "" ' List to hold the keys in myList$. keys = 0

keys = sl.Keys( myAssocList$, keys$) print " Number of key-data pairs ="; keys

For i = 1 To keys

   keyName$ = sl.Get$( keys$, Str$( i))
   Print "  Key "; i; ":", keyName$, "Data: ", sl.Get$( myAssocList$, keyName$)

Next i

end </lang>

 Number of key-data pairs =5
 Key 1:      red           Data:         255 50 50
 Key 2:      green         Data:         50 255 50
 Key 3:      blue          Data:         50 50 255
 Key 4:      my fave       Data:         220 120 120
 Key 5:      black         Data:         0 0 0

Lua

<lang lua>local table = {

   ["foo"] = "bar",
   ["baz"] = 6,
   42 = 7,

} for key,val in pairs(table) do

   print(string.format("%s: %s\n", key, val)

end</lang>

M4

<lang M4>divert(-1) define(`for',

  `ifelse($#,0,``$0,
  `ifelse(eval($2<=$3),1,
  `pushdef(`$1',$2)$4`'popdef(`$1')$0(`$1',incr($2),$3,`$4')')')')

define(`new',`define(`$1[size]key',0)') define(`asize',`defn(`$1[size]key')') define(`aget',`defn(`$1[$2]')') define(`akget',`defn(`$1[$2]key')') define(`avget',`aget($1,akget($1,$2))') define(`aset',

  `ifdef($1[$2],
     `',
     `define(`$1[size]key',incr(asize(`$1')))`'define($1[asize(`$1')]key,$2)')`'define($1[$2],$3)')

define(`dquote', ``$@) define(`akeyvalue',`dquote(akget($1,$2),aget($1,akget($1,$2)))') define(`akey',`dquote(akget($1,$2))') define(`avalue',`dquote(aget($1,akget($1,$2)))') divert new(`a') aset(`a',`wow',5) aset(`a',`wow',flame) aset(`a',`bow',7) key-value pairs for(`x',1,asize(`a'),

  `akeyvalue(`a',x)

') keys for(`x',1,asize(`a'),

  `akey(`a',x)

') values for(`x',1,asize(`a'),

  `avalue(`a',x)

')</lang>

Output:

key-value pairs
`wow',`flame'
`bow',`7'

keys
`wow'
`bow'

values
`flame'
`7'

Mathematica

<lang Mathematica>keys=DownValues[#,Sort->False]All,1,1,1&; hashes=#/@keys[#]&;

a[2]="string";a["sometext"]=23; keys[a] ->{2,sometext} hashes[a] ->{string,23}</lang>

NetRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref savelog symbols

surname = 'Unknown' -- default value surname['Fred'] = 'Bloggs' surname['Davy'] = 'Jones'

try = 'Fred' say surname[try] surname['Bert']

-- extract the keys loop fn over surname

 say fn.right(10) ':' surname[fn]
 end fn

</lang>

Objective-C

Works with: Objective-C version 2.0+

<lang objc>NSDictionary *myDict = [NSDictionary dictionaryWithObjectsAndKeys:

                       [NSNumber numberWithInt:13], @"hello",
                       [NSNumber numberWithInt:31], @"world",
                       [NSNumber numberWithInt:71], @"!", nil];

// iterating over keys: for (id key in myDict) {

   NSLog(@"key = %@", key);

}

// iterating over values: for (id value in [myDict objectEnumerator]) {

   NSLog(@"value = %@", value);

}</lang>

Works with: Objective-C version <2.0

<lang objc>NSDictionary *myDict = [NSDictionary dictionaryWithObjectsAndKeys:

                       [NSNumber numberWithInt:13], @"hello",
                       [NSNumber numberWithInt:31], @"world",
                       [NSNumber numberWithInt:71], @"!", nil];

// iterating over keys: NSEnumerator *enm = [myDict keyEnumerator]; id key; while ((key = [enm nextObject])) {

   NSLog(@"key = %@", key);

}

// iterating over values: enm = [myDict objectEnumerator]; id value; while ((value = [enm nextObject])) {

   NSLog(@"value = %@", value);

}</lang>

Works with: Cocoa version Mac OS X 10.6+

<lang objc>NSDictionary *myDict = [NSDictionary dictionaryWithObjectsAndKeys:

                       [NSNumber numberWithInt:13], @"hello",
                       [NSNumber numberWithInt:31], @"world",
                       [NSNumber numberWithInt:71], @"!", nil];

// iterating over keys and values: [myDict enumerateKeysAndObjectsUsingBlock: ^(id key, id value, BOOL *stop) {

   NSLog(@"key = %@, value = %@", key, value);

}];</lang>

OCaml

Association list: <lang ocaml>#!/usr/bin/env ocaml

let map = [| ('A', 1); ('B', 2); ('C', 3) |] ;;

(* iterate over pairs *) Array.iter (fun (k,v) -> Printf.printf "key: %c - value: %d\n" k v) map ;;

(* iterate over keys *) Array.iter (fun (k,_) -> Printf.printf "key: %c\n" k) map ;;

(* iterate over values *) Array.iter (fun (_,v) -> Printf.printf "value: %d\n" v) map ;;

(* in functional programming it is often more useful to fold over the elements *) Array.fold_left (fun acc (k,v) -> acc ^ Printf.sprintf "key: %c - value: %d\n" k v) "Elements:\n" map ;;</lang>

Hash table: <lang ocaml>let map = Hashtbl.create 42;; Hashtbl.add map 'A' 1;; Hashtbl.add map 'B' 2;; Hashtbl.add map 'C' 3;;

(* iterate over pairs *) Hashtbl.iter (fun k v -> Printf.printf "key: %c - value: %d\n" k v) map ;;

(* in functional programming it is often more useful to fold over the elements *) Hashtbl.fold (fun k v acc -> acc ^ Printf.sprintf "key: %c - value: %d\n" k v) map "Elements:\n" ;;</lang>

Functional binary search tree: <lang ocaml>module CharMap = Map.Make (Char);; let map = CharMap.empty;; let map = CharMap.add 'A' 1 map;; let map = CharMap.add 'B' 2 map;; let map = CharMap.add 'C' 3 map;;

(* iterate over pairs *) CharMap.iter (fun k v -> Printf.printf "key: %c - value: %d\n" k v) map ;;

(* in functional programming it is often more useful to fold over the elements *) CharMap.fold (fun k v acc -> acc ^ Printf.sprintf "key: %c - value: %d\n" k v) map "Elements:\n" ;;</lang>

Oz

<lang oz>declare

 MyMap = unit('hello':13 'world':31 '!':71)

in

 {ForAll {Record.toListInd MyMap} Show}  %% pairs
 {ForAll {Record.arity     MyMap} Show}  %% keys
 {ForAll {Record.toList    MyMap} Show}  %% values</lang>

Perl

<lang perl>#! /usr/bin/perl use strict;

my %pairs = ( "hello" => 13, "world" => 31, "!" => 71 );

1. iterate over pairs

1. Be careful when using each(), however, because it uses a global iterator
2. associated with the hash. If you call keys() or values() on the hash in the
3. middle of the loop, the each() iterator will be reset to the beginning. If
4. you call each() on the hash somewhere in the middle of the loop, it will
5. skip over elements for the "outer" each(). Only use each() if you are sure
6. that the code inside the loop will not call keys(), values(), or each().

while ( my ($k, $v) = each %pairs) {

   print "(k,v) = ($k, $v)\n";

}

1. iterate over keys

foreach my $key ( keys %pairs ) {

   print "key = $key, value = $pairs{$key}\n";

}

1. or (see note about each() above)

while ( my $key = each %pairs) {

   print "key = $key, value = $pairs{$key}\n";

}

1. iterate over values

foreach my $val ( values %pairs ) {

   print "value = $val\n";

}</lang>

Perl 6

Works with: Rakudo version #21 "Seattle"

<lang perl6>my %pairs = hello => 13, world => 31, '!' => 71;

for %pairs.kv -> $k, $v {

   say "(k,v) = ($k, $v)";

}

say "key = $_" for %pairs.keys;

say "value = $_" for %pairs.values;</lang>

PHP

<lang php><?php $pairs = array( "hello" => 1, "world" => 2, "!" => 3 );

// iterate over key-value pairs foreach($pairs as $k => $v) {

 echo "(k,v) = ($k, $v)\n";

}

// iterate over keys foreach(array_keys($pairs) as $key) {

 echo "key = $key, value = $pairs[$key]\n";

}

// iterate over values foreach($pairs as $value) {

 echo "values = $value\n";

} ?></lang>

PicoLisp

Using properties

<lang PicoLisp>(put 'A 'foo 5) (put 'A 'bar 10) (put 'A 'baz 15)

(getl 'A) # Get the whole property list

-> ((15 . baz) (10 . bar) (5 . foo))

(mapcar cdr (getl 'A)) # Get all keys

-> (baz bar foo)

(mapcar car (getl 'A)) # Get all values

-> (15 10 5)</lang>

Using an index tree

<lang PicoLisp>(idx 'A (def "foo" 5) T) (idx 'A (def "bar" 10) T) (idx 'A (def "baz" 15) T)

A # Get the whole tree

-> ("foo" ("bar" NIL "baz"))

(idx 'A) # Get all keys

-> ("bar" "baz" "foo")

(mapcar val (idx 'A)) # Get all values

-> (10 15 5)</lang>

Pike

note that the order is not alphabetic but depends on the hash value of the keys. the order is deterministic however.

<lang Pike> mapping(string:string) m = ([ "A":"a", "B":"b", "C":"c" ]); foreach(m; string key; string value) {

   write(key+value);

} Result: BbAaCc

// only keys foreach(m; string key;) {

   write(key);

} Result: BAC

// only values foreach(m;; string value) {

   write(value);

} Result: bac

</lang>

PureBasic

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

<lang python>NewMap dict.s() dict("de") = "German" dict("en") = "English" dict("fr") = "French"

ForEach dict()

 Debug MapKey(dict()) + ":" + dict()

Next</lang>

Python

<lang python>myDict = { "hello": 13, "world": 31, "!"  : 71 }

1. iterating over key-value pairs:

for key, value in myDict.items():

   print ("key = %s, value = %s" % (key, value))

1. iterating over keys:

for key in myDict:

   print ("key = %s" % key)

1. (is a shortcut for:)

for key in myDict.keys():

   print ("key = %s" % key)

1. iterating over values:

for value in myDict.values():

   print ("value = %s" % value)</lang>

PostScript

<lang postscript> % over keys and values <</a 1 /b 2 /c 3>> {= =} forall % just keys <</a 1 /b 2 /c 3>> {= } forall % just values <</a 1 /b 2 /c 3>> {pop =} forall </lang>

PowerShell

Using the following hash table: <lang powershell>$h = @{ 'a' = 1; 'b' = 2; 'c' = 3 }</lang> Iterating over the key/value pairs is slightly cumbersome as it requires an explicit call to GetEnumerator: <lang powershell>$h.GetEnumerator() | ForEach-Object { Write-Host Key: $_.Name, Value: $_.Value }</lang> A foreach statement can also be used: <lang powershell>foreach ($e in $h.GetEnumerator()) {

   Write-Host Key: $e.Name, Value: $e.Value

}</lang> Iterating over the keys: <lang powershell>$h.Keys | ForEach-Object { Write-Host Key: $_ }

foreach ($k in $h.Keys) {

   Write-Host Key: $k

}</lang> Iterating over the values: <lang powershell>$h.Values | ForEach-Object { Write-Host Value: $_ }

foreach ($v in $h.Values) {

   Write-Host Value: $v

}</lang>

R

R does not have a built-in concept of key-value pairs, however vectors can have named elements, which is close. <lang r>x <- c(hello=1, world=2, "!"=3) print(x)</lang>

hello world     ! 
    1     2     3

<lang r>print(names(x))</lang>

"hello" "world" "!"

<lang r>print(unname(x))</lang>

1 2 3

RLaB

Associative arrays are called lists in RLaB.

<lang RLaB> x = <<>>; // create an empty list x.hello = 1; x.world = 2; x.["!"] = 3;

// to iterate over identifiers of a list one needs to use the function members // the identifiers are returned as a lexicographically ordered string row-vector // here ["!", "hello", "world"] for(i in members(x)) { printf("%s %g\n", i, x.[i]); }

// occasionally one needs to check if there exists member of a list y = members(x); // y contains ["!", "hello", "world"] clear(x.["!"]); // remove member with identifier "!" from the list "x" for(i in y) { printf("%s %g\n", i, x.[i]); } // this produces error because x.["!"] does not exist

for(i in y) {

 if (exist(x.[i]))
 { printf("%s %g\n", i,  x.[i]); }  // we print a member of the list "x" only if it exists

}

</lang>

Ruby

<lang ruby>myDict = { "hello" => 13, "world" => 31, "!" => 71 }

1. iterating over key-value pairs:

myDict.each {|key, value| puts "key = #{key}, value = #{value}"}

1. or

myDict.each_pair {|key, value| puts "key = #{key}, value = #{value}"}

1. iterating over keys:

myDict.each_key {|key| puts "key = #{key}"}

1. iterating over values:

myDict.each_value {|value| puts "value =#{value}"}</lang>

Scala

<lang Scala>val m=Map("Hello"->13, "world"->31, "!"->71)

println("Keys:") m.keys foreach println

println("\nValues:") m.values foreach println

println("\nPairs:") m foreach println

println("\nKey->Value:") for((k,v)<-m) println(k+"->"+v)</lang>

Scheme

Works with: Racket

(moved from Racket)

Using the dictionary interface, different data structures can be treated as an associative array in Racket.

<lang scheme>#lang racket

(define dict1 #hash((apple . 5) (orange . 10))) ; hash table (define dict2 '((apple . 5) (orange . 10)))  ; a-list (define dict3 (vector "a" "b" "c"))  ; vector (integer keys)

(dict-keys dict1)  ; => '(orange apple) (dict-values dict2)  ; => '(5 10) (for/list ([(k v) (in-dict dict3)]) ; => '("0 -> a" "1 -> b" "2 -> c")

 (format "~a -> ~a" k v))

</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const type: dictType is hash [string] integer; var dictType: myDict is dictType.value;

const proc: main is func

 local
   var string: stri is "";
   var integer: number is 0;
 begin
   myDict @:= ["hello"] 1;
   myDict @:= ["world"] 2;
   myDict @:= ["!"] 3;

   # iterating over key-value pairs:
   for number key stri range myDict do
     writeln("key = " <& number <& ", value = " <& stri);
   end for;

   # iterating over keys:
   for key stri range myDict do
     writeln("key = " <& stri);
   end for;

   # iterating over values:
   for number range myDict do
     writeln("value = " <& number);
   end for;
 end func;</lang>

Output:

key = 3, value = !
key = 1, value = hello
key = 2, value = world
key = !
key = hello
key = world
value = 3
value = 1
value = 2

Slate

In Slate, all associative mappings inherit from Mapping, so they all have the same protocol. Even Sequences obey it, in addition to their own protocol for collections with ordered integer-range keys. <lang slate>define: #pairs -> ({'hello' -> 1. 'world' -> 2. '!' -> 3. 'another!' -> 3} as: Dictionary). pairs keysAndValuesDo: [| :key :value |

 inform: '(k, v) = (' ; key printString ; ', ' ; value printString ; ')'

].

pairs keysDo: [| :key |

 inform: '(k, v) = (' ; key printString ; ', ' ; (pairs at: key) printString ; ')'

].

pairs do: [| :value |

 inform: 'value = ' ; value printString

].</lang>

Smalltalk

Works with: GNU Smalltalk

<lang smalltalk>|pairs| pairs := Dictionary from: { 'hello' -> 1. 'world' -> 2. '!' -> 3. 'another!' -> 3 }.

"iterate over keys and values" pairs keysAndValuesDo: [ :k :v |

   ('(k, v) = (%1, %2)' % { k. v }) displayNl

].

"iterate over keys" pairs keysDo: [ :key |

   ('key = %1, value = %2' % { key. pairs at: key }) displayNl

].

"iterate over values" pairs do: [ :value |

   ('value = %1' % { value }) displayNl

].</lang>

We could also obtain a set of keys or a collection of values and iterate over them with "do:":

<lang smalltalk>(pairs keys) do: [ :k | "..." ]. (pairs values) do: [ :v | "..." ].</lang>

SNOBOL4

Works with: Macro Spitbol

Works with: Snobol4+

Works with: CSnobol

<lang SNOBOL4>* # Create sample table

       t = table()
       t<'cat'> = 'meow'
       t<'dog'> = 'woof'
       t<'pig'> = 'oink'

• # Convert table to key/value array

       a = convert(t,'array')

• # Iterate pairs

ploop i = i + 1; output = a<i,1> ' -> ' a<i,2> :s(ploop)

• # Iterate keys

kloop j = j + 1; output = a<j,1> :s(kloop)

• # Iterate vals

vloop k = k + 1; output = a<k,2> :s(vloop) end</lang>

Tcl

With Arrays

<lang tcl>array set myAry {

   # list items here...

}

1. Iterate over keys and values

foreach {key value} [array get myAry] {

   puts "$key -> $value"

}

1. Iterate over just keys

foreach key [array names myAry] {

   puts "key = $key"

}

1. There is nothing for directly iterating over just the values
2. Use the keys+values version and ignore the keys</lang>

With Dictionaries

Works with: Tcl version 8.5

<lang tcl>set myDict [dict create ...]; # Make the dictionary

1. Iterate over keys and values

dict for {key value} $myDict {

   puts "$key -> $value"

}

1. Iterate over keys

foreach key [dict keys $myDict] {

   puts "key = $key"

}

1. Iterate over values

foreach value [dict values $myDict] {

   puts "value = $value"

}</lang>

TXR

<lang txr> @(do (defvar *h* (make-hash nil nil nil))

    (mapcar (lambda (k v)
              (set (gethash *h* k nil) v))
            '(a b c)
            '(1 2 3))
    (dohash (k v *h*)
      (format t "~a -> ~a\n" k v)))</lang>

$ txr hash.txr 
c -> 3
b -> 2
a -> 1

UNIX Shell

Two shells have associative arrays, but they use different syntax to access their keys.

Works with: ksh93

<lang bash>a=([key1]=value1 [key2]=value2)

1. just keys

printf '%s\n' "${!a[@]}"

1. just values

printf '%s\n' "${a[@]}"

1. keys and values

for key in "${!a[@]}"; do printf '%s => %s\n' "$key" "${a[$key]}" done</lang>

Works with: zsh

<lang bash>typeset -A a a=(key1 value1 key2 value2)

1. just keys

print -l -- ${(k)a}

1. just values

print -l -- ${(v)a}

1. keys and values

printf '%s => %s\n' ${(kv)a}</lang>

Vala

Library: Gee

<lang vala> using Gee;

void main(){

   // declare HashMap                                                          
   var map = new HashMap<string, double?>();

   // set 3 entries                                                            
   map["pi"] = 3.14;
   map["e"] = 2.72;
   map["golden"] = 1.62;

   // iterate over (key,value) pair                                            
   foreach (var elem in map.entries){
       string name = elem.key;
       double num = elem.value;

stdout.printf("%s,%f\n", name, num);

   }

   // iterate over keys                                                        
   foreach (string key in map.keys){

stdout.printf("%s\n", key);

   }

   // iterate over values                                                      
   foreach (double num in map.values){

stdout.printf("%f\n", num);

   }

} </lang>

Compile with flag:

--pkg gee-1.0

Output:

e,2.720000
golden,1.620000
pi,3.140000
e
golden
pi
2.720000
1.620000
3.140000