Objects: Named Bundles of Data

From Bee: Spread is shallow. {...obj} copies the top level only. Nested objects are still shared references. Use structuredClone for true copies.

What Is an Object?

An object (called a dictionary in Python and a HashMap in Java) groups related values under named keys. Where arrays answer "which one?" by position, objects answer by name.

Reading and Updating Fields

Two notations: dot notation (user.name) and bracket notation (user["name"]). Dot is shorter; brackets work when the key is dynamic.

Nested Objects

Object fields can themselves be objects or arrays. Real-world data is usually deeply nested: a user has an address; an address has a city; a city has a country.

Code Examples in Three Languages

let user = {
  name: "Aisha",
  age: 30,
  email: "a@example.com",
  address: { city: "Cairo", country: "EG" }
};

user.name;              // "Aisha"
user["age"];            // 30
user.address.city;      // "Cairo"

// Update / add
user.age = 31;
user.role = "admin";

// Iterate
for (const key in user) {
  console.log(key, user[key]);
}

user = {
    "name": "Aisha",
    "age": 30,
    "email": "a@example.com",
    "address": {"city": "Cairo", "country": "EG"}
}

user["name"]              # "Aisha"
user["address"]["city"]   # "Cairo"

# Update / add
user["age"] = 31
user["role"] = "admin"

# Iterate
for key, value in user.items():
    print(key, value)

// Java has no dict literal — use HashMap
Map<String, Object> user = new HashMap<>();
user.put("name", "Aisha");
user.put("age", 30);

user.get("name");      // "Aisha"
user.put("role", "admin");

for (Map.Entry<String, Object> e : user.entrySet()) {
    System.out.println(e.getKey() + ": " + e.getValue());
}

Best Practices

1. Use objects when fields have names; use arrays when you have many of the same kind.
2. Keep nesting shallow — flat data is easier to work with.
3. Use consistent key naming across your app (camelCase or snake_case, pick one).
4. Validate keys exist before reading — missing keys cause subtle bugs.

Common Mistakes

• Reading missing keys. Returns undefined in JS, raises KeyError in Python.
• Mixing key styles. user.firstName here, user.first_name there.
• Mutating a shared object. Two parts of the code edit the same object and step on each other.
• Deep clone confusion. const copy = obj doesn't copy — both names point to the same object.

How It Works Under the Hood

A JavaScript object is roughly a hash map: keys are strings (or Symbols), values are any. Reading user.name hashes the key and looks up the slot — constant time on average. Internally V8 uses "hidden classes" to speed up access patterns, which is why creating objects with the same shape (always the same keys in the same order) is faster than dynamically adding fields.

Python dicts and Java HashMaps work similarly. The trade-off is the same: very fast lookup, no order guarantee historically (Python 3.7+ preserves insertion order, JS preserves order for string keys).

Objects are passed by reference, not value. const a = {}; const b = a; creates two names for one object — modifying b.x shows up in a.x. This is the source of more beginner bugs than perhaps any other concept.

From Beginner to Pro

The same concept gets deeper as you grow. Here's what mastery looks like at three levels:

Performance & Gotchas

• Reference sharing — const b = a doesn't copy.
• Spread is shallow — nested values still share references.
• JSON loses functions, undefined, dates — be explicit about what serializes.
• Missing-key reads — undefined silently in JS, KeyError in Python.

Quick Quiz

Real-World Uses (Production Code, Today)

Frequently Asked Questions

Related Concepts