Objects

Creating Objects

Object Literal

const person = {
  name: 'John',
  age: 30,
  greet() {
    return `Hello, ${this.name}`;
  }
};

Constructor Function

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.greet = function() {
    return `Hello, ${this.name}`;
  };
}

const john = new Person('John', 30);

Object.create

const proto = {
  greet() {
    return `Hello, ${this.name}`;
  }
};

const person = Object.create(proto);
person.name = 'John';

Class Syntax

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  
  greet() {
    return `Hello, ${this.name}`;
  }
}

const john = new Person('John', 30);

Computed Property Names

const key = 'name';
const person = {
  [key]: 'John',
  ['age']: 30,
  [`get${key.charAt(0).toUpperCase() + key.slice(1)}()`]() {
    return this[key];
  }
};

Shorthand Properties

const name = 'John';
const age = 30;

// Long
const person = { name: name, age: age };

// Shorthand
const person = { name, age };

Object Methods

Method Definition

const calculator = {
  value: 0,
  add(n) {
    this.value += n;
    return this;
  },
  subtract(n) {
    this.value -= n;
    return this;
  },
  result() {
    return this.value;
  }
};

// Method chaining
calculator.add(5).subtract(2).result(); // 3

this in Methods

const person = {
  name: 'John',
  greet() {
    console.log(this.name); // "John"
  }
};

person.greet(); // this is person

Getters and Setters

const person = {
  firstName: 'John',
  lastName: 'Doe',
  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  },
  set fullName(value) {
    const [first, last] = value.split(' ');
    this.firstName = first;
    this.lastName = last;
  }
};

console.log(person.fullName); // "John Doe" (getter)
person.fullName = 'Jane Smith'; // setter
console.log(person.firstName); // "Jane"

Computed Methods

const methods = {
  double: (x) => x * 2,
  triple: (x) => x * 3
};

const operation = 'double';
methods[operation](5); // 10

Object.assign

const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3 };

Object.assign(target, source1, source2);
console.log(target); // { a: 1, b: 2, c: 3 }

Spread Operator

const original = { a: 1, b: 2 };
const copy = { ...original };
const merged = { ...original, c: 3 };

console.log(merged); // { a: 1, b: 2, c: 3 }

Object Manipulation

Object.keys

const person = { name: 'John', age: 30 };

Object.keys(person); // ['name', 'age']

Object.values

Object.values(person); // ['John', 30]

Object.entries

Object.entries(person); // [['name', 'John'], ['age', 30]]

// Use with destructuring
for (const [key, value] of Object.entries(person)) {
  console.log(`${key}: ${value}`);
}

Object.fromEntries

const entries = [['name', 'John'], ['age', 30]];
Object.fromEntries(entries); // { name: 'John', age: 30 }

hasOwnProperty

const person = { name: 'John' };

person.hasOwnProperty('name'); // true
person.hasOwnProperty('toString'); // false

// Better: use 'in' operator
'name' in person; // true
'toString' in person; // true (inherited)

Delete Operator

const person = { name: 'John', age: 30 };
delete person.age;
console.log(person); // { name: 'John' }

Spread vs Object.assign

// Object.assign (mutates target)
const target = { a: 1 };
Object.assign(target, { b: 2 });

// Spread (creates new object)
const original = { a: 1 };
const copy = { ...original, b: 2 };

Deep Copy

// Shallow copy
const shallow = { ...original };

// Deep copy
const deep = JSON.parse(JSON.stringify(original));

// Modern deep copy
const deep = structuredClone(original);

Object.freeze

const frozen = Object.freeze({ name: 'John' });
frozen.name = 'Jane'; // Silently fails (or throws in strict)
console.log(frozen.name); // "John"

Object.seal

const sealed = Object.seal({ name: 'John' });
sealed.name = 'Jane'; // Can modify existing
sealed.age = 30;      // Cannot add new
console.log(sealed); // { name: 'Jane' }