Associative array/Merging: Difference between revisions

{{trans|Python}}

V update = [‘price’ = ‘15.25’, ‘color’ = ‘red’, ‘year’ = ‘1974’]

=={{header|Ada}}==

with Ada.Containers.Indefinite_Ordered_Maps;

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

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}

{{output}}

=={{header|Arturo}}==

newDetails: extend details #[price: 15.25 colour: 'red year: 1974]

=={{header|AutoHotkey}}==

Merged := {}

for k, v in base

return Merged

}</syntaxhighlight>

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

Merged := merge(base, update)

=={{header|AWK}}==

# syntax: GAWK -f ASSOCIATIVE_ARRAY_MERGING.AWK

#

=={{header|B4X}}==

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

Dim merged As Map

=={{header|BaCon}}==

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

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

#include <string>

#include <map>

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

using System.Collections.Generic;

using System.Linq;

=={{header|Clojure}}==

(defn update-map [base update]

(merge base update))

=={{header|Crystal}}==

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

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

In Common Lisp, the value of a key in an alist or a plist is defined as the first value in the list with a matching key or indicator. Thus, all that is necessary to implement this algorithm for either is the following:

(append list2 list1)

</syntaxhighlight>

These implementations for alists and plists are more complicated, but avoid duplicate keys in the results:

(defun merge-alists (alist1 alist2)

(nconc

=={{header|Dart}}==

main() {

var base = {

{{libheader| System.Generics.Collections}}

{{Trans|C#}}

program Associative_arrayMerging;

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

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

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" } }

=={{header|Go}}==

import "fmt"

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

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

local base, update, master, f, k

=={{header|J}}==

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

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

=={{header|Java}}==

class MergeMaps {

=={{header|JavaScript}}==

'use strict';

=={{header|Kotlin}}==

fun main() {

val base = HashMap<String,String>()

=={{header|Lua}}==

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

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

a2 = <|"price" -> 15.25, "color" -> "red", "year" -> 1974|>;

Merge[{a1, a2}, Last]</syntaxhighlight>

=={{header|MiniScript}}==

MiniScript supports merging maps with the + operator.

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

=={{header|Nim}}==

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

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

{{works with|Cocoa}}

int main(void) {

Helper code for all 3 versions:

type ty =

| TFloat of float

Association list : naive and functional approach.

let l1 : assoc list = [

("name", TString "Rocket Skates");

Binary tree/Map functor : proper functional approach.

{{works with|OCaml|above 4.03 for union function}}

module StringMap = Map.Make(String) ;;

Hash table : imperative/mutable approach.

(* Updates the base table with the bindings from add *)

let hash_merge (base : (string, ty) Hashtbl.t) (add : (string, ty) Hashtbl.t) : unit =

Since version 3.1.1 function `ff-union` changed from `(ff-union a1 a2 collide)` to `(ff-union collide a1 a2 ...)`!

(define a1 {

'name "Rocket Skates"

=={{header|Perl}}==

use warnings;

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">d1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">new_dict</span><span style="color: #0000FF;">({{</span><span style="color: #008000;">"name"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Rocket Skates"</span><span style="color: #0000FF;">},{</span><span style="color: #008000;">"price"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">12.75</span><span style="color: #0000FF;">},{</span><span style="color: #008000;">"color"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"yellow"</span><span style="color: #0000FF;">}}),</span>

=={{header|Phixmonti}}==

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

=={{header|PHP}}==

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

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

Alternative:

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

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

=={{header|PureBasic}}==

NewMap m2.s()

NewMap m3.s()

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}

;Alternative:

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

;New alternative using '|'

Type "help", "copyright", "credits" or "license()" for more information.

>>> base = {"name":"Rocket Skates", "price":12.75, "color":"yellow"}

=={{header|Racket}}==

(require racket/hash)

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

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

=={{header|Ring}}==

load "stdlib.ring"

=={{header|Ruby}}==

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

=={{header|Rust}}==

fn main() {

in an alist. Hence, a merge may be implemented by simply appending the update alist to the

front of the base alist. The downside is this leaves a bunch of useless junk in the alist.

; (The extra '() is so that append doesn't co-opt the second list.)

(define append-alists

This is more true to the intent of the Task. It generates a new alist with only the key/value

pairs needed.

; Returns a new list; the argument lists are not modified.

(define merge-alists

=={{header|SenseTalk}}==

In addition to setting individual property values, SenseTalk includes 5 built-in operations for modifying property lists, to: add properties, replace properties, remove properties, retain properties, and rename properties. The operation to replace properties is needed for this task.

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

=={{header|Smalltalk}}==

'name'-> 'Rocket Skates' .

'price' -> 12.75 .

=={{header|Swift}}==

{{works with|Swift|5+}}

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

=={{header|Tcl}}==

set dict2 [dict create price 15.25 color red year 1974]

dict for {key val} [dict merge $dict1 $dict2] {

3 ways to do this tasks :

First : With Arrays + Type

Private Type Associative

Key As String

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

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

'INIT VARIABLE

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

The Class Module code:

Private mKey As String

End Sub</syntaxhighlight>

The Module code :

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

ReDim Result(UBound(Base)) As New ClassArrayAssociative

=={{header|VBScript}}==

set d1=createobject("Scripting.Dictionary")

d1.add "name", "Rocket Skates"

=={{header|Wren}}==

var m3 = {}

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

=={{header|Vlang}}==

type Assoc = map[string]Generic

=={{header|Wren}}==

var m3 = {}

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

=={{header|zkl}}==

"name", "Rocket Skates",

"price", 12.75,