BRUCE_FE JS Interview Notes - JS new, Prototype Chain and Class Implementation Analysis

// Function Constructor
function Person(name, age) {
  this.name = name;
  this.age = age;
}

// Prototype method - shared by all instances
Person.prototype.introduce = function() {
  return `I'm ${this.name}, ${this.age} years old`;
};

// Static method simulation
Person.createAnonymous = function () {
  return new Person('Anonymous', 0);
};

// Create instance
const john = new Person('John', 30);
console.log(john.introduce());   // "I'm John, 30 years old"

// Class Syntax (ES6+)
class Person {
  // Constructor
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  
  // Prototype methods (shared)  
  introduce() {
    return `I'm ${this.name}, ${this.age} years old`;
  }
  
  // Static method - attached to class, can be called without instantiation
  static createAnonymous() {
    return new Person('Anonymous', 0);
  }
}

// Create instance directly with new
const jane = new Person('Jane', 25);

// Call static method
const anonymous = Person.createAnonymous();

/* 
Differences between direct new vs static method instantiation:

1. Direct new:
   - Pros: Intuitive and clear, full control over parameters
   - Cons: Cannot encapsulate repeated logic, need to provide full parameters each time

2. Static method:
   - Pros: Encapsulates complex construction logic, provides default values, implements factory pattern
   - Pros: Can implement singleton pattern or object pool design patterns
   - Cons: Indirectness may reduce code readability

Practical applications:
- Static methods are more suitable when object creation logic is complex or needs to reuse specific configurations
- Common in API designs like React.createElement(), Array.from()
*/

// Prototype chain example
function Animal() {}
Animal.prototype.eat = function() { return 'Eating...'; };

function Dog() {}
// Set up prototype inheritance
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;  // Fix constructor
Dog.prototype.bark = function() { return 'Woof!'; };

const doggy = new Dog();
console.log(doggy.bark());  // "Woof!" - found in Dog.prototype
console.log(doggy.eat());   // "Eating..." - found in Animal.prototype

// Get prototype
Object.getPrototypeOf(obj);  // Alternative to obj.__proto__

// Set prototype
Object.setPrototypeOf(obj, prototype);  // Alternative to obj.__proto__ = prototype

// Create new object with specified prototype
Object.create(prototype);  // More direct than new

function Counter() {
  // Private variable
  let count = 0;
  
  // Public methods
  this.increment = function() {
    count++;
    return count;
  };
  
  this.decrement = function() {
    count--;
    return count;
  };
  
  this.getValue = function() {
    return count;
  };
}

const counter = new Counter();
console.log(counter.getValue());   // 0
counter.increment();
console.log(counter.getValue());   // 1
console.log(counter.count);        // undefined (cannot access directly)

class BankAccount {
  #balance = 0;  // Private field
  
  constructor(initialBalance) {
    if (initialBalance > 0) {
      this.#balance = initialBalance;
    }
  }
  
  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
      return true;
    }
    return false;
  }
  
  getBalance() {
    return this.#balance;
  }
}

const account = new BankAccount(100);
console.log(account.getBalance());  // 100
// console.log(account.#balance);   // SyntaxError: Private field