Associative array/Iteration: Difference between revisions

 

Also show how to iterate just over the keys, or the values, if there is a separate way to do that in your language.

 

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

 

L(key, value) d

 

L(value) d.values()

{{out}}

<pre>

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

Iterating key,value pairs uses "m:each":

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

( swap . space . cr )

m:each

{{out}}<pre>

one 1

 

Iterating the keys uses "m:keys":

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

( . cr )

a:each

{{out}}<pre>

one

 

=={{header|Ada}}==

with Ada.Containers.Indefinite_Ordered_Maps;

 

Index := Next (Index);

end loop;

{{out}}

<pre>

 

=={{header|Aime}}==

text s;

 

o_form("key ~, value ~ (~)\n", s, r[s], r_type(r, s));

} while (rsk_greater(r, s, s));

{{out}}

<pre>key A, value 33 (integer)

<br>

This sample defines a simple hash-based implementation with operators to iterate over the array.

 

# the modes allowed as associative array element values - change to suit #

e := NEXT a1

OD

{{out}}

<pre>

=={{header|Arturo}}==

 

d: #[

name: "john"

loop values d [v][

print ["value =" v]

 

{{out}}

 

=={{header|ATS}}==

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

obj := Object("red", 0xFF0000, "blue", 0x0000FF, "green", 0x00FF00)

enum := obj._NewEnum()

While enum[key, value]

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

 

=={{header|AWK}}==

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

a["hello"] = 1

a["world"] = 2

print key, a[key]

}

 

As AWK was often used in (Bourne) shell scripts,

sorting was done by a pipe of two awk programs and the sort command.

Today, 'gawk' allows to set the order of iteration:

a["hello"] = 1

a["world"] = 2

print key, a[key]

}

 

=={{header|Babel}}==

In Babel, associative arrays are referred to as maps. To create a map from a list-of-lists:

 

 

To iterate over a map, in the primary sense, use the overmap utility. We will copy the map (cp operator) so as not to modify the original:

 

 

To see the results, use the valmap operator:

 

 

{{out}}

There are many ways to interact with a map in Babel. Most of these begin by converting the map to a list or list-of-lists. To look up a list of specific values from the map, by key, use the lumapls utility:

 

 

{{out}}

To convert the entire map back to a list of key-value pairs:

 

 

To view the list:

 

 

{{out}}

To merge two maps together, use the mapmerge utility:

 

 

To view the results:

 

 

{{out}}

For more information on maps in Babel, view [https://github.com/claytonkb/clean_babel/blob/master/std.sp std.sp] (see the section titled "map utilities").

 

 

associative("abc") = "first three"

FOR i = 0 TO amount - 1

PRINT keys$[i], ":", associative(keys$[i])

 

{{out}}

LOOKUP creates a numerically indexed array of the keys of the associative array, with the number of elements stored in the field following the SIZE keyword.

 

''Solution is at [[Associative_array/Creation#BASIC256]]''.

 

PROCputdict(mydict$, "FF0000", "red")

PROCputdict(mydict$, "00FF00", "green")

key$ = MID$(dict$, J%+1, K%-J%-1)

IF K% >= LEN(dict$) THEN K% = 0

 

=={{header|Bracmat}}==

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

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

& put$\n

)

{{out}}

<pre>key: meat

 

=={{header|Brat}}==

 

#Iterate over key, value pairs

h.each_value { v |

p "Value: #{v}"

 

=={{header|C}}==

 

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

using System.Collections.Generic;

 

}

}

 

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

{{works with|C++11}}

#include <map>

#include <string>

 

return 0;

 

 

Pre C++11:

myDict["hello"] = 1;

myDict["world"] = 2;

int& value = it->second;

std::cout << "key = " << key << ", value = " << value << std::endl;

 

=={{header|Ceylon}}==

 

value myMap = map {

}

 

=={{header|Chapel}}==

 

 

for k in A.domain do

 

for (k,v) in zip(A.domain, A) do

 

{{out}}

 

=={{header|Clojure}}==

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

(println k "=" v))

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

(println v))

 

=={{header|CoffeeScript}}==

a: 'one'

b: 'two'

for key of hash

console.log key

 

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

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

 

(dolist (pair alist)

(destructuring-bind (key . value) pair

;; iterate and destructure with loop

(loop for (key . value) in alist

 

===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 <code>loop</code>'s destructuring makes things a bit easier.

 

 

===With hash tables===

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

 

(format t "~&Key: ~a, Value: ~a." key value))

 

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

 

 

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

 

(loop

(multiple-value-bind (nextp key value) (next-entry)

(if (not nextp)

(return)

===Alternate solution===

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

 

;; Project : Associative array/Iteration

 

(format t "~a" " : ")

(format t "~a" (aref x n 1)))

Output:

<pre>

 

=={{header|Crystal}}==

 

dict.each { |pair|

dict.each_value { |value|

puts value

 

{{out}}

{{works with|D|2}}

 

 

void main() {

foreach (value; aa.values)

writeln("7) Got value ", value);

 

=={{header|Dao}}==

dict = { 'def' => 1, 'abc' => 2 }

 

io.writeln( key, value )

}

 

=={{header|Dart}}==

main(){

var fruits = {

fruits.values.forEach( ( value ) => print( value ) );

}

{{out}}

<pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lDictionary.Free;

end;

 

=={{header|Dyalect}}==

 

 

for x in t.Keys() {

print("\(x)=\(t[x])")

 

{{out}}

The <code>for</code> 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 (<code>_</code>).

 

"a" => 1,

"b" => 2,

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

println(`$key .`)

 

=={{header|EchoLisp}}==

(lib 'hash) ;; load hash.lib

(define H (make-hash))

value-> 666

value-> 33

 

=={{header|Elena}}==

ELENA 5.0 :

import system'routines;

import extensions;

map.forEach:

(keyValue){ console.printLine(keyValue.Key," : ",keyValue.Value) }

 

=== Strong typed dictionary ===

import system'routines;

import extensions;

map.forEach:

(tuple){ console.printLine(tuple.Item1," : ",tuple.Item2) }

 

=={{header|Elixir}}==

Enum.each(d, fn kv -> IO.inspect kv end)

Enum.each(d, fn {k,v} -> IO.puts "#{inspect k} => #{v}" end)

Enum.each(Map.keys(d), fn key -> IO.inspect key end)

 

{{out}}

3

1

</pre>

 

=={{header|Erlang}}==

-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#}}==

Iterating over both.

let myMap = [ ("Hello", 1); ("World", 2); ("!", 3) ]

 

for k, v in myMap do

printfn "%s -> %d" k v

 

Iterating over either keys or values only can be achieved through use of the _ wildcard token.

// Only prints the keys.

for k, _ in myMap do

for _, v in myMap do

printfn "%d" v

 

=={{header|Factor}}==

<code>assoc-each</code> places both the key and the value on top of the data stack. A simple <code>drop</code> or <code>nip</code> enables iterating over only keys or values.

There's also <code>assoc-map</code>, <code>assoc-find</code>, <code>assoc-filter</code> and many more.

 

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

 

class Main

{

}

}

 

=={{header|Forth}}==

{{libheader|Forth Foundation Library}}

 

include ffl/hci.fs

 

;

 

 

\ Written in ANS-Forth; tested under VFX.

\ Requires the novice package: http://www.forth.org/novice.html

 

some-languages kill-association

{{out}}

<pre style="height:30ex;overflow:scroll">

Since this data structure stores the keys and values together it makes little sense to iterate through the same array three times to print different parts of it, hence I will only print the key:value pairs.

 

 

function get_dict_data_string( d as dicitem ) as string

for i as uinteger = 0 to ubound(Dictionary)

print_keyval_pair(Dictionary(i))

 

{{out}}

 

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

{$mode delphi}{$ifdef windows}{$apptype console}{$endif}

uses Generics.Collections;

lDictionary.Free;

end;

<pre>

Pair: foo = 6

 

=={{header|Frink}}==

for [key, value] = d

println["$key\t$value"]

for key = keys[d]

println["$key"]

 

{{out}}

1

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=e48bd6ed7e6b583106b8178bca536eea Click this link to run this code]'''

Dim cList As Collection = ["2": "quick", "4": "fox", "1": "The", "9": "dog", "7": "the", "5": "jumped", "3": "brown", "6": "over", "8": "lazy"]

Dim siCount As Short

Next

 

Output:

<pre>

=={{header|Go}}==

'''Language:'''

"hello": 13,

"world": 31,

for _, value := range myMap {

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

'''Standard library templates:'''

 

* In a template, if map keys are a comparable basic type, then iteration proceeds in key order. With the language for/range, iteration is in non-deterministic order.

 

 

import (

{{end -}}

`)).Execute(os.Stdout, m)

{{out}}

Note order by key.

=={{header|Groovy}}==

Solution:

 

println "Entries:"

println()

println "Values:"

 

{{out}}

 

=={{header|Harbour}}==

LOCAL x

 

// or value only

? x

 

=={{header|Haskell}}==

with Data.Map:

 

myMap :: M.Map String Int

, show . M.elems -- Values

] <*>

{{Out}}

<pre>[("!",71),("hello",13),("world",31)]

 

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

t := table()

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

every writes(" ",!t)

write()

 

{{out}}

 

=={{header|Io}}==

"hello", 13,

"world", 31,

myDict values foreach( value,

writeln("value = ", value)

 

=={{header|J}}==

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

 

 

 

 

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

 

 

}

 

 

Java 8 version

 

map.put("hello", 1);

map.put("world", 2);

 

// iterating over values:

 

{{out}}

=={{header|JavaScript}}==

JavaScript does not have associative arrays until ECMAScript 6 brings Maps. In versions up to ES5.1, you may add properties to an empty object to achieve the same effect.

myhash["hello"] = 3;

myhash.world = 6; //obj.name is equivalent to obj["name"] for certain values of name

keys.map(function (key) {

console.log("Key is: " + key + '. Value is: ' + myhash[key]);

 

=={{header|Jq}}==

 

In jq > 1.4, keys_unsorted, for producing an array of the keys (in the order of creation), is also available.

 

# Iterating over the keys

# ["world",31]

# ["!",71]

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

# applying a function to key-value pairs:

@show value

end

 

{{out}}

=={{header|K}}==

Creating a dictionary.

 

The keys are available via "!".

`hello `world `"!"

 

("hello"

"world"

 

Print the key value pairs.

hello: 1

world: 2

 

The values are available via "[]".

1 2 3

 

{x+1}'d[]

 

=={{header|Kotlin}}==

val map = mapOf("hello" to 1, "world" to 2, "!" to 3)

 

with(map) {

keys.forEach { println("key = $it") }

values.forEach { println("value = $it") }

}

{{Out}}

<pre>key = hello, value = 1

 

=={{header|Lang5}}==

: say(*) dup first " => " 2 compress "" join . second . ;

 

 

=={{header|Lasso}}==

//iterate over associative array

//Lasso maps

//the {^ ^} indicates that output should be printed (AutoCollect) ,

// if output is not desired, just { } is used

 

=={{header|LFE}}==

 

===Keys and Values===

(let ((data '(#(key1 "foo") #(key2 "bar")))

(hash (: dict from_list data)))

0

hash))

 

===Just Keys===

(let ((data '(#(key1 "foo") #(key2 "bar")))

(hash (: dict from_list data)))

(: io format '"~s~n" (list key)))

(: dict fetch_keys hash)))

 

=={{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"

 

end

Number of key-data pairs =5

Key 1: red Data: 255 50 50

 

=={{header|Lingo}}==

 

-- iterate over key-value pairs

repeat with val in hash

put val

 

=={{header|LiveCode}}==

put 5 into fruit["pears"]

put 6 into fruit["oranges"]

-- alternatively, use same loop as for values 1 with tkey && fruit[tKey]

 

Output

apples

pears

bananas:none

oranges:6

 

=={{header|Lua}}==

["foo"] = "bar",

["baz"] = 6,

for key,val in pairs(t) do

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

 

{{out}}

 

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

Module checkit {

\\ Inventories are objects with keys and values, or keys (used as read only values)

}

Checkit

 

=={{header|M4}}==

define(`for',

`ifelse($#,0,``$0'',

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

`avalue(`a',x)

 

{{out}}

=={{header|Maple}}==

Iterate through indices when indices are all simple expressions:

> T := table( [ "A" = 1, "B" = 2, "C" = 3, "D" = 4 ] );

> for i in indices( T, nolist ) do print(i ) end:

 

"D"

 

Iterate through indices when indices may be expression sequences:

> T := table( [ "a" = 1, "b" = 2, ("c","d") = 3 ] ):

> for i in indices( T ) do print( i, T[ op( i ) ] ) end:

 

["c", "d"], 3

 

Return all index / entry pairs as equations:

> for i in indices( T, pairs ) do print( i) end:

"a" = 1

 

("c", "d") = 3

 

> for i in entries( T ) do print( i) end:

[1]

 

[2]

 

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

hashes=#/@keys[#]&;

 

->{2,sometext}

hashes[a]

 

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

Associative arrays can be defined as structs in Matlab and Octave.

 

for k=1:length(keys),

key = keys{k};

value = getfield(hash,key); % get value of key

hash = setfield(hash,key,-value); % set value of key

 

or

 

for k=1:length(keys),

key = keys{k};

value = hash.(key); % get value of key

hash.(key) = -value; % set value of key

 

=={{header|Maxima}}==

h[9]: 2$

 

for key in rest(arrayinfo(h), 2) do (

val: arrayapply(h, key),

 

=={{header|MiniScript}}==

 

for keyVal in d

for val in d.values

print val

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols

 

loop fn over surname

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

 

=={{header|NewLISP}}==

(setq alist '(("A" "a") ("B" "b") ("C" "c")))

 

;; loop over the assocation list:

(dolist (elem alist)

 

=={{header|Nim}}==

import tables

 

for k,v in t.pairs:

echo "at[" & $k & "]=" & v

{{out}}

<pre>

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

{{works with|oo2c Version 2}}

MODULE AssociativeArray;

IMPORT

END AssociativeArray.

 

=={{header|Objeck}}==

class Iteration {

function : Main(args : String[]) ~ Nil {

}

}

 

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

{{works with|Objective-C|2.0+}}

[NSNumber numberWithInt:13], @"hello",

[NSNumber numberWithInt:31], @"world",

for (id value in [myDict objectEnumerator]) {

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

 

{{works with|Objective-C|<2.0}}

[NSNumber numberWithInt:13], @"hello",

[NSNumber numberWithInt:31], @"world",

while ((value = [enm nextObject])) {

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

 

{{works with|Cocoa|Mac OS X 10.6+}}

[NSNumber numberWithInt:13], @"hello",

[NSNumber numberWithInt:31], @"world",

[myDict enumerateKeysAndObjectsUsingBlock: ^(id key, id value, BOOL *stop) {

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

 

=={{header|OCaml}}==

Association array:

 

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

 

(* in functional programming it is often more useful to fold over the elements *)

 

Hash table:

Hashtbl.add map 'A' 1;;

Hashtbl.add map 'B' 2;;

 

(* in functional programming it is often more useful to fold over the elements *)

 

Functional binary search tree:

let map = CharMap.empty;;

let map = CharMap.add 'A' 1 map;;

 

(* in functional programming it is often more useful to fold over the elements *)

 

=={{header|Ol}}==

;;; create sample associative array

(define aa (list->ff '(

; ==> #((! . 9) (hello . 1) (world . 4))

 

 

=={{header|ooRexx}}==

d["hello"] = 1

d["world"] = 2

say "key =" s~index", value =" s~item

s~next

{{out}}

<pre>key = !

 

=={{header|Oz}}==

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

in

{ForAll {Record.toListInd MyMap} Show} %% pairs

{ForAll {Record.arity MyMap} Show} %% keys

 

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

 

The keys can be retried from a map with Vec:

You can iterate over the values as usual:

print(keys[i]," ",mapget(M,keys[i]))

 

=={{header|Perl}}==

use strict;

 

foreach my $val ( values %pairs ) {

print "value = $val\n";

 

=={{header|Phix}}==

The first three lines create a simple dictionary, with keys and values of several different types (string/integer/sequence):

<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: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #7060A8;">traverse_dict</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"visitor"</span><span style="color: #0000FF;">))</span>

{{out}}

<pre>

</pre>

You could also use some of the map.e routines:

<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: #0000FF;">?</span><span style="color: #000000;">keys</span><span style="color: #0000FF;">()</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">values</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

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

keys nl

values

 

=={{header|PHP}}==

$pairs = array( "hello" => 1,

"world" => 2,

echo "values = $value\n";

}

 

=={{header|PicoLisp}}==

===Using properties===

(put 'A 'bar 10)

(put 'A 'baz 15)

 

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

===Using an index tree===

(idx 'A (def "bar" 10) T)

(idx 'A (def "baz" 15) T)

 

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

 

=={{header|Pike}}==

the order is deterministic however.

 

mapping(string:string) m = ([ "A":"a", "B":"b", "C":"c" ]);

foreach(m; string key; string value)

Result: bac

 

 

=={{header|PostScript}}==

% over keys and values

<</a 1 /b 2 /c 3>> {= =} forall

% just values

<</a 1 /b 2 /c 3>> {pop =} forall

 

=={{header|Potion}}==

We can traverse tables by key or by key and val. We cannot traverse tables only by val.

 

mydictionary each (key, val): (key, ":", val, "\n") join print.

 

=={{header|PowerShell}}==

Using the following hash table:

Iterating over the key/value pairs is slightly cumbersome as it requires an explicit call to <code>GetEnumerator</code>:

A <code>foreach</code> statement can also be used:

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

Iterating over the keys:

 

foreach ($k in $h.Keys) {

Write-Host Key: $k

Iterating over the values:

 

foreach ($v in $h.Values) {

Write-Host Value: $v

 

=={{header|Prolog}}==

from having more than one value):

 

assert( mymap(key1,value1) ).

assert( mymap(key2,value1) ).

 

To perform the specific task at hand:

?- forall( mymap(Key,Value), writeln( [Key,Value]) ).

 

[key1,value1]

[key2,value1]

 

In Prolog, however, iteration is "built-in". For example:

?- mymap(key1, Y).

Y = value1.

X = key1 ;

X = key2.

 

To construct the list of keys:

?- findall( X, mymap(X,value1), Xs).

Xs = [key1, key2].

 

To construct the list of distinct values:

?- findall( Y, mymap(key1,Y), Ys).

Ys = [value1].

 

=={{header|PureBasic}}==

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

 

dict("de") = "German"

dict("en") = "English"

ForEach dict()

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

 

=={{header|Python}}==

"world": 31,

"!" : 71 }

# iterating over values:

for value in myDict.values():

 

=={{header|QB64}}==

'dictionary is not native data type of QB64

' here a dictionary engine using a string to store data

End Function

 

=={{header|R}}==

 

=== environment example ===

 

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

<pre>[1] 123</pre>

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

> for (name in ls(env)) {

+ cat(sprintf('index=%s, value=%s\n', name, env[[name]]))

<pre>index=1, value=rainfed hay

index=x, value=123</pre>

=== vector example ===

 

<pre>!

3</pre>

<pre>[1] 3</pre>

 

=== list example ===

 

<pre>[1] 1</pre>

<pre>[1] "xyz"</pre>

 

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

 

#lang racket

 

(for/list ([(k v) (in-dict dict3)]) ; => '("0 -> a" "1 -> b" "2 -> c")

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

 

=={{header|Raku}}==

{{works with|Rakudo|2015.12}}

 

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

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

 

 

=={{header|REXX}}==

/*╔════════════════════════════════════════════════════════════════════════════════════╗

║ The (below) two REXX statements aren't really necessary, but it shows how to ║

stateN.code= name; w= max(w,length(name)) /*define the state's name; max width. */

stateC.code= cap /* " " " code to the capital*/

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

 

=={{header|Ring}}==

# Project : Associative array/Iteration

 

see lst[n][1] + " : " + lst[n][2] + nl

next

Output:

<pre>

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

 

x = <<>>; // create an empty list

x.hello = 1;

 

 

 

=={{header|Ruby}}==

"world" => 31,

"!" => 71 }

 

# iterating over values:

 

another way:

puts "key = #{key}, value = #{value}"

end

for value in my_dict.values

puts "value = #{value}"

 

{{out}}

 

=={{header|Rust}}==

fn main() {

let mut olympic_medals = HashMap::new();

}

{{out}}

Note that <code>HashMap</code> does not preserve order (if this is important, <code>std::collections::BTreeMap</code> is what you want.)

 

=={{header|Scala}}==

 

println(f"Key->Value: ${m.mkString(", ")}%s")

println(f"Keys: ${m.keys.mkString(", ")}%s")

println(f"Values: ${m.values.mkString(", ")}%s")

Key->Value: Amsterdam -> Netherlands, New York -> USA, Heemstede -> Netherlands

Pairs: (Amsterdam,Netherlands), (New York,USA), (Heemstede,Netherlands)

{{works with|Gauche Scheme}}

 

;; Create an associative array (hash-table) whose keys are strings:

(define table (hash-table 'string=?

;; Create by "partial application" a function that accepts 2 arguments,

;; the key and the value:

 

Output:

</pre>

 

;; Iterate over the table and create a list of the keys and the

;; altered values:

(lambda (k-v) (cons (car k-v) (+ (cdr k-v) 5000)))

table)

 

To get a list of the keys or of the values of the table,

(To save space, I have removed comments you can read at the section for [[Associative_array/Creation#A_persistent_associative_array_from_scratch|''persistent'' associative arrays]].)

 

(r7rs)

(chicken (import r7rs)))

 

))

{{out}}

<pre>$ csc -DDEMONSTRATION -R r7rs -X r7rs associative_array_with_generators.scm && ./associative_array_with_generators

 

=={{header|Seed7}}==

 

const type: dictType is hash [string] integer;

writeln("value = " <& number);

end for;

 

{{out}}

 

=={{header|SenseTalk}}==

put "Carries a watch" into animal's habits

 

put animal's nextKeyValue

put animal's nextValue -- walking off the end returns a unique endValue

{{out}}

<pre>

 

=={{header|Sidef}}==

key1 => 'value1',

key2 => 'value2',

# Iterate over key-value pairs

hash.each { |key, value|

}

 

# Iterate only over keys

hash.keys.each { |key|

}

 

# Iterate only over values

hash.values.each { |value|

{{out}}

<pre>key1: value1

=={{header|Slate}}==

In Slate, all associative mappings inherit from <tt>Mapping</tt>, so they all have the same protocol. Even <tt>Sequence</tt>s obey it, in addition to their own protocol for collections with ordered integer-range keys.

pairs keysAndValuesDo: [| :key :value |

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

pairs do: [| :value |

inform: 'value = ' ; value printString

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

pairs := Dictionary

from: { 'hello' -> 1. 'world' -> 2. '!' -> 3. 'another!' -> 3 }.

pairs do: [ :value |

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

 

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

 

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

t = table()

t<'cat'> = 'meow'

* # Iterate vals

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

 

=={{header|Stata}}==

// Create an associative array

a=asarray_create()

loc=asarray_next(a,loc)

} while(loc!=NULL)

 

=={{header|Swift}}==

"hello": 13,

"world": 31,

// iterating over key-value pairs:

for (key, value) in myMap {

 

=={{header|Tcl}}==

===With Arrays===

# list items here...

}

 

# There is nothing for directly iterating over just the values

===With Dictionaries===

{{works with|Tcl|8.5}}

 

# Iterate over keys and values

foreach value [dict values $myDict] {

puts "value = $value"

 

=={{header|TXR}}==

 

 

(each ((k '(a b c))

 

(dohash (k v h)

 

{{out|Run}}

 

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

 

{{works with|ksh93}}

 

# just keys

for key in "${!a[@]}"; do

printf '%s => %s\n' "$key" "${a[$key]}"

 

{{works with|zsh}}

a=(key1 value1 key2 value2)

 

 

# keys and values

 

=={{header|Vala}}==

{{libheader|Gee}}

using Gee;

 

}

}

 

Compile with flag:

Dictionaries are similar in VBA and VBScript. Here is how to iterate.

 

Sub Test()

Dim h As Object, i As Long, u, v, s

Debug.Print u(i), v(i)

Next

 

=={{header|VBScript}}==

'instantiate the dictionary object

Set dict = CreateObject("Scripting.Dictionary")

WScript.StdOut.WriteLine key & " - " & dict.Item(key)

Next

 

{{Out}}

 

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

 

echo "Iterating over key-value pairs"

for value in values(dict)

echo value

 

{{Out}}

4

11</pre>

 

=={{header|Wart}}==

each (key val) table

 

{{out}}

=={{header|Wren}}==

Note that Wren makes no guarantee about iteration order which is not necessarily the same order in which the entries were added.

var capitals = {

"France": "Paris",

 

// iterate though the map and print out just the values

 

{{out}}

 

=={{header|XPL0}}==

char Dict(10,10);

int Entries;

for I:= 0 to Entries-1 do

[ChOut(0, Dict(I,0)); ChOut(0, ^ ); Text(0, @Dict(I,1)); CrLf(0)];

 

{{out}}

 

=={{header|zkl}}==

d.keys.pump(Console.print,fcn(k){String(k,",")})

d.values.apply("toUpper").println();

d.makeReadOnly(); // can only iterate over k,v pairs if read only

{{out}}

<pre>