Associative array/Merging: Difference between revisions

|}

<br><br>

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses the associative array implementations in [[ALGOL_68/prelude]].

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

MODE AAVALUE = UNION( STRING, INT, REAL );

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

MODE AAKEY = STRING;

# include the associative array code #

PR read "aArrayBase.a68" PR

# adds or replaces all elements from b into a #

PRIO UPDATE = 9;

a

END # UPDATE # ;

# construct the associative arrays for the task #

REF AARRAY a := INIT LOC AARRAY;

);

e := NEXT c

{{out}}

<pre>

color: red

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f ASSOCIATIVE_ARRAY_MERGING.AWK

#

}

}

{{out}}

<pre>

 

=={{header|B4X}}==

Dim m2 As Map = CreateMap("price": 15.25, "color": "red", "year": 1974)

Dim merged As Map

Next

Next

 

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

#include <string>

#include <map>

 

template<typename map_type>

map_type result(update);

result.insert(original.begin(), original.end());

}

 

typedef std::map<std::string, std::string> map;

map original{

std::cout << "key: " << i.first << ", value: " << i.second << '\n';

return 0;

 

{{out}}

key: year, value: 1974

</pre>

 

=={{header|Clojure}}==

(defn update-map [base update]

(merge base update))

"color" "red"

"year" "1974"})

 

{{out}}

{"name" "Rocket Skates", "price" "15.25", "color" "red", "year" "1974"}

</pre>

 

=={{header|Dart}}==

main() {

var base = {

 

}

 

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

type N = |Price of float|Name of string|Year of int|Colour of string

let n=Map<string,N>[("name",Name("Rocket Skates"));("price",Price(12.75));("colour",Colour("yellow"))]

let ng=(Map.toList n)@(Map.toList g)|>Map.ofList

printfn "%A" ng

{{out}}

<pre>

The <code>assoc-union</code> word does this. <code>assoc-union!</code> is a variant that mutates the first associative array.

{{works with|Factor|0.99 2019-10-06}}

 

{ { "name" "Rocket Skates" } { "price" 12.75 } { "color" "yellow" } }

{ { "price" 15.25 } { "color" "red" } { "year" 1974 } }

{{out}}

<pre>

}

</pre>

 

=={{header|Go}}==

 

import "fmt"

result := merge(base, update)

fmt.Println(result)

 

{{out}}

There are various approaches, all of which would be strictly typed.<br>

For example, if we want to treat the input and output records as all sharing the same type:

{ name :: Maybe String

, price :: Maybe Float

itemFromMerge

(Item (Just "Rocket Skates") (Just 12.75) (Just "yellow") Nothing)

{{Out}}

<pre>Item {name = Just "Rocket Skates", price = Just 15.25, color = Just "red", year = Just 1974}</pre>

 

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

local base, update, master, f, k

 

write(k, " = ", master[k])

}

 

{{out}}

 

=={{header|J}}==

merge=: ,. NB. use: update merge original

compress=: #"1~ ~:@:keys

get=: [: > ((i.~ keys)~ <)~ { values@:] NB. key get (associative array)

pair=: [: |: <;._2;._2

Exercise the definitions. Interactive J prompts with 3 space indentation.

<pre>

 

=={{header|Java}}==

 

 

 

 

=={{header|JavaScript}}==

'use strict';

 

null, 2

))

{{Out}}

<pre>{

"year": 1974

}</pre>

 

=={{header|Julia}}==

 

=={{header|Kotlin}}==

fun main() {

val base = HashMap<String,String>()

println("merged: $merged")

}

{{Output}}

<pre>

 

=={{header|Lua}}==

update = {price=15.25, color="red", year=1974}

 

for key,val in pairs(result) do

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

 

{{output}}

year: 1974

name: Rocket Skates</pre>

 

=={{header|MiniScript}}==

MiniScript supports merging maps with the + operator.

update = {"price":15.25, "color":"red", "year":1974}

 

result = base + update

 

 

{{output}}

<pre>{"color": "red", "name": "Rocket Skates", "price": 15.25, "year": 1974}</pre>

 

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

{{works with|Cocoa}}

 

int main(void) {

}

return 0;

{{output}}

<pre>{

year = 1974;

}</pre>

 

=={{header|Perl}}==

use warnings;

 

$merge{$_} = [$base{$_}] for keys %base;

push @{$merge{$_}}, $more{$_} for keys %more;

{{output}}

<pre>Update

 

=={{header|Phix}}==

{{out}}

<pre>

{{"color","red"},{"name","Rocket Skates"},{"price",15.25},{"year",1974}}

</pre>

 

=={{header|PHP}}==

$base = array("name" => "Rocket Skates", "price" => 12.75, "color" => "yellow");

$update = array("price" => 15.25, "color" => "red", "year" => 1974);

$result = $update + $base; // Notice that the order is reversed

print_r($result);

{{output}}

<pre>Array

 

Alternative:

$base = array("name" => "Rocket Skates", "price" => 12.75, "color" => "yellow");

$update = array("price" => 15.25, "color" => "red", "year" => 1974);

$result = array_merge($base, $update);

print_r($result);

{{output}}

<pre>Array

[year] => 1974

)</pre>

 

=={{header|Python}}==

As of Python 3.5, this can be solved with the dictionary unpacking operator.

{{works with|Python|3.5+}}

update = {"price":15.25, "color":"red", "year":1974}

 

result = {**base, **update}

 

{{output}}

<pre>{'name': 'Rocket Skates', 'price': 15.25, 'color': 'red', 'year': 1974}</pre>

 

update = {"price":15.25, "color":"red", "year":1974}

 

result.update(update)

 

{{output}}

<pre>{'name': 'Rocket Skates', 'price': 15.25, 'color': 'red', 'year': 1974}</pre>

 

=={{header|Raku}}==

I must say I somewhat disagree with the terminology. The requested operation is an update not a merge. Demonstrate both an update and a merge. Associative arrays are commonly called hashes in Raku.

 

say my %base = :name('Rocket Skates'), :price<12.75>, :color<yellow>;

say my %update = :price<15.25>, :color<red>, :year<1974>;

 

# Demonstrate unmutated hashes

{{out}}

<pre>{color => yellow, name => Rocket Skates, price => 12.75}

The double quotes that surround the string (character) items (as shown in the task's preamble) weren't included for this presentation,

<br>although they could easily be added.

$.= /*define default value(s) for arrays. */

@.wAAn= 21; @.wKey= 7; @.wVal= 7 /*max widths of: AAname, keys, values.*/

defAA: procedure expose $. @.; parse arg AAn; new= 'new' /*get AA name; set NEW.*/

do j=2 to arg(); parse value arg(j) with key val /*obtain key and value.*/

/* [↑] add to key list if not in list.*/

/* [↑] add to key list if not in list.*/

@.wKey= max(@.wKey, length(key) ) /*find max width of a name of a key. */

say center(AAn, @.wAAn) right(key, @.wKey) $.AAn.key /*show some information.*/

end /*j*/

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

<pre>

new color red

new year 1974

</pre>

 

=={{header|Ruby}}==

update = {"price" => 15.25, "color" => "red", "year" => 1974}

 

result = base.merge(update)

{{output}}

<pre>{"name"=>"Rocket Skates", "price"=>15.25, "color"=>"red", "year"=>1974}</pre>

 

=={{header|Rust}}==

 

fn main() {

println!("{:#?}", original);

}

{{output}}

<pre>{

"price": "15.25",

}</pre>

 

=={{header|Swift}}==

{{works with|Swift|5+}}

let update : [String: Any] = ["price": 15.25, "color": "red", "year": 1974]

 

let result = base.merging(update) { (_, new) in new }

 

{{output}}

<pre>["price": 15.25, "name": "Rocket Skates", "color": "red", "year": 1974]</pre>

 

=={{header|Wren}}==

var m3 = {}

for (key in m1.keys) m3[key] = m1[key]

var update = { "price": 15.25, "color": "red", "year": 1974 }

var merged = mergeMaps.call(base, update)

 

{{out}}

 

=={{header|zkl}}==

"name", "Rocket Skates",

"price", 12.75,

update.pump( new:=base.copy() );

 

{{out}}

<pre>