Associative array/Creation: Difference between revisions

 

 

=={{header|ActionScript}}==

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

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

 

// More keys and values can then be added

map['key3'] = "value3";

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

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2007}}

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

with Ada.Text_IO;

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

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

 

=={{header|Aikido}}==

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

var names = {} // empty map

names["foo"] = "bar"

 

 

 

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

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

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

 

MODE COLOR = BITS;

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

 

<pre>

green: 16r00ff00

values: (16rff0000, 16r00ff00, 16r0000ff, 16r337733, 16r000000)

</pre>

 

=={{header|APL}}==

{{works with|Dyalog APL}}

X←⎕NS ⍬

sales.(revenue ← prices +.× quantities)

sales.revenue

 

=={{header|AWK}}==

Arrays in AWK are indeed associative arrays.

a["red"] = 0xff0000

a["green"] = 0x00ff00

print ( "red" in a ) # print 0

print ( "blue" in a ) # print 1

 

 

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

This is cheating, I'm sure of it.

 

@echo off

setlocal ENABLEDELAYEDEXPANSION

echo %1 = %2

goto :eof

 

<pre>array.dog = 1

array.cat = 2

"sicko&mumps" = 7

"sicko&bromodrosis" = 8</pre>

 

=={{header|Brat}}==

 

h[:a] = 1 #Assign value

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

 

 

=={{header|C}}==

''Solution is at [[Associative arrays/Creation/C]]''.

 

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

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

 

 

===Creation===

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

 

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

 

 

===Insertion===

====Operator[]====

The first method is using the [] operator.

 

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

double myValue = 3.14;

====insert()====

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

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

 

===Lookup===

====operator[]====

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

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

 

====find()====

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

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

if(exampleMap.end() != myIterator)

// Return the value for that key.

myValue = myIterator->second;

 

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

===Example===

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

#include <iostreams>

 

// main() must return 0 on success.

return 0;

 

 

 

 

=={{header|Clojure}}==

:key2 "value2"

 

=={{header|ColdFusion}}==

<cfset myHash.key1 = "foo">

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

 

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

 

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

;; or for implementation identity for other types!

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

;; alist is written like this:

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

 

=={{header|D}}==

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

assert("foo" in hash);

 

=={{header|Dao}}==

 

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

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lDictionary.Free;

end;

 

=={{header|E}}==

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

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

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

 

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

.NET 3.5 Generic Dictionary (mutable)

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

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

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

Functional dictionary (immutable)

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

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

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

| None -> printfn "not found"

 

=={{header|Factor}}==

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

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

{ [ "one" swap at . ]

[ 2 swap value-at . ]

[ "three" swap at . ]

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

 

=={{header|Fantom}}==

Associative arrays are called 'maps' in Fantom:

 

class Main

{

}

}

 

=={{header|Forth}}==

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

 

search-wordlist if

>body @

s" alpha" bar get . \ 5

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

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

 

 

Hashtable for mapping strings to integer

 

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

[ELSE]

.( Entry not present.) cr

 

=={{header|Go}}==

 

// make an empty map

 

 

// set a value

x["foo"] = 3

 

// make a map with a literal

 

=={{header|Groovy}}==

Create an empty map and add values

map[7] = 7

map['foo'] = 'foovalue'

assert 'foovalue' == map.foo

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

 

Create a pre-populated map and verify values

 

assert 7 == map[7]

assert 'foovalue' == map.foo

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

 

=={{header|Haskell}}==

{{works with|GHC}}

 

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

 

 

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

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

 

local t

t := table()

t["foo"] := "bar"

write(t["foo"])

 

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

 

===Static relation===

 

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

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

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

 

===Dynamic relation===

 

When play begins:

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

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

 

=={{header|Ioke}}==

 

=={{header|J}}==

 

 

 

 

 

 

 

 

=={{header|JavaScript}}==

assoc['foo'] = 'bar';

assoc['another-key'] = 3;

assoc.thirdKey = 'we can also do this!';

 

if (assoc.hasOwnProperty(key)) {

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

}

 

 

foo: 'bar',

'another-key': 3 //the key can either be enclosed by quotes or not

 

 

 

=={{header|Logo}}==

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

pprop "animals "dog 4

pprop "animals "mouse 11

print gprop "animals "cat ; 5

remprop "animals "dog

 

=={{header|Lua}}==

Lua tables are Hashes

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

hash[ "key-2" ] = 1

Returns nil on unknown key.