Object.keys, values, entries.
Three methods, three outputs.

Shape of each return value:

Object.keys(obj)
  → ['name', 'age', 'email']
  → string[]

Object.values(obj)
  → ['Alice', 30, 'alice@example.com']
  → any[]

Object.entries(obj)
  → [['name', 'Alice'], ['age', 30], ...]
  → [string, any][]

All three return ARRAYS.
So you can chain array methods:

const activeNames = Object.entries(users)
  .filter(([, user]) => user.active)
  .map(([id, user]) => user.name);

This is the reason these methods exist.
Objects don't have filter or map.
Convert to an array of entries, then use
array methods, then optionally convert back
with Object.fromEntries(entries).

Round-trip:

  const entries = Object.entries(obj);
  const back = Object.fromEntries(entries);
  // same as obj

Object.fromEntries(entries) is the inverse.
Very useful when you've transformed the
entries into a new shape.

Which one to use:

✅ Existence check:
   'key' in obj  (fastest, handles all own + inherited)
   obj.hasOwnProperty('key')  (own only)
   Object.keys(obj).includes('key')  (works, slower)
   
   Prefer `in` for existence.
   Only use Object.keys().includes() if you specifically
   want to check own enumerable properties.

✅ Get all values:
   Object.values(obj)
   
   Use when you don't need the keys.
   For example: summing all scores, mapping names.

✅ Iterate with keys and values:
   Object.entries(obj)
   
   Use when you need both.
   The destructuring pattern [key, value] is idiomatic.

✅ Transform:
   Object.fromEntries(Object.entries(obj).map(...))
   
   Use when you need to change the shape of an object.
   Very common in data pipelines.

✅ Get all keys:
   Object.keys(obj)
   
   Use when you need to do something with the keys
   themselves — sort them, filter them, compare sets.

The three methods return arrays.
So you chain array methods on them.
This is how you "iterate" an object in JS —
you don't. You convert to an array, then iterate
the array.

⚠️ Order of keys:
   Integer-like keys come first, in numeric order.
   Then string keys, in insertion order.
   Symbols are excluded entirely.
   For plain objects with string keys, insertion
   order is preserved.

⚠️ These methods don't include inherited properties.
   If you need them, use for...in with hasOwnProperty filter.
   But you almost never need them.

The difference:

for...in:
  → iterates own AND inherited enumerable properties
  → includes properties from the prototype chain
  → works on any object
  → can't be chained with array methods

Object.keys / values / entries:
  → iterate OWN enumerable properties only
  → excludes inherited properties
  → returns arrays
  → chainable with array methods

For plain objects created with {} or Object.assign,
they give the same result — no inherited properties.
The difference only matters when the object has a
custom prototype, or was created with Object.create.

The modern recommendation:
  Use Object.entries (or keys / values) for iteration.
  Use for...in only when you specifically want
  inherited properties (rare).
  If you must use for...in, always filter with
  hasOwnProperty — otherwise you'll include
  properties you didn't expect.

The hasOwnProperty fix:
  for (const key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      // process obj[key]
    }
  }

Why Object.prototype.hasOwnProperty.call(obj, key)?
  Some objects override hasOwnProperty.
  Using the prototype's version directly is safe.
  Or use Object.hasOwn(obj, key) — ES2022, cleaner.

  Object.hasOwn(obj, key) is the modern replacement.
  Use it in new code.

⚠️ for...in also iterates array indices as strings.
   for (const i in [1, 2, 3]) gives '0', '1', '2' (strings).
   Never use for...in on arrays — use for...of or forEach.