JavaScript Object Methods — Arrow Functions Break 'this'

// A plain object representing a user profile
const userProfile = {
  firstName: 'Sarah',
  lastName: 'Chen',
  age: 28,

  // This is a METHOD — a function stored as a property
  // 'this' refers to the userProfile object itself
  getFullName: function () {
    return this.firstName + ' ' + this.lastName;
  },

  // Modern shorthand syntax — does exactly the same thing
  // No 'function' keyword needed — cleaner and preferred in modern JS
  greet() {
    return 'Hi! My name is ' + this.getFullName() + ' and I am ' + this.age + ' years old.';
  },

  // A method that UPDATES the object's own data
  celebrateBirthday() {
    this.age = this.age + 1; // increment age on the object itself
    return 'Happy birthday, ' + this.firstName + '! You are now ' + this.age + '.';
  }
};

// Calling a method: objectName.methodName()
console.log(userProfile.getFullName());     // call getFullName method
console.log(userProfile.greet());           // call greet method
console.log(userProfile.celebrateBirthday()); // call celebrateBirthday — also changes age
console.log('Updated age:', userProfile.age); // confirm the age was actually updated

// A bank account object — notice how every method uses 'this'
// to access and modify the account's OWN data
const bankAccount = {
  ownerName: 'Marcus Johnson',
  balance: 1000,
  currency: 'USD',

  // 'this.balance' reads the balance from THIS specific object
  getBalance() {
    return this.ownerName + "'s balance: " + this.currency + ' ' + this.balance;
  },

  // 'this.balance' is updated — changes the object's own property
  deposit(amount) {
    if (amount <= 0) {
      return 'Deposit amount must be greater than zero.';
    }
    this.balance = this.balance + amount; // update THIS object's balance
    return 'Deposited ' + amount + '. New balance: ' + this.balance;
  },

  withdraw(amount) {
    if (amount > this.balance) {
      // 'this.balance' checks THIS account's funds — not some global variable
      return 'Insufficient funds. Current balance: ' + this.balance;
    }
    this.balance = this.balance - amount;
    return 'Withdrew ' + amount + '. Remaining balance: ' + this.balance;
  },

  // A method calling OTHER methods on the same object using 'this'
  printStatement() {
    return [
      '--- Account Statement ---',
      'Owner: ' + this.ownerName,
      this.getBalance()  // calling another method via 'this' is valid!
    ].join('\n');
  }
};

console.log(bankAccount.getBalance());
console.log(bankAccount.deposit(500));
console.log(bankAccount.withdraw(200));
console.log(bankAccount.withdraw(5000)); // try to overdraw
console.log(bankAccount.printStatement());

// A product in an online store
const laptopProduct = {
  name: 'ProBook 15',
  brand: 'TechCore',
  price: 1299,
  inStock: true,
  rating: 4.7
};

// Object.keys() — get all the property NAMES as an array
const propertyNames = Object.keys(laptopProduct);
console.log('Property names:', propertyNames);

// Object.values() — get all the property VALUES as an array
const propertyValues = Object.values(laptopProduct);
console.log('Property values:', propertyValues);

// Object.entries() — get [key, value] pairs — great for looping
const propertyPairs = Object.entries(laptopProduct);
console.log('Key-value pairs:', propertyPairs);

// Real-world use: loop over entries to display each field
console.log('\n--- Product Details ---');
Object.entries(laptopProduct).forEach(function ([key, value]) {
  // Destructure each [key, value] pair directly in the parameter
  console.log(key + ': ' + value);
});

// Object.assign() — copy properties from one object into another
// Useful for merging objects or creating shallow copies
const discountedProduct = Object.assign({}, laptopProduct, { price: 999, onSale: true });
// {} is the target (new empty object), laptopProduct is copied in, then overrides are applied
console.log('\nOriginal price:', laptopProduct.price);    // original unchanged
console.log('Discounted price:', discountedProduct.price); // new object has new price
console.log('On sale flag:', discountedProduct.onSale);    // new property added

// Object.freeze() — lock an object so nothing can change it
const appConfig = Object.freeze({
  apiUrl: 'https://api.example.com',
  version: '2.1.0',
  maxRetries: 3
});

appConfig.version = '9.9.9'; // silently fails in non-strict mode
console.log('\nConfig version (unchanged):', appConfig.version); // still 2.1.0

// Start with a plain data object — no methods, just properties
const movieRecord = {
  title: 'The Lost Horizon',
  director: 'Elena Vasquez',
  releaseYear: 2019,
  ratingOutOf10: 8.4,
  genre: 'Sci-Fi'
};

// Add a method to the existing object AFTER creation
// Just assign a function to a new property name
moviewRecord.getSummary = function () {
  return this.title + ' (' + this.releaseYear + ') — directed by ' + this.director;
};

// Oops — typo above. Let's do it correctly:
movieRecord.getSummary = function () {
  return this.title + ' (' + this.releaseYear + ') — directed by ' + this.director;
};

movieRecord.isHighlyRated = function () {
  // Returns true if rating is 8.0 or above
  return this.ratingOutOf10 >= 8.0;
};

movieRecord.getAgeOfFilm = function () {
  const currentYear = new Date().getFullYear(); // get the current year dynamically
  return currentYear - this.releaseYear + ' years old';
};

console.log(movieRecord.getSummary());
console.log('Highly rated?', movieRecord.isHighlyRated());
console.log('Film age:', movieRecord.getAgeOfFilm());

// Check if a method exists before calling it — safe practice
if (typeof movieRecord.getSummary === 'function') {
  console.log('getSummary method exists — safe to call');
}

// The 'in' operator checks for ANY property (including non-functions)
console.log('Has director property?', 'director' in movieRecord); // true
console.log('Has budget property?', 'budget' in movieRecord);     // false

// Delete a property (or method) from an object
console.log('\nBefore delete — genre:', movieRecord.genre); // Sci-Fi
delete movieRecord.genre;
console.log('After delete — genre:', movieRecord.genre);  // undefined

// See all current keys to confirm what's on the object
console.log('\nAll current keys:', Object.keys(movieRecord));

// A calculator object with chainable methods
const calculator = {
  value: 0,

  add(n) {
    this.value += n;
    return this; // enable chaining
  },

  subtract(n) {
    this.value -= n;
    return this;
  },

  multiply(n) {
    this.value *= n;
    return this;
  },

  getResult() {
    return this.value; // breaks the chain — returns a number
  }
};

// Chained calls — clean and readable
const result = calculator
  .add(10)
  .subtract(2)
  .multiply(3)
  .getResult();

console.log('Result:', result); // (10 - 2) * 3 = 24

// Without chaining — intermediate variables everywhere
const calc2 = { value: 0 };
calc2.value += 10;
calc2.value -= 2;
calc2.value *= 3;
console.log('Manual result:', calc2.value);

// Real-world: form builder using chaining
const formBuilder = {
  fields: [],
  addField(type, label) {
    this.fields.push({ type, label });
    return this;
  },
  build() {
    return this.fields;
  }
};

const myForm = formBuilder
  .addField('text', 'Name')
  .addField('email', 'Email')
  .addField('submit', 'Send')
  .build();

console.log('Form fields:', myForm);

// 1. Factory function — returns a new object with methods
function createUser(firstName, lastName, age) {
  return {
    firstName,
    lastName,
    age,
    getFullName() {
      return `${this.firstName} ${this.lastName}`;
    },
    canDrink() {
      // Age check based on US law — could be configurable
      return this.age >= 21;
    }
  };
}

const user1 = createUser('Alice', 'Smith', 30);
const user2 = createUser('Bob', 'Jones', 17);
console.log(user1.getFullName(), user1.canDrink()); // Alice Smith true
console.log(user2.getFullName(), user2.canDrink()); // Bob Jones false

// 2. Method that aggregates multiple data sources
const order = {
  items: [
    { name: 'Widget', price: 10, qty: 2 },
    { name: 'Gadget', price: 25, qty: 1 }
  ],
  discount: 5, // flat $ discount

  getSubtotal() {
    return this.items.reduce((sum, item) => sum + item.price * item.qty, 0);
  },
  getTotal() {
    return this.getSubtotal() - this.discount;
  },
  getSummary() {
    return `Order: $${this.getTotal()} (${this.items.length} items, discount $${this.discount})`;
  }
};

console.log(order.getSummary());

// 3. toJSON method — custom serialization
const user = {
  name: 'John',
  password: 'secret',
  role: 'admin',
  toJSON() {
    // Serialize only safe fields
    return {
      name: this.name,
      role: this.role
    };
  }
};

console.log(JSON.stringify(user)); // {"name":"John","role":"admin"}