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 #

);

e := NEXT c

{{out}}

<pre>

The method with AppleScript "records" is to concatenate them. The result is a third record containing the labels from both contributors, the values from the record to the left of the operator being kept where labels are shared. The bars with some of the labels below are to distinguish them as "user" labels from tokenised ones that are provided as standards for use by scriptable applications and scripting additions. However, merging records works with tokenised labels too.

 

set updateRecord to {price:15.25, |color|:"red", |year|:1974}

 

set mergedRecord to updateRecord & baseRecord

 

{{output}}

 

=={{header|AutoHotkey}}==

Merged := {}

for k, v in base

Merged[k] := v

return Merged

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

Merged := merge(base, update)

for k, v in Merged

result .= k " : " v "`n"

Outputs:<pre>color : red

name : Rocket Skates

 

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

 

 

base$("name") = "Rocket Skates"

FOR x$ IN OBTAIN$(merge$)

PRINT x$, " : ", merge$(x$)

{{out}}

<pre>Base array

 

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

#include <string>

#include <map>

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

return 0;

 

{{out}}

</pre>

 

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(defn update-map [base update]

(merge base update))

"color" "red"

"year" "1974"})

 

{{out}}

 

=={{header|Crystal}}==

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

 

 

{{out}}

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

</pre>

 

=={{header|Dart}}==

main() {

var base = {

 

}

=={{header|Delphi}}==

{{libheader| System.Generics.Collections}}

{{Trans|C#}}

program Associative_arrayMerging;

 

end.

 

{{out}}

<pre>

=={{header|Elixir}}==

Elixir has a built-in hashmap type, called [https://hexdocs.pm/elixir/Map.html Map].

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

result = Map.merge(base, update)

{{out}}

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

The above sample uses [https://hexdocs.pm/elixir/Atom.html atoms] as the key type. If strings are needed, the <code>base</code> map would look like this:

 

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

 

=={{header|Nim}}==

 

let t1 = {"name": "Rocket Skates", "price": "12.75", "color": "yellow"}.toTable

t3[key] = value

 

 

{{out}}

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

{{works with|Cocoa}}

 

int main(void) {

}

return 0;

{{output}}

<pre>{

year = 1974;

}</pre>

 

=={{header|Ol}}==

(define a1 {

'name "Rocket Skates"

 

(define (collide a b) b) ; will use new key value

{{Out}}

<pre>

 

=={{header|Perl}}==

use warnings;

 

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

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

{{output}}

<pre>Update

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

def scand /# dict key -- dict n #/

 

pstack

 

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

 

 

(require racket/hash)

 

(hash-union base-data update-data #:combine (λ (a b) b)))

 

{{out}}

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

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>

 

=={{header|Ring}}==

load "stdlib.ring"

 

see list1[n][1] + " = " + list1[n][2] + nl

next

Output:

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

'name'-> 'Rocket Skates' .

'price' -> 12.75 .

declareAllFrom:update.

 

{{out}}

<pre>Dictionary(name->Rocket Skates price->15.25 year->1974 color->red)</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|VBA}}==

3 ways to do this tasks :

First : With Arrays + Type

Private Type Associative

Key As String

Next i

Debug.Print "-----------------------------"

 

Second way (simply) : with the Scripting Dictionary Object :

Dim Base As Object, Update As Object, Merged As Object, K As Variant

'INIT VARIABLE

Debug.Print K, Merged(K)

Next K

 

And the Third : With a Class Module (named ClassArrayAssociative)

The Class Module code:

 

Private mKey As String

Value = V

Key = K

The Module code :

Dim Base(2) As New ClassArrayAssociative, Up(2) As New ClassArrayAssociative

ReDim Result(UBound(Base)) As New ClassArrayAssociative

Next i

Debug.Print "-----------------------------"

{{out}}

<pre>

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