JavaScript Object Interview Questions

Creating objects — four ways

// 1. Object literal — most common
const user = {
  name: 'Alice',
  age: 30,
  greet() { return `Hi, I'm ${this.name}` }
}

// 2. Object.create(proto) — set prototype explicitly
const base = { greet() { return `Hi, I'm ${this.name}` } }
const user = Object.create(base)
user.name = 'Alice'

// 3. Constructor function / class
class User {
  constructor(name, age) { this.name = name; this.age = age }
}
const user = new User('Alice', 30)

// 4. Object.fromEntries — build from key-value pairs
const fields = [['name', 'Alice'], ['age', 30]]
const user = Object.fromEntries(fields)  // { name: 'Alice', age: 30 }

Property shorthand, computed keys, getters, setters

const name = 'Alice'
const age  = 30

// Shorthand — variable name becomes the key
const user = { name, age }  // { name: 'Alice', age: 30 }

// Computed keys — any expression inside []
const field = 'email'
const user  = {
  [field]: 'alice@example.com',
  [`${field}Valid`]: true
}

// Getters and setters — computed properties with logic
const circle = {
  _r: 5,
  get radius()  { return this._r },
  set radius(r) {
    if (r < 0) throw new RangeError('Positive only')
    this._r = r
  },
  get area() { return Math.PI * this._r ** 2 }
}
circle.radius = 10
circle.area   // 314.159...

Property descriptors — the hidden layer

Every property has a descriptor with four attributes. Most developers never see these, but they control everything about how a property behaves.

const obj = { name: 'Alice' }

Object.getOwnPropertyDescriptor(obj, 'name')
// { value: 'Alice', writable: true, enumerable: true, configurable: true }
//   writable:     can the value be changed?
//   enumerable:   shows in for..in / Object.keys / JSON.stringify?
//   configurable: can descriptor be changed or property deleted?

// Define a hidden, read-only property
Object.defineProperty(obj, 'id', {
  value: 42,
  writable: false,    // read-only
  enumerable: false,  // hidden from Object.keys and JSON.stringify
  configurable: false // permanent
})

obj.id = 99          // silently fails (strict mode: TypeError)
obj.id               // 42 — unchanged
Object.keys(obj)     // ['name'] — id is non-enumerable
JSON.stringify(obj)  // '{"name":"Alice"}' — id excluded

Object immutability — three levels

const config = { host: 'localhost', port: 3000, db: { timeout: 5000 } }

// preventExtensions — no new properties
Object.preventExtensions(config)
config.host = 'prod'    // ✓ modify existing
config.newProp = 'x'    // ✗ can't add new

// seal — no add, no delete; existing writable props still mutable
Object.seal(config)
config.host = 'prod'    // ✓ still writable
delete config.host      // ✗ can't delete

// freeze — completely locked (SHALLOW)
Object.freeze(config)
config.host = 'changed' // ✗ nothing changes
config.db.timeout = 999 // ✓ nested object NOT frozen — still mutable!

// Deep freeze
function deepFreeze(obj) {
  Object.getOwnPropertyNames(obj).forEach(key => {
    const val = obj[key]
    if (val && typeof val === 'object') deepFreeze(val)
  })
  return Object.freeze(obj)
}

Copying and merging

const user = { name: 'Alice', address: { city: 'Mumbai' } }

// Shallow copy — two ways, same result
const copy1 = Object.assign({}, user)
const copy2 = { ...user }

// Shallow means nested objects are SHARED
copy2.address.city = 'Delhi'
user.address.city   // 'Delhi' — same reference!

// Deep clone options
const deep1 = JSON.parse(JSON.stringify(user))
// Limitations: loses functions, undefined, Date becomes string, no circular refs

const deep2 = structuredClone(user)
// Modern (2022+): handles Date, Map, Set, ArrayBuffer, circular refs
// Does NOT handle functions or class instances

// Merging — later keys win
const defaults = { theme: 'light', lang: 'en', timeout: 5000 }
const prefs    = { theme: 'dark' }
const config   = { ...defaults, ...prefs }
// { theme: 'dark', lang: 'en', timeout: 5000 }

Object utility methods — the full toolkit

const user = { name: 'Alice', age: 30, role: 'admin' }

Object.keys(user)    // ['name', 'age', 'role']  — own enumerable keys
Object.values(user)  // ['Alice', 30, 'admin']
Object.entries(user) // [['name','Alice'], ['age',30], ['role','admin']]

// fromEntries — inverse of entries; transform and rebuild
const sanitized = Object.fromEntries(
  Object.entries(user)
    .filter(([k]) => k !== 'role')         // remove role
    .map(([k, v]) => [k, String(v).trim()]) // trim all values
)
// { name: 'Alice', age: '30' }

// Checking properties
'name'  in user                // true  — own + prototype chain
Object.hasOwn(user, 'name')    // true  — own only (modern preferred API)
Object.hasOwn(user, 'toString') // false — inherited, not own

// Property exists but value is undefined:
const obj = { count: undefined }
obj.count === undefined         // true — but property EXISTS
Object.hasOwn(obj, 'count')     // true — confirms it exists
Object.hasOwn(obj, 'missing')   // false — this one doesn't exist

Optional chaining and nullish coalescing

const user = { profile: { address: { city: 'Mumbai' } } }

// Without optional chaining — crashes if anything is null/undefined
const city = user.profile.address.city  // fine here, but fragile

// Optional chaining — short-circuits at first null/undefined
const city    = user?.profile?.address?.city     // 'Mumbai'
const country = user?.profile?.address?.country  // undefined (no error)
const phone   = user?.contact?.phone             // undefined (contact missing)

// Methods and bracket notation
user?.getPermissions?.()  // calls only if method exists
user?.roles?.[0]          // first role only if roles is defined

// Nullish coalescing — default only for null/undefined (not 0, '', false)
const city    = user?.profile?.address?.city ?? 'Unknown'
const timeout = config?.timeout ?? 5000
const count   = data?.count ?? 0  // preserves 0 if explicitly set to 0
// vs || which replaces ALL falsy values — almost always wrong for defaults

Iteration order

// Property order rules (ES2015+):
// 1. Integer indices (array-like keys) — ascending numeric order
// 2. String keys — insertion order
// 3. Symbol keys — insertion order

const obj = {
  b: 2,
  a: 1,
  1: 'one',
  0: 'zero',
  c: 3
}

Object.keys(obj)  // ['0', '1', 'b', 'a', 'c']
// Integers first (sorted), then strings in insertion order

// for...in respects the same order
// JSON.stringify respects the same order