<?php
$menus = array(
  array('name' => 'CURRY', 'price' => 900),
  array('name' => 'PASTA', 'price' => 1200),
  array('name' => 'COFFEE', 'price' => 600)
);

// この下にコードを書いてください
foreach ($menus as $menu) {
  echo $menu['name']."は".$menu['price']."円です";
  echo '<br>';
}

?>

---出力結果---
CURRYは900円です
PASTAは1200円です
COFFEEは600円です

  foreach ($menus as $menu) { ~~~~}

int[] array = new int[4]

array[0] = 160;
array[1] = 170;
array[2] = 180;

//Dictionary インスタンスを使うための Using ディレクティブ
using System.Collections.Generic; 
//Dictionary の宣言
var array = new Dictionary<"Keyの型", "Valueの型">();

array.Add("配列の名前(Key)", "配列に代入する値(Value)");

array[速度V] = 20 -----> 速度 (array[0]) には 20 という値が結びつく
array[質量M] = 2 ------> 質量 (array[1]) には 170 という値が結びつく
array[大きさS] = 100 --> 大きさ (array[2]) には 100 という値が結びつく

//キーを保管するための配列
string[] key = new string[4];
int i = 0;

//キーが存在する回数だけ繰り返し、key に保管する
foreach(string Key in array.Keys)
{
       key[i] = Key;
       i++;
}

//値を保管するための配列
string[] value = new string[4];
int j = 0;

//値が存在する回数だけ繰り返し、value に保管する
foreach(string Value in array.Values)
{
       value[j] = Value;
       j++;
}

<Window x:Class="_006_連想配列.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:_006_連想配列"
        mc:Ignorable="d"
        Title="MainWindow" Height="200" Width="300">
    <Grid>
        <Label Content="配列[0]" HorizontalAlignment="Left" Margin="10,10,0,0" VerticalAlignment="Top"/>
        <Label Content="配列[1]" HorizontalAlignment="Left" Margin="10,41,0,0" VerticalAlignment="Top"/>
        <Label Content="配列[2]" HorizontalAlignment="Left" Margin="10,72,0,0" VerticalAlignment="Top"/>
        <Label Content="配列[3]" HorizontalAlignment="Left" Margin="10,103,0,0" VerticalAlignment="Top"/>
        <TextBox HorizontalAlignment="Left" Height="23" Margin="58,14,0,0" TextWrapping="Wrap" Text="なにか" VerticalAlignment="Top" Width="120" x:Name="Textbox0"/>
        <TextBox HorizontalAlignment="Left" Height="23" Margin="58,44,0,0" TextWrapping="Wrap" Text="文字を" VerticalAlignment="Top" Width="120" x:Name="Textbox1"/>
        <TextBox HorizontalAlignment="Left" Height="23" Margin="58,75,0,0" TextWrapping="Wrap" Text="入力" VerticalAlignment="Top" Width="120" x:Name="Textbox2"/>
        <TextBox HorizontalAlignment="Left" Height="23" Margin="58,107,0,0" TextWrapping="Wrap" Text="してみて" VerticalAlignment="Top" Width="120" x:Name="Textbox3"/>
        <Button Content="書き換える" HorizontalAlignment="Left" Margin="58,139,0,0" VerticalAlignment="Top" Width="90" Click="Button_Write" />
        <Label Content="配列名" HorizontalAlignment="Left" Margin="197,10,0,0" VerticalAlignment="Top" x:Name="Label_array0" Height="27"/>
        <Label Content="配列名" HorizontalAlignment="Left" Margin="197,41,0,0" VerticalAlignment="Top" Height="26" x:Name="Label_array1"/>
        <Label Content="配列名" HorizontalAlignment="Left" Margin="197,72,0,0" VerticalAlignment="Top" Height="27" x:Name="Label_array2"/>
        <Label Content="配列名" HorizontalAlignment="Left" Margin="197,107,0,0" VerticalAlignment="Top" Height="27" x:Name="Label_array3"/>
        <Button Content="表示" HorizontalAlignment="Left" Margin="161,139,0,0" VerticalAlignment="Top" Width="90" Click="Button_Show"/>
    </Grid>
</Window>

using System.Windows;
using System.Collections.Generic;

namespace _006_連想配列
{
    /// <summary>
    /// MainWindow.xaml の相互作用ロジック
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        //連想配列にテキストボックスの情報を書き込む
        static void Array_Write()
        {
            //Textbox は MainWindow に存在するのでインスタンス化する必要がある。
            //インスタンスを取得した上でその中の TextBox を使う
            var mainWindow = (MainWindow)App.Current.MainWindow;

            //連想配列は Dictionary<> を用いる
            //<配列の名前, 配列に入れるデータ>の各型を宣言する
            var array = new Dictionary<string, string>();

            //キーを個別に保管しておくための配列(変換する)
            string[] key = new string[4];

            //値を個別に保管しておくための配列(変換する)
            string[] value = new string[4];

            //foreach を回すための初期値
            int i = 0;

            //各要素に配列名とそこに入れるデータを参照する
            array.Add("配列1", mainWindow.Textbox0.ToString());
            array.Add("配列2", mainWindow.Textbox1.ToString());
            array.Add("配列3", mainWindow.Textbox2.ToString());
            array.Add("配列4", mainWindow.Textbox3.ToString());

            //array のキーの数だけ繰り返して、キーを個々に格納
            foreach(string Key in array.Keys)
            {
                key[i] = Key;
                i++;
            }

            //ウィンドウの配列名のところに設定した配列名が更新される
            mainWindow.Label_array0.Content = key[0];
            mainWindow.Label_array1.Content = key[1];
            mainWindow.Label_array2.Content = key[2];
            mainWindow.Label_array3.Content = key[3];
        }

        private void Button_Write(object sender, RoutedEventArgs e)
        {
            //連想配列へ書き込む
            Array_Write();
            MessageBox.Show("書き込みました");
        }

        private void Button_Show(object sender, RoutedEventArgs e)
        { 
            MessageBox.Show("配列名 " + Label_array0.Content + " には " + Textbox0.Text + " が代入されています。");
            MessageBox.Show("配列名 " + Label_array1.Content + " には " + Textbox1.Text + " が代入されています。");
            MessageBox.Show("配列名 " + Label_array2.Content + " には " + Textbox2.Text + " が代入されています。");
            MessageBox.Show("配列名 " + Label_array3.Content + " には " + Textbox3.Text + " が代入されています。");
        }
    }
}

let a = 1;
let b = a;
a = 100; // 後からaにだけ100を代入し直す。
console.log(b); // さてbには何が入っているでしょう。 1? 100?

1

let obj1 = {'one':'あ'};
let obj2 = obj1;
obj1.one = 'い'; // 後からobj1にだけ「い」を代入し直す。
console.log(obj2); // さてこれは？ 「あ」？　「い」？

{one: "い"}

let arr1 = [1,2,3];
let arr2 = arr1;
arr1[0] = 10000; // 後からarr1にだけ10000を代入し直す。
console.log(arr2[0]); // さてこれは？　1? 100?

10000

      let idx = []
      this.users.map((v,k) => v.gender == '男' ? idx.push(k) : []) // ここはコメント欄で指摘を頂いております。そちらもご参照ください。
      return idx

# ピカチュウが被っているので
data = [
    {"species": "ピカチュウ", "color": "yellow" , "animal": "ねずみ"},
    {"species": "カイリュー", "color": "orange" , "animal": "ドラゴン"},
    {"species": "ヤドラン", "color": "pink" , "animal": "やどかり"},
    {"species": "ピカチュウ", "color": "orange" , "animal": "ねずみ"},
    {"species": "ビジョン", "color": "purple" , "animal": "とり"},
    {"species": "コダック", "color": "yellow" , "animal": "あひる"},
    {"species": "ピカチュウ", "color": "white" , "animal": "ねずみ"}
]

# こうして、ピカチュウを一つにしたい
new_data = [
    {"species": "ピカチュウ", "color": "yellow" , "animal": "ねずみ"},
    {"species": "カイリュー", "color": "orange" , "animal": "ドラゴン"},
    {"species": "ヤドラン", "color": "pink" , "animal": "やどかり"},
    {"species": "ビジョン", "color": "purple" , "animal": "とり"},
    {"species": "コダック", "color": "yellow" , "animal": "あひる"}
]

data = [
    {"species": "ピカチュウ", "color": "yellow" , "animal": "ねずみ"},
    {"species": "カイリュー", "color": "orange" , "animal": "ドラゴン"},
    {"species": "ヤドラン", "color": "pink" , "animal": "やどかり"},
    {"species": "ピカチュウ", "color": "orange" , "animal": "ねずみ"},
    {"species": "ビジョン", "color": "purple" , "animal": "とり"},
    {"species": "コダック", "color": "yellow" , "animal": "あひる"},
    {"species": "ピカチュウ", "color": "white" , "animal": "ねずみ"}
]

# 重複を削りたいkeyの値を追加していく配列
species_array = []
# 新たにできる連想配列
new_data = []

# データ１つ１つに処理を行う
for pokemon in data:
    # 重複を削りたいkeyの値を変数に入れる
    species = pokemon["species"]
    # 重複を削りたいkeyの値を追加した配列に同じ値がなければ
    if(species not in species_array):
        # 重複を削りたいkeyの値を追加した配列に新たな値を追加して
        species_array.append(species)
        # 新たにできる連想配列にデータを追加する
        new_data.append(pokemon)

"use strict";

//初期化
const kantoh={
    "茨城県":"水戸市",
    "栃木県":"宇都宮市",
    "群馬県":"前橋市",
    "埼玉県":"さいたま市",
    "神奈川県":"横浜市"
};
//代入
kantoh["千葉県"]="千葉市";
//要素の有無
console.log("千葉県" in kantoh);
//追加と代入は同じ
kantoh["東京都"]="新宿区";
//要素が登録済みなら代入したくない場合
if(!("東京都" in kantoh)){
    kantoh["東京都"]="新宿区";
}
else{
    console.log("同一のキーを含む項目が既に追加されています。");
}
//取得
console.log(kantoh["千葉県"]);
//代入演算子も使用可
kantoh["千葉県"]+="中央区";
console.log(kantoh["千葉県"]);
//要素数
console.log(Object.keys(kantoh).length);
//要素の削除
delete kantoh["千葉県"];
//キーの配列
console.log(Object.keys(kantoh).join(","));
//値の配列
console.log(Object.values(kantoh).join(","));
//ループ
for(let [key,value] of Object.entries(kantoh)){
    console.log(`key:${key} value:${value}`);   
}
//Join
const joinDict=
    dict=>Object.entries(dict).map(v=>v.join(":")).join(", ");
console.log(joinDict(kantoh));
//要素のクリア
for(let i of Object.keys(kantoh)) delete kantoh[i];
kantoh["なし"]="なにもないよ";
console.log(joinDict(kantoh));

"use strict";

//初期化
const kantoh=new Map([
    ["茨城県","水戸市"],
    ["栃木県","宇都宮市"],
    ["群馬県","前橋市"],
    ["埼玉県","さいたま市"],
    ["神奈川県","横浜市"]
]);
//代入
kantoh.set("千葉県","千葉市");
//要素の有無
console.log(kantoh.has("千葉県"));
//追加と代入は同じ
kantoh.set("東京都","新宿区");
//要素が登録済みなら代入したくない場合
if(!kantoh.has("東京都")){
    kantoh.set("東京都","新宿区");
}
else{
    console.log("同一のキーを含む項目が既に追加されています。");
}
//取得
console.log(kantoh.get("千葉県"));
//代入演算子は使用不可
const resetAdd=(dict,key,value)=>dict.set(key,dict.get(key)+value);
resetAdd(kantoh,"千葉県","中央区");
console.log(kantoh.get("千葉県"));
//要素数
console.log(kantoh.size);
//要素の削除
kantoh.delete("千葉県");
//キーの配列
console.log(Array.from(kantoh.keys()));
//値の配列
console.log(Array.from(kantoh.values()));
//ループ
for(let [key,value] of kantoh){
    console.log(`key:${key} value:${value}`);   
}
//Join
const joinDict=
    dict=>Array.from(dict).map(v=>v.join(":")).join(", ");
console.log(joinDict(kantoh));
//要素のクリア
kantoh.clear();
kantoh.set("なし","なにもないよ");
console.log(joinDict(kantoh));

#初期化
kantoh={
    "茨城県":"水戸市",
    "栃木県":"宇都宮市",
    "群馬県":"前橋市",
    "埼玉県":"さいたま市",
    "神奈川県":"横浜市"
}
#代入
kantoh["千葉県"]="千葉市"
#要素の有無
print("千葉県" in kantoh)
#追加と代入は同じ
kantoh["東京都"]="新宿区"
#要素が登録済みなら代入したくない場合
if "東京都" not in kantoh:
    kantoh["東京都"]="新宿区"
else:
    print("同一のキーを含む項目が既に追加されています。")
#取得
print(kantoh["千葉県"])
#代入演算子も使用可
kantoh["千葉県"]+="中央区"
print(kantoh["千葉県"])
#要素数
print(len(kantoh))
#要素の削除
del kantoh["千葉県"]
#キーの配列
print(list(kantoh.keys()))
#値の配列
print(list(kantoh.values()))
#ループ
for key,value in kantoh.items():
    print(f"key:{key} value:{value}")
#Join
joinDict=(
    lambda dict:",".join([":".join(v) for v in dict.items()]))
print(joinDict(kantoh))
#要素のクリア
kantoh.clear()
kantoh["なし"]="なにもないよ"
print(joinDict(kantoh))

using System;
using System.Collections.Generic;
using System.Linq;

class Program{
    static void Main(){
        //初期化
        var kantoh=new Dictionary<string,string>{
            {"茨城県","水戸市"},
            {"栃木県","宇都宮市"},
            {"群馬県","前橋市"},
            {"埼玉県","さいたま市"},
            {"神奈川県","横浜市"}
        };
        //代入
        kantoh["千葉県"]="千葉市";
        //要素の有無
        Console.WriteLine(kantoh.ContainsKey("千葉県"));
        //追加
        kantoh.Add("東京都","新宿区");
        //要素が登録済みの場合、ArgumentException
        try{
            kantoh.Add("東京都","新宿区");
        }
        catch(ArgumentException ex){
            Console.WriteLine(ex.Message);
        }
        //取得
        Console.WriteLine(kantoh["千葉県"]);
        //代入演算子も使用可
        kantoh["千葉県"]+="中央区";
        Console.WriteLine(kantoh["千葉県"]);
        //要素数
        Console.WriteLine(kantoh.Count);
        //要素の削除
        kantoh.Remove("千葉県");
        //キーの配列
        Console.WriteLine(string.Join(",",kantoh.Keys));
        //値の配列
        Console.WriteLine(string.Join(",",kantoh.Keys));
        //ループ
        foreach(var v in kantoh){
            Console.WriteLine($"key:{v.Key} value:{v.Value}");
        }
        //Join
        Func<Dictionary<string,string>,string> joinDict=
            dict=>string.Join(", ",dict.Select(v=>v.Key+":"+v.Value));
        Console.WriteLine(joinDict(kantoh));  
        //要素のクリア
        kantoh.Clear();
        kantoh["なし"]="なにもないよ";
        Console.WriteLine(joinDict(kantoh));  
    }
}

Option Strict On
Option Infer On
Imports System.Collections.Generic
Imports System.Linq

Module Program
    Sub Main()
        '初期化
        Dim kantoh As New Dictionary(Of String,String) From {
            {"茨城県","水戸市"},
            {"栃木県","宇都宮市"},
            {"群馬県","前橋市"},
            {"埼玉県","さいたま市"},
            {"神奈川県","横浜市"}
        }
        '代入
        kantoh("千葉県")="千葉市"
        '要素の有無
        Console.WriteLine(kantoh.ContainsKey("千葉県"))
        '追加
        kantoh.Add("東京都","新宿区")
        '要素が登録済みの場合、ArgumentException
        Try
            kantoh.Add("東京都","新宿区")
        Catch ex As ArgumentException
            Console.WriteLine(ex.Message)
        End Try
        '取得
        Console.WriteLine(kantoh("千葉県"))
        '代入演算子も使用可
        kantoh("千葉県")+="中央区"
        Console.WriteLine(kantoh("千葉県"))
        '要素数
        Console.WriteLine(kantoh.Count)
        '要素の削除
        kantoh.Remove("千葉県")
        'キーの配列
        Console.WriteLine(String.Join(",",kantoh.Keys))
        '値の配列
        Console.WriteLine(String.Join(",",kantoh.Keys))
        'ループ
        For Each v In kantoh
            Console.WriteLine($"key:{v.Key} value:{v.Value}")
        Next
        'Join
        Dim joinDict As Func(Of Dictionary(Of String,String),String)=
            Function(dict) String.Join(", ",dict.Select(Function(v) v.Key & ":" & v.Value))
        Console.WriteLine(joinDict(kantoh))
        '要素のクリア
        kantoh.Clear()
        kantoh("なし")="なにもないよ"
        Console.WriteLine(joinDict(kantoh))
    End Sub
End Module

#runtime "hsp3cl"
#cmpopt varinit 1
#include "Dictionary.as"

;初期化
new@Dictionary kantoh,"str",,,{"
    茨城県:水戸市,
    栃木県:宇都宮市,
    群馬県:前橋市,
    埼玉県:さいたま市,
    神奈川県:横浜市
"}
;代入
dcSet kantoh,"千葉県","千葉市"
;要素の有無
mes dcContainsKey(kantoh,"千葉県")
;追加
dcAdd kantoh,"東京都","新宿区"
;要素が登録済みの場合、statに1が返り何もしない
dcAdd kantoh,"東京都","新宿区"
if 1=stat{
    mes "同一のキーを含む項目が既に追加されています。"
}
;取得
mes dcItem(kantoh,"千葉県")
;代入演算子っぽい何かも使用可
dcReSet kantoh,"千葉県","+","中央区"
mes dcItem(kantoh,"千葉県")
;要素数
mes dcCount(kantoh)
;要素の削除
dcRemove kantoh,"千葉県"
;キーの配列
sdim keys: dcRefKeys kantoh,keys
mes dcJoinArray(keys,",")
;値の配列
sdim values: dcRefValues kantoh,values
mes dcJoinArray(values,",")
;ループ
dcForeach kantoh
    mes strf("key:%s value:%s",dcKeys(kantoh,cnt),dcValues(kantoh,cnt))   
loop
;Join
mes dcJoinDict(kantoh,":",",")   
;要素のクリア
dcClear kantoh
dcSet kantoh,"なし","なにもないよ"
mes dcJoinDict(kantoh)

(let(
        ;初期化
        (kantoh (make-hash-table :test #'equal)))
    ;初期化は愚直
    (setf
        (gethash "茨城県" kantoh) "水戸市"
        (gethash "栃木県" kantoh) "宇都宮市"
        (gethash "群馬県" kantoh) "前橋市"
        (gethash "埼玉県" kantoh) "さいたま市"
        (gethash "神奈川県" kantoh) "横浜市")
    (format t "~A~%" (gethash "千葉県" kantoh))
    ;代入
    (setf (gethash "千葉県" kantoh) "千葉市")
    ;要素の有無 gethashの返り値の2価を
    (format t "~A~%" (multiple-value-list(gethash "千葉県" kantoh)))
    ;追加と代入は同じ
    (setf (gethash "東京都" kantoh) "新宿区")
    ;要素が登録済みなら代入したくない場合
    (if (not(cadr(multiple-value-list(gethash "東京都" kantoh))))
        (setf (gethash "東京都" kantoh) "新宿区")
        (write-line "同一のキーを含む項目が既に追加されています。"))
    ;取得
    (format t "~A~%" (gethash "東京都" kantoh))
    ;代入演算子なんてない
    (setf (gethash "千葉県" kantoh)
        (concatenate 'string (gethash "千葉県" kantoh) "中央区"))
    ;要素数
    (format t "~d~%" (hash-table-count kantoh))
    ;要素の削除
    (remhash "千葉県" kantoh)
    ;キーの配列
    (format t "~A~%" (loop for key being the hash-keys in kantoh collect key))
    ;値の配列
    (format t "~A~%" (loop for key being the hash-keys in kantoh using (hash-value value) collect value))
    ;ループ
    (maphash #'(lambda(key value)
            (format t "key:~A value:~A~%" key value))
        kantoh)
    ;Join
    (labels((joinDict(dict)
            (format nil "~{~A~^,~}" 
                (mapcar #'(lambda(item) (concatenate 'string (car item) ":"  (cadr item)))
                    (loop for key being the hash-keys in kantoh using (hash-value value) collect
                        (list key value))))))
        (format t "~A~%" (joinDict kantoh))
        ;要素のクリア
        (maphash #'(lambda(key value) (remhash key kantoh)) kantoh)
            (setf (gethash "なし" kantoh) "なにもないよ")
            (format t "~A~%" (joinDict kantoh))))

$testarr = ['t1' => 'sss1','t2' => 'sss2'];
dump($testarr);
dump((object)$testarr);

echo $testarr['t1'];
echo ((object)$testarr)->t1;

map<string, int> mp;

#include<bits/stdc++.h>
using namespace std;

int main(){
    map<string, int> mp;
    mp["dog"] = 3;
    mp["cat"] = 1;
    mp["python"] = 4;

    cout << mp["dog"] << endl; //3
    cout << mp["cat"] << endl; // 1
    cout << mp["python"] << endl; // 4
    cout << mp["fish"] << endl; //0
}

#include<bits/stdc++.h>
using namespace std;

int main(){
    map<string, int> mp;
    mp["dog"] = 3;
    mp["cat"] = 1;
    mp["python"] = 4;

    for(auto itr=mp.begin(); itr!=mp.end(); itr++) {
        cout << "key = " << itr->first;      // キーを表示      
        cout << ", val = " << itr->second << endl;    // 値を表示
    }
}

key = cat, val = 1
key = dog, val = 3
key = python, val = 4

g++ -O0 map.cpp
time ./a.out 
g++ -O0 unordered_map.cpp
time ./a.out 

#include<bits/stdc++.h>
using namespace std;

int main(){
    map<string, int> mp;

    for(int i=0; i<1e7; i++){
        string s = to_string(i);
        mp[s]= i;
    }

    for(auto itr=mp.begin(); itr!=mp.end(); itr++) {
        string a = itr->first;      // キーを表示
        int b = itr->second;
    }
}

#include<bits/stdc++.h>
using namespace std;

int main(){
    unordered_map<string, int> mp2;
    for(int i=0; i<1e7; i++){
        string s = to_string(i);
        mp2[s]= i;
    }

    for(auto itr=mp2.begin(); itr!=mp2.end(); itr++) {
        string a = itr->first;
        int b = itr->second;
    }
}

[
    {
        "name": "Aさん",
        "department": "営業",
        "text": [
            "今月の売り上げは先月の2倍の見込みです",
            "先月の遅れを取り戻します"
        ]
    },
    {
        "name": "B",
        "department": "人事",
        "text": [
            "就活生とお話する機会があって楽しいです"
        ]
    },
    {
        "name": "C",
        "department": "経理",
        "text": [
            "1桁のミスも許されない世界です"
        ]
    }
]

<?php
$file = "./data.json";
$json = file_get_contents($file);
$data = json_decode($json, true);
?>

$data[0]["name"] => "A"
$data[0]["department"] => "営業"
$data[0]["text"][0] => "今月の売り上げは先月の2倍の見込みです"
$data[0]["text"][1] => "先月の遅れを取り戻します"
$data[1]["name"] => "B"
$data[1]["department"] => "人事"
・・・

<?php
for($i=0; $i<count($data); $i++){
    print<<<EOT
    <div style="margin: 10px; padding: 5px; border: solid 1px #000000;">
        <p>名前：{$data[$i]["name"]}</p>
        <p>所属：{$data[$i]["department"]}</p>
        <p>
EOT;
        for($k=0; $k<count($data[$i]["text"]); $k++){
            print<<<EOT
            {$data[$i]["text"][$k]}<br>
EOT;
        }
        print<<<EOT
        </p>
    </div>

EOT;
}
?>

const obj1    = { a: 1, b: 2, c: 3 };
const obj2    = { d: 4, e: 5, f: 6 };
const result1 = Object.assign(obj1, obj2);
console.log(result1);
// => { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }

const obj3    = { a: 1, b: 2, c: 3 };
const obj4    = { a: 4 };
const result2 = Object.assign(obj3, obj4);
console.log(result2);
// 同じKeyの値がある場合、第２引数のものに上書きされる
// => { a: 4, b: 2, c: 3 }

const obj1    = { a: 1, b: 2, c: 3 };
const obj2    = { d: 4, e: 5, f: 6 };
const result1 = { ...obj1, ...obj2 }
console.log(result1);
// => { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }

const obj3    = { a: 1, b: 2, c: 3 };
const obj4    = { a: 4 };
const result2 = { ...obj3, ...obj4 }
console.log(result2);
// 同じKeyの値がある場合、２つ目のものに上書きされる
// => { a: 4, b: 2, c: 3 }

$datetimes = [
    'past' => [
        'yesterday' => new DateTime('yesterday'),
        'lastweek' => new DateTime('last week'),
    ],
    'future' => [
        'tomorrow' => new DateTime('tomorrow'),
        'nextyear' => new DateTime('next year'),
    ]
];

$datetimes = [];
foreach($request as $v){
    $datetimes[$v['tense']][$v['key']] = new DateTime($v['value']);
}

    var datetimes = new Dictionary<string, Dictionary<string, DateTime>>();

    var list1 = new Dictionary<string, DateTime>();
    list1.Add("yesterday", new DateTime("yesterday"));
    list1.Add("lastweek", new DateTime("last week"));

    var list2 = new Dictionary<string, DateTime>();
    list2.Add("tomorrow", new DateTime("tomorrow"));
    list2.Add("nextyear", new DateTime("next year"));

    datetimes.Add("past", list1);
    datetimes.Add("future", list2);

    var datetimes = new Dictionary<string, Dictionary<string, DateTime>>();

    // The given key "past" was not present in the dictionary
    datetimes["past"].Add("yesterday", new DateTime("yesterday"));

    // Object reference not set to an instance of an object
    datetimes.Add("past", null);

    // An item with the same key has already been added
    datetimes.Add("past", new Dictionary<string, DateTime>{{"yesterday", new DateTime("yesterday")}} );
    datetimes.Add("past", new Dictionary<string, DateTime>{{"lastweek", new DateTime("last week")}} );

    // これはOK
    datetimes.Add("past", new Dictionary<string, DateTime>{{"yesterday", new DateTime("yesterday")}} );
    datetimes["past"].Add("lastweek", new DateTime("last week"));

functionresoluteBibtex(bibtex_source){// BibTeXソースを要素ごとの連想配列に分解varbibtex_source_tailcut=bibtex_source.replace(/}[\n]*}/,'');//　末尾の'} }'を削除varbibtex_splited=bibtex_source_tailcut.split(/},[\n]*/);varbibtex_contents={};varvalue,value_splited;for(varindexinbibtex_splited){value=bibtex_splited[index];// @xxxxx{label, となっている部分の対応if(value.charAt(0)=='@'){value_splited=value.split('{');bibtex_contents['@']=value_splited[0];bibtex_contents['label']=value_splited[1].substring(0,value_splited[1].indexOf(','));varnext_content_by_label=value_splited[1].replace(/[\w]*, */,'');bibtex_contents[next_content_by_label.replace('=','')]=value_splited[2];}else{value_splited=value.split('={');bibtex_contents[value_splited[0]]=value_splited[1];}}returnbibtex_contents;}

// BibTeX形式のデータvarbibtex_source="@inproceedings{shvachko2010hadoop,
  title={The hadoop distributed file system.},
  author={Shvachko, Konstantin and Kuang, Hairong and Radia, Sanjay and Chansler, Robert and others},
  booktitle={MSST},
  volume={10},
  pages={1--10},
  year={2010}
}";varbibtex_contents=resoluteBibtex(bibtex_source);

// キー：値 で表示"@":"inproceedings","label":"shvachko2010hadoop","title":"The hadoop distributed file system.","author":"Shvachko, Konstantin and Kuang, Hairong and Radia, Sanjay and Chansler, Robert and others","booktitle":"MSST","volume":"10","pages":"1--10","year":"2010"

@foo=JSON(foo)

#js-el#👈Vue.jsがマウントするDOM
  #js-el-data-foo=@foo# 👈渡したい値 その１#js-el-data-baa=@baa# 👈渡したい値 その２

<script>exportdefault{data:()=>{return{reservations:{}}},created:function(){//                 👇JSONが連想配列になる                            👇JSONで受け取るthis.memos=JSON.parse(document.querySelector('#js-el-data-foo').innerText);}}</script>

<templatelang="pug">.foo(v-for="key in keys")|{{foo[key]}}</template>
<script>exportdefault{data:()=>{return{reservations:{},keys:[]}}}</script>

exportdefault{data:()=>{return{foo:{}}},methods:{addFoo:function(key,hoge){this.$set(this.foo,`key`,hoge);}}

methods:{deleteFoo:function(key){this.$delete(this.foo,key);}}

methods:{token(){constmeta=document.querySelector('meta[name="csrf-token"]')returnmeta?meta.getAttribute('content'):''},getFoo:function(){fetch(`/api/hogehoge`,{method:'POST',headers:{'Content-Type':'application/json; charset=utf-8','X-Requested-With':'XMLHttpRequest','X-CSRF-Token':this.token()},credentials:'same-origin',redirect:'manual',}).then(response=>{returnresponse.json();}).then(json=>{this.$set(this.foo,`key`,json);// 👈受け取った値を連想配列`foo`に入れる}).catch(error=>{console.warn('Failed to parsing',error);})},

letarray=["name","id","pw","emal"];//配列の長さを取得console.log(array.length);//4//配列の１個目を取得console.log(array[1]);//"name"//"pw"が配列内の何個目にあるか知りたいconstresult=$.inArray("pw",array);console.log(result);//2

letarary={name:"鈴木",id:"1111",pw:"aaaa",email:"test@test.com"}//配列内のkey名取得constkey=Object.keys(array);console.log(key);//["name", "id", "pw", "email"]//nameというkeyのvalueを取得console.log(array.name);//"鈴木"

letarray=[{name:"鈴木",id:"1111",pw:"aaaa",email:"test@test.com"},{name:"田中",id:"2222",pw:"bbbb",email:"test2@test2.com"},{name:"佐藤",id:"3333",pw:"cccc",email:"test3@test3.com"}];// 多次元配列内の１番目の連想配列を取得console.log(array[1]);//{name: "田中", id: "2222", pw: "bbbb", email: "test2@test2.com"}// 取得した連想配列の"name"keyのvalueを取得console.log(arryB[1].name);//"田中"

letarray=[{name:"鈴木",id:"1111",pw:"aaaa",email:"test@test.com"},{name:"田中",id:"2222",pw:"bbbb",email:"test2@test2.com"},{name:"佐藤",id:"3333",pw:"cccc",email:"test3@test3.com"}];// 多次元配列のキーを取得letkeyB=Object.keys(arryB);console.log(keyB);// ["0", "1", "2"]for(vari=0;i<key.length;i++){letall=(array[i])//多次元配列内の全ての連想配列を取得console.log(all);//取得した連想配列の"id"keyのvalueを取得console.log(all["id"]);//"1111","2222","3333"}

varlist={'mango':100,'orange':200,'apple':'','pineapple':'pen'};varbreakPoint=1;//←ここでブレイクポイントを打つ

containers >= 0.5.9

importqualifiedData.Map.StrictasMimportqualifiedData.SetasS

importqualifiedData.Map.StrictasM

fruits::[(String,Int)]fruits=[("apple",1),("orange",2),("banana",3),("peach",4),("cherry",5),("orange",6),("apple",7),("peach",8)]fruitsMap=M.fromListfruits

PreludeM>fruits[("apple",1),("orange",2),("banana",3),("peach",4),("cherry",5),("orange",6),("apple",7),("peach",8)]PreludeM>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]

fromList::Ordk=>[(k,a)]->Mapka

empty::Mapka

PreludeMMain>M.fromList[]==M.emptyTruePreludeM>M.fromList[("orange",3)]==M.emptyFalse

singleton::k->a->Mapka

PreludeM>M.singleton"peach"4==M.fromList[("peach",4)]TruePreludeM>M.singleton"peach"4==M.fromList[("peach",4),("oraneg",3)]False

lookup::Ordk=>k->Mapka->Maybea

PreludeMMain>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeMMain>M.lookup"orange"fruitsMapJust6PreludeMMain>M.lookup"beef"fruitsMapNothing

(!?)::Ordk=>Mapka->k->Maybea

PreludeMMain>fruitsMapM.!?"orange"Just6PreludeMMain>fruitsMapM.!?"beef"Nothing

(!)::Ordk=>Mapka->k->a

PreludeMMain>fruitsMapM.!"orange"6PreludeMMain>fruitsMapM.!"beef"***Exception:Map.!:givenkeyisnotanelementinthemapCallStack(fromHasCallStack):error,calledatlibraries/containers/containers/src/Data/Map/Internal.hs:627:17incontainers-0.6.2.1:Data.Map.Internal

insert::Ordk=>k->a->Mapka->Mapka

PreludeM>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeMMain>M.insert"grape"1fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("grape",1),("orange",6),("peach",8)]PreludeMMain>M.insert"orange"1fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",1),("peach",8)]PreludeMMain>M.insert"kiwi"10emptyfromList[("kiwi",10)]

delete::Ordk=>k->Mapka->Mapka

PreludeMMain>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeMMain>M.delete"orange"fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("peach",8)]PreludeMMain>M.delete"beef"fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]

member::Ordk=>k->Mapka->Bool

PreludeMMain>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeMMain>M.member"orange"fruitsMapTruePreludeMMain>M.member"beef"fruitsMapFalse

update::Ordk=>(a->Maybea)->k->Mapka->Mapka

PreludeM>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeM>M.update(\x->Just(x+100))"cherry"fruitsMapfromList[("apple",7),("banana",3),("cherry",105),("orange",6),("peach",8)]PreludeM>M.update(\x->Just(x+100))"beef"fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]

keys::Mapka->[k]

PreludeMMain>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeMMain>M.keysfruitsMap["apple","banana","cherry","orange","peach"]

elems::Mapka->[a]

PreludeMMain>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeMMain>M.elemsfruitsMap[7,3,5,6,8]

toList::Mapka->[(k,a)]

PreludeM>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeM>toListfruitsMap[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]

fromListWith::Ordk=>(a->a->a)->[(k,a)]->Mapka

PreludeM>fruits[("apple",1),("orange",2),("banana",3),("peach",4),("cherry",5),("orange",6),("apple",7),("peach",8)]PreludeM>M.fromListWith(++)$map(\(k,v)->(k,[v]))fruitsfromList[("apple",[7,1]),("banana",[3]),("cherry",[5]),("orange",[6,2]),("peach",[8,4])

PreludeM>M.fromListWith(+)fruitsfromList[("apple",8),("banana",3),("cherry",5),("orange",8),("peach",12)]

map::(a->b)->Mapka->MapkbmapKeys::Ordk2=>(k1->k2)->Mapk1a->Mapk2afoldl::(a->b->a)->a->Mapkb->a

PreludeM>fruitsMapfromList[("apple",7),("banana",3),("cherry",5),("orange",6),("peach",8)]PreludeM>M.map(+1)fruitsMapfromList[("apple",8),("banana",4),("cherry",6),("orange",7),("peach",9)]PreludeM>M.mapKeys("F."++)fruitsMapfromList[("F.apple",7),("F.banana",3),("F.cherry",5),("F.orange",6),("F.peach",8)]PreludeM>M.foldl(+)0fruitsMap29PreludeM>M.foldlWithKey(\acckv->acc++(k++"="++showv))[]fruitsMap"apple=7banana=3cherry=5orange=6peach=8"PreludeM>M.filter(>5)(fruitsMap)fromList[("apple",7),("orange",6),("peach",8)]PreludeM>M.filterWithKey(\x_->lengthx>5)fruitsMapfromList[("banana",3),("cherry",5),("orange",6)]