🗂️ Lesson 5.2: Dictionaries, Objects, and Maps

# Python uses "dictionaries" (dict) — curly braces with key: value
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
    "is_student": False
}

# Empty dictionary
empty = {}
# or: empty = dict()

# From a list of pairs
pairs = dict([("a", 1), ("b", 2), ("c", 3)])

# From keyword arguments
settings = dict(theme="dark", font_size=16, language="en")

print(person)
print(type(person))   # <class 'dict'>
print(len(person))    # 4 (number of key-value pairs)

// JavaScript uses "objects" — curly braces with key: value
let person = {
    name: "Alice",          // Keys don't need quotes (if valid identifiers)
    age: 30,
    city: "New York",
    isStudent: false
};

// Empty object
let empty = {};

// Keys with special characters need quotes:
let config = {
    "font-size": 16,       // Hyphens need quotes
    "max retries": 3       // Spaces need quotes
};

console.log(person);
console.log(typeof person);          // 'object'
console.log(Object.keys(person).length);  // 4

// C# uses Dictionary<TKey, TValue> — strongly typed
Dictionary<string, object> person = new Dictionary<string, object>
{
    { "name", "Alice" },
    { "age", 30 },
    { "city", "New York" },
    { "isStudent", false }
};

// More commonly, use a specific value type:
Dictionary<string, string> capitals = new Dictionary<string, string>
{
    { "France", "Paris" },
    { "Japan", "Tokyo" },
    { "Brazil", "Brasilia" }
};

// Empty dictionary
Dictionary<string, int> empty = new Dictionary<string, int>();

Console.WriteLine(capitals.Count);  // 3

person = {"name": "Alice", "age": 30, "city": "New York"}

# Bracket notation
print(person["name"])   # "Alice"
print(person["age"])    # 30

# ❌ Missing key = KeyError
# print(person["email"])  # KeyError: 'email'

# Safe access with .get() — returns None (or a default) if missing
print(person.get("email"))           # None
print(person.get("email", "N/A"))    # "N/A" (custom default)
print(person.get("name", "N/A"))     # "Alice" (key exists, returns value)

# .get() is the preferred way to access when key might not exist

let person = { name: "Alice", age: 30, city: "New York" };

// Dot notation (most common)
console.log(person.name);    // "Alice"
console.log(person.age);     // 30

// Bracket notation (required for special keys or variables)
console.log(person["city"]); // "New York"

let key = "name";
console.log(person[key]);    // "Alice" (dynamic key lookup)

// Missing key = undefined (not an error!)
console.log(person.email);           // undefined
console.log(person.email ?? "N/A");  // "N/A" (nullish coalescing)

// Optional chaining for nested access (safe)
console.log(person.address?.street);  // undefined (no error)

Dictionary<string, string> person = new Dictionary<string, string>
{
    { "name", "Alice" },
    { "age", "30" },
    { "city", "New York" }
};

// Bracket notation
Console.WriteLine(person["name"]);   // "Alice"
Console.WriteLine(person["age"]);    // "30"

// ❌ Missing key = KeyNotFoundException
// Console.WriteLine(person["email"]);

// Safe access with TryGetValue
if (person.TryGetValue("email", out string? email))
{
    Console.WriteLine(email);
}
else
{
    Console.WriteLine("N/A");  // "N/A"
}

// Or use GetValueOrDefault (with newer C#):
string city = person.GetValueOrDefault("city", "Unknown");
Console.WriteLine(city);  // "New York"

person = {"name": "Alice", "age": 30}

# Add a new key
person["email"] = "alice@example.com"
print(person)
# {'name': 'Alice', 'age': 30, 'email': 'alice@example.com'}

# Update an existing key
person["age"] = 31
print(person["age"])  # 31

# Add/update multiple keys at once
person.update({
    "city": "Boston",
    "age": 32,           # Updates existing
    "job": "developer"   # Adds new
})
print(person)

# Merge two dicts (Python 3.9+)
defaults = {"theme": "light", "language": "en"}
overrides = {"theme": "dark", "font_size": 16}
merged = defaults | overrides
print(merged)  # {'theme': 'dark', 'language': 'en', 'font_size': 16}

let person = { name: "Alice", age: 30 };

// Add a new key
person.email = "alice@example.com";
// or: person["email"] = "alice@example.com";
console.log(person);

// Update an existing key
person.age = 31;
console.log(person.age);  // 31

// Add/update multiple keys (spread operator)
person = {
    ...person,
    city: "Boston",
    age: 32,
    job: "developer"
};

// Merge two objects
let defaults = { theme: "light", language: "en" };
let overrides = { theme: "dark", fontSize: 16 };
let merged = { ...defaults, ...overrides };
console.log(merged);  // {theme: 'dark', language: 'en', fontSize: 16}

// Object.assign also works:
// let merged = Object.assign({}, defaults, overrides);

Dictionary<string, string> person = new Dictionary<string, string>
{
    { "name", "Alice" },
    { "age", "30" }
};

// Add a new key
person["email"] = "alice@example.com";
// or: person.Add("email", "alice@example.com");
// ⚠️ .Add() throws if key already exists; [] overwrites silently

// Update an existing key
person["age"] = "31";

// Add/update multiple — no built-in merge, use a loop:
var updates = new Dictionary<string, string>
{
    { "city", "Boston" },
    { "age", "32" },
    { "job", "developer" }
};

foreach (var kvp in updates)
{
    person[kvp.Key] = kvp.Value;  // Adds or updates
}

Console.WriteLine(string.Join(", ",
    person.Select(kvp => $"{kvp.Key}: {kvp.Value}")));

person = {"name": "Alice", "age": 30, "city": "NYC", "email": "a@b.com"}

# Remove by key and get the value
removed = person.pop("email")
print(removed)  # "a@b.com"
print(person)   # No more 'email' key

# Safe removal (returns default if key missing)
missing = person.pop("phone", "not found")
print(missing)  # "not found" (no error)

# Remove by key (no return value)
del person["city"]
print(person)   # {'name': 'Alice', 'age': 30}

# Remove and get the last inserted pair
last_key, last_val = person.popitem()
print(f"Removed: {last_key} = {last_val}")

# Clear everything
person.clear()
print(person)   # {}

let person = { name: "Alice", age: 30, city: "NYC", email: "a@b.com" };

// Remove by key
delete person.email;
console.log(person);  // No more 'email'

// delete returns true/false (but doesn't give you the value)
let existed = delete person.city;
console.log(existed);  // true

// To get the value before deleting:
let { age, ...rest } = person;  // Destructure: age gets the value, rest is the remainder
console.log(age);    // 30
console.log(rest);   // { name: "Alice" }

// Clear everything (reassign)
person = {};
// or: Object.keys(person).forEach(k => delete person[k]);

Dictionary<string, string> person = new Dictionary<string, string>
{
    { "name", "Alice" },
    { "age", "30" },
    { "city", "NYC" },
    { "email", "a@b.com" }
};

// Remove by key (returns true if found, false if not)
bool removed = person.Remove("email");
Console.WriteLine(removed);  // True

// Remove and get the value
if (person.Remove("city", out string? cityValue))
{
    Console.WriteLine($"Removed city: {cityValue}");  // "NYC"
}

// Remove missing key — no error, just returns false
bool notFound = person.Remove("phone");
Console.WriteLine(notFound);  // False

// Clear everything
person.Clear();
Console.WriteLine(person.Count);  // 0

person = {"name": "Alice", "age": 30, "city": "NYC"}

# Check if key exists
print("name" in person)     # True
print("email" in person)    # False
print("email" not in person)  # True

# Common pattern: check then access
if "email" in person:
    print(person["email"])
else:
    print("No email on file")

# Or just use .get() (usually simpler)
email = person.get("email", "No email on file")
print(email)

# Get all keys, values, or pairs
print(list(person.keys()))    # ['name', 'age', 'city']
print(list(person.values()))  # ['Alice', 30, 'NYC']
print(list(person.items()))   # [('name','Alice'), ('age',30), ('city','NYC')]

let person = { name: "Alice", age: 30, city: "NYC" };

// Check if key exists
console.log("name" in person);                // true
console.log("email" in person);               // false
console.log(person.hasOwnProperty("name"));   // true

// Check then access
if ("email" in person) {
    console.log(person.email);
} else {
    console.log("No email on file");
}

// Or use nullish coalescing
let email = person.email ?? "No email on file";

// Get all keys, values, or pairs
console.log(Object.keys(person));    // ['name', 'age', 'city']
console.log(Object.values(person));  // ['Alice', 30, 'NYC']
console.log(Object.entries(person)); // [['name','Alice'], ['age',30], ...]

Dictionary<string, string> person = new Dictionary<string, string>
{
    { "name", "Alice" },
    { "age", "30" },
    { "city", "NYC" }
};

// Check if key exists
Console.WriteLine(person.ContainsKey("name"));    // True
Console.WriteLine(person.ContainsKey("email"));   // False

// Check if value exists
Console.WriteLine(person.ContainsValue("Alice")); // True

// Check then access
if (person.ContainsKey("email"))
    Console.WriteLine(person["email"]);
else
    Console.WriteLine("No email on file");

// Or use TryGetValue (more efficient — single lookup)
if (person.TryGetValue("email", out string? val))
    Console.WriteLine(val);
else
    Console.WriteLine("No email on file");

// Get all keys, values, or pairs
Console.WriteLine(string.Join(", ", person.Keys));    // name, age, city
Console.WriteLine(string.Join(", ", person.Values));  // Alice, 30, NYC

scores = {"Alice": 95, "Bob": 87, "Charlie": 92}

# Iterate over keys (default)
for name in scores:
    print(name)  # Alice, Bob, Charlie

# Iterate over values
for score in scores.values():
    print(score)  # 95, 87, 92

# Iterate over key-value pairs (most common)
for name, score in scores.items():
    print(f"{name}: {score}")
# Alice: 95
# Bob: 87
# Charlie: 92

# Dict comprehension (like list comprehension!)
doubled = {name: score * 2 for name, score in scores.items()}
print(doubled)  # {'Alice': 190, 'Bob': 174, 'Charlie': 184}

# Filter with dict comprehension
honor_roll = {name: score for name, score in scores.items() if score >= 90}
print(honor_roll)  # {'Alice': 95, 'Charlie': 92}

let scores = { Alice: 95, Bob: 87, Charlie: 92 };

// for...in loop (iterates over keys)
for (let name in scores) {
    console.log(`${name}: ${scores[name]}`);
}

// Object.entries() with for...of (cleaner)
for (let [name, score] of Object.entries(scores)) {
    console.log(`${name}: ${score}`);
}

// Object.keys() and Object.values()
Object.keys(scores).forEach(name => console.log(name));
Object.values(scores).forEach(score => console.log(score));

// Transform into a new object (no built-in comprehension)
let doubled = Object.fromEntries(
    Object.entries(scores).map(([name, score]) => [name, score * 2])
);
console.log(doubled);  // {Alice: 190, Bob: 174, Charlie: 184}

// Filter
let honorRoll = Object.fromEntries(
    Object.entries(scores).filter(([_, score]) => score >= 90)
);
console.log(honorRoll);  // {Alice: 95, Charlie: 92}

Dictionary<string, int> scores = new Dictionary<string, int>
{
    { "Alice", 95 },
    { "Bob", 87 },
    { "Charlie", 92 }
};

// foreach over key-value pairs
foreach (KeyValuePair<string, int> kvp in scores)
{
    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
}

// Shorthand with var
foreach (var (name, score) in scores)
{
    Console.WriteLine($"{name}: {score}");
}

// Iterate keys or values
foreach (string name in scores.Keys)
    Console.WriteLine(name);

foreach (int score in scores.Values)
    Console.WriteLine(score);

// Transform with LINQ
var doubled = scores.ToDictionary(
    kvp => kvp.Key,
    kvp => kvp.Value * 2
);

// Filter with LINQ
var honorRoll = scores
    .Where(kvp => kvp.Value >= 90)
    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
Console.WriteLine(string.Join(", ",
    honorRoll.Select(kvp => $"{kvp.Key}: {kvp.Value}")));

# Python only has dict — it handles everything
# No need to choose between two types

scores = {}
scores["Alice"] = 95
scores[42] = "numeric key"   # Any hashable type as key
scores[(1, 2)] = "tuple key" # Even tuples work!

print(len(scores))  # 3

# Python dicts are already ordered (insertion order, since 3.7)
# Python dicts already support any hashable key
# Python dicts already have a clean iteration API

# So Python's dict = best of both JS objects and Maps

// OBJECTS: Great for structured data (like a person or config)
let person = { name: "Alice", age: 30 };
person.email = "alice@example.com";

// MAP: Great for dynamic key-value storage
let scores = new Map();
scores.set("Alice", 95);
scores.set("Bob", 87);
scores.set(42, "numeric key!");    // Non-string keys work!
scores.set(true, "boolean key!");  // Any type as key!

console.log(scores.get("Alice"));  // 95
console.log(scores.size);          // 4
console.log(scores.has("Bob"));    // true

scores.delete("Bob");
console.log(scores.size);          // 3

// Iterating a Map
for (let [key, value] of scores) {
    console.log(`${key} => ${value}`);
}

// WHEN TO USE WHICH:
// Object: structured data with known string keys (person, config, API response)
// Map: dynamic lookups, non-string keys, frequent add/delete, need .size

// C# Dictionary<TKey, TValue> handles both use cases
// Keys can be any type (like JS Maps)

Dictionary<string, int> stringKeys = new Dictionary<string, int>
{
    { "Alice", 95 },
    { "Bob", 87 }
};

Dictionary<int, string> intKeys = new Dictionary<int, string>
{
    { 1, "first" },
    { 42, "answer" }
};

// C# also has SortedDictionary (keeps keys sorted)
SortedDictionary<string, int> sorted = new SortedDictionary<string, int>
{
    { "Charlie", 92 },
    { "Alice", 95 },
    { "Bob", 87 }
};

foreach (var kvp in sorted)
    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
// Alice: 95, Bob: 87, Charlie: 92 (alphabetical!)

# A student record with nested data
student = {
    "name": "Alice",
    "grades": {
        "math": 95,
        "english": 88,
        "science": 92
    },
    "hobbies": ["reading", "chess", "hiking"],
    "address": {
        "street": "123 Main St",
        "city": "Boston",
        "state": "MA"
    }
}

# Access nested values by chaining keys
print(student["grades"]["math"])      # 95
print(student["hobbies"][0])          # "reading"
print(student["address"]["city"])     # "Boston"

# Modify nested values
student["grades"]["english"] = 91
student["hobbies"].append("coding")

# Safe nested access
phone = student.get("contact", {}).get("phone", "N/A")
print(phone)  # "N/A"

let student = {
    name: "Alice",
    grades: {
        math: 95,
        english: 88,
        science: 92
    },
    hobbies: ["reading", "chess", "hiking"],
    address: {
        street: "123 Main St",
        city: "Boston",
        state: "MA"
    }
};

// Access nested values
console.log(student.grades.math);       // 95
console.log(student.hobbies[0]);        // "reading"
console.log(student.address.city);      // "Boston"

// Modify nested values
student.grades.english = 91;
student.hobbies.push("coding");

// Safe nested access with optional chaining
let phone = student.contact?.phone ?? "N/A";
console.log(phone);  // "N/A"

// Destructure nested objects
let { name, grades: { math }, address: { city } } = student;
console.log(`${name} got ${math} in math, lives in ${city}`);

// C# typically models complex data with classes (Module 6),
// but nested dictionaries work too:

var student = new Dictionary<string, object>
{
    { "name", "Alice" },
    { "grades", new Dictionary<string, int>
        {
            { "math", 95 },
            { "english", 88 },
            { "science", 92 }
        }
    },
    { "hobbies", new List<string> { "reading", "chess", "hiking" } },
    { "address", new Dictionary<string, string>
        {
            { "street", "123 Main St" },
            { "city", "Boston" },
            { "state", "MA" }
        }
    }
};

// Access nested values (requires casting)
var grades = (Dictionary<string, int>)student["grades"];
Console.WriteLine(grades["math"]);  // 95

var hobbies = (List<string>)student["hobbies"];
Console.WriteLine(hobbies[0]);  // "reading"

// This casting is clunky — it's why C# prefers classes for nested data.
// We'll learn a much cleaner approach in Module 6!