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

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

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

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

( swap . space . cr )

 

Iterating the keys uses "m:keys":

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

( . cr )

 

=={{header|Ada}}==

with Ada.Containers.Indefinite_Ordered_Maps;

 

 

=={{header|Aime}}==

text s;

 

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

=={{header|Arturo}}==

 

d: #[

name: "john"

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

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

enum := obj._NewEnum()

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

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

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:

 

births foo mergemap !</syntaxhighlight>

 

To view the results:

 

 

{{out}}

 

=={{header|BaCon}}==

 

associative("abc") = "first three"

 

=={{header|BBC BASIC}}==

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

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

 

=={{header|Bracmat}}==

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

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

 

=={{header|Brat}}==

 

#Iterate over key, value pairs

 

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

using System.Collections.Generic;

 

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

{{works with|C++11}}

#include <map>

#include <string>

 

Pre C++11:

myDict["hello"] = 1;

myDict["world"] = 2;

 

=={{header|Ceylon}}==

 

value myMap = map {

=={{header|Chapel}}==

 

 

for k in A.domain do

 

=={{header|Clojure}}==

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

(println k "=" v))

 

=={{header|CoffeeScript}}==

a: 'one'

b: 'two'

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

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.

 

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

 

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

hash-table)</syntaxhighlight>

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

 

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

 

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)

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

 

;; Project : Associative array/Iteration

 

 

=={{header|Crystal}}==

 

dict.each { |pair|

{{works with|D|2}}

 

 

void main() {

 

=={{header|Dao}}==

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

 

 

=={{header|Dart}}==

main(){

var fruits = {

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

=={{header|Dyalect}}==

 

 

for x in t.Keys() {

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,

 

=={{header|EchoLisp}}==

(lib 'hash) ;; load hash.lib

(define H (make-hash))

=={{header|Elena}}==

ELENA 5.0 :

import system'routines;

import extensions;

 

=== Strong typed dictionary ===

import system'routines;

import extensions;

 

=={{header|Elixir}}==

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

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

 

=={{header|Erlang}}==

-module(assoc).

-compile([export_all]).

=={{header|F_Sharp|F#}}==

Iterating over both.

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

 

 

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

 

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

H{ { "hi" "there" } { "a" "b" } } [ nip print ] assoc-each ! print values</syntaxhighlight>

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

{

{{libheader|Forth Foundation Library}}

 

include ffl/hci.fs

 

iterate</syntaxhighlight>

 

\ Written in ANS-Forth; tested under VFX.

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

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

 

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

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

uses Generics.Collections;

 

=={{header|Frink}}==

for [key, value] = d

println["$key\t$value"]

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

=={{header|Go}}==

'''Language:'''

"hello": 13,

"world": 31,

* 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 (

=={{header|Groovy}}==

Solution:

 

println "Entries:"

 

=={{header|Harbour}}==

LOCAL x

 

=={{header|Haskell}}==

with Data.Map:

 

myMap :: M.Map String Int

 

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

t := table()

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

 

=={{header|Io}}==

"hello", 13,

"world", 31,

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.

 

=={{header|Java}}==

map.put("hello", 1);

map.put("world", 2);

Java 8 version

 

map.put("hello", 1);

map.put("world", 2);

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

 

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

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

# applying a function to key-value pairs:

=={{header|K}}==

Creating a dictionary.

 

The keys are available via "!".

`hello `world `"!"

 

 

Print the key value pairs.

hello: 1

world: 2

 

The values are available via "[]".

1 2 3

 

 

=={{header|Kotlin}}==

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

 

 

=={{header|Lang5}}==

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

 

 

=={{header|Lasso}}==

//iterate over associative array

//Lasso maps

 

===Keys and Values===

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

(hash (: dict from_list data)))

 

===Just Keys===

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

(hash (: dict from_list data)))

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

 

=={{header|Lingo}}==

 

-- iterate over key-value pairs

 

=={{header|LiveCode}}==

put 5 into fruit["pears"]

put 6 into fruit["oranges"]

put tTmp</syntaxhighlight>

Output

apples

pears

 

=={{header|Lua}}==

["foo"] = "bar",

["baz"] = 6,

 

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

Module checkit {

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

 

=={{header|M4}}==

define(`for',

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

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

 

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:

 

Return all index / entry pairs as equations:

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

"a" = 1

</syntaxhighlight>

 

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

[1]

 

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

hashes=#/@keys[#]&;

 

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

 

for k=1:length(keys),

key = keys{k};

or

 

for k=1:length(keys),

key = keys{k};

 

=={{header|Maxima}}==

h[9]: 2$

 

 

=={{header|MiniScript}}==

 

for keyVal in d

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols

 

 

=={{header|NewLISP}}==

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

 

 

=={{header|Nim}}==

import tables

 

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

{{works with|oo2c Version 2}}

MODULE AssociativeArray;

IMPORT

 

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

 

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

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

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

 

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

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

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

=={{header|OCaml}}==

Association array:

 

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

 

Hash table:

Hashtbl.add map 'A' 1;;

Hashtbl.add map 'B' 2;;

 

Functional binary search tree:

let map = CharMap.empty;;

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

 

=={{header|Ol}}==

;;; create sample associative array

(define aa (list->ff '(

 

=={{header|ooRexx}}==

d["hello"] = 1

d["world"] = 2

 

=={{header|Oz}}==

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

in

 

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]))

)</syntaxhighlight>

 

=={{header|Perl}}==

use strict;

 

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

</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>

 

=={{header|Phixmonti}}==

 

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

 

=={{header|PHP}}==

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

"world" => 2,

 

=={{header|Picat}}==

Map = new_map([1=one,2=two,3=three,4=four]),

foreach(K=V in Map)

=={{header|PicoLisp}}==

===Using properties===

(put 'A 'bar 10)

(put 'A 'baz 15)

-> (15 10 5)</syntaxhighlight>

===Using an index tree===

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

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

the order is deterministic however.

 

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

foreach(m; string key; string value)

 

=={{header|PostScript}}==

% over keys and values

<</a 1 /b 2 /c 3>> {= =} 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

}</syntaxhighlight>

Iterating over the keys:

 

foreach ($k in $h.Keys) {

}</syntaxhighlight>

Iterating over the values:

 

foreach ($v in $h.Values) {

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

 

 

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

?- mymap(key1, Y).

Y = value1.

 

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

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

 

dict("de") = "German"

dict("en") = "English"

 

=={{header|Python}}==

"world": 31,

"!" : 71 }

 

=={{header|QB64}}==

'dictionary is not native data type of QB64

' here a dictionary engine using a string to store data

=== environment example ===

 

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

> env[["x"]]</syntaxhighlight>

<pre>[1] 123</pre>

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

> for (name in ls(env)) {

=== vector example ===

 

> print(x["!"])</syntaxhighlight>

<pre>!

3</pre>

<pre>[1] 3</pre>

 

=== list example ===

 

> print(a$a)</syntaxhighlight>

<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

 

{{works with|Rakudo|2015.12}}

 

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

 

=={{header|REXX}}==

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

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

 

=={{header|Ring}}==

# Project : Associative array/Iteration

 

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

 

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

x.hello = 1;

 

=={{header|Ruby}}==

"world" => 31,

"!" => 71 }

 

another way:

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

end

 

=={{header|Rust}}==

fn main() {

let mut olympic_medals = HashMap::new();

 

=={{header|Scala}}==

 

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

{{works with|Gauche Scheme}}

 

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

(define table (hash-table 'string=?

</pre>

 

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

;; altered values:

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

 

=={{header|Seed7}}==

 

const type: dictType is hash [string] integer;

 

=={{header|SenseTalk}}==

put "Carries a watch" into animal's habits

 

 

=={{header|Sidef}}==

key1 => 'value1',

key2 => 'value2',

=={{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 ; ')'

{{works with|GNU Smalltalk}}

 

pairs := Dictionary

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

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

 

(pairs values) do: [ :v | "..." ].</syntaxhighlight>

 

{{works with|CSnobol}}

 

t = table()

t<'cat'> = 'meow'

 

=={{header|Stata}}==

// Create an associative array

a=asarray_create()

 

=={{header|Swift}}==

"hello": 13,

"world": 31,

=={{header|Tcl}}==

===With Arrays===

# list items here...

}

===With Dictionaries===

{{works with|Tcl|8.5}}

 

# Iterate over keys and values

=={{header|TXR}}==

 

 

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

 

{{works with|ksh93}}

 

# just keys

 

{{works with|zsh}}

a=(key1 value1 key2 value2)

 

=={{header|Vala}}==

{{libheader|Gee}}

using Gee;

 

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

 

Sub Test()

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

 

=={{header|VBScript}}==

'instantiate the dictionary object

Set dict = CreateObject("Scripting.Dictionary")

 

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

 

echo "Iterating over key-value pairs"

 

=={{header|Vlang}}==

my_map := {

"hello": 13,

 

=={{header|Wart}}==

each (key val) table

prn key " " val</syntaxhighlight>

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

 

=={{header|XPL0}}==

char Dict(10,10);

int Entries;

 

=={{header|zkl}}==

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

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