How to Create Objects in JavaScript: Full Guide

const user = {
  firstName: "Alice",
  lastName: "Johnson",
  age: 28,
  email: "alice@example.com",
  isActive: true
};
 
console.log(user.firstName); // "Alice"
console.log(user.age);       // 28

const config = {
  apiUrl: "https://api.example.com",
  timeout: 5000,
  retries: 3,
  debug: false
};
 
const searchParams = {
  query: "javascript objects",
  page: 1,
  limit: 20,
  sortBy: "relevance"
};

const name = "Alice";
const age = 28;
const role = "developer";
 
// Without shorthand
const userOld = { name: name, age: age, role: role };
 
// With shorthand (ES6)
const userNew = { name, age, role };
 
console.log(userNew); // { name: "Alice", age: 28, role: "developer" }

const field = "email";
const prefix = "user";
 
const obj = {
  [field]: "alice@example.com",
  [`${prefix}Name`]: "Alice",
  [`${prefix}Id`]: 42
};
 
console.log(obj.email);    // "alice@example.com"
console.log(obj.userName); // "Alice"
console.log(obj.userId);   // 42

function User(firstName, lastName, age) {
  this.firstName = firstName;
  this.lastName = lastName;
  this.age = age;
  this.isActive = true;
}
 
User.prototype.getFullName = function() {
  return `${this.firstName} ${this.lastName}`;
};
 
User.prototype.greet = function() {
  return `Hi, I'm ${this.getFullName()}, age ${this.age}`;
};
 
const alice = new User("Alice", "Johnson", 28);
const bob = new User("Bob", "Smith", 32);
 
console.log(alice.getFullName()); // "Alice Johnson"
console.log(bob.greet());         // "Hi, I'm Bob Smith, age 32"
console.log(alice instanceof User); // true

// WRONG: missing new
const broken = User("Charlie", "Brown", 25);
console.log(broken); // undefined (no return statement)
// In non-strict mode, firstName is now on the global object!
 
// Safe guard pattern
function SafeUser(name) {
  if (!(this instanceof SafeUser)) {
    return new SafeUser(name);
  }
  this.name = name;
}

class Product {
  constructor(name, price, category) {
    this.name = name;
    this.price = price;
    this.category = category;
    this.inStock = true;
  }
 
  getFormattedPrice() {
    return `$${this.price.toFixed(2)}`;
  }
 
  applyDiscount(percent) {
    this.price = this.price * (1 - percent / 100);
    return this;
  }
 
  toString() {
    return `${this.name} (${this.getFormattedPrice()})`;
  }
}
 
const laptop = new Product("MacBook Pro", 2499.99, "Electronics");
console.log(laptop.getFormattedPrice()); // "$2499.99"
 
laptop.applyDiscount(10);
console.log(laptop.toString()); // "MacBook Pro ($2249.99)"

class MathHelper {
  static PI = 3.14159265359;
 
  static circleArea(radius) {
    return MathHelper.PI * radius * radius;
  }
 
  static celsiusToFahrenheit(celsius) {
    return (celsius * 9) / 5 + 32;
  }
}
 
console.log(MathHelper.circleArea(5));          // 78.5398...
console.log(MathHelper.celsiusToFahrenheit(0)); // 32
// MathHelper.PI is accessible without creating an instance

const animal = {
  type: "Unknown",
  speak() {
    return `The ${this.type} makes a sound`;
  },
  describe() {
    return `I am a ${this.type}`;
  }
};
 
const dog = Object.create(animal);
dog.type = "Dog";
dog.bark = function() {
  return "Woof!";
};
 
console.log(dog.speak());    // "The Dog makes a sound"
console.log(dog.bark());     // "Woof!"
console.log(dog.describe()); // "I am a Dog"
 
// Prototype chain verification
console.log(Object.getPrototypeOf(dog) === animal); // true

const base = { role: "user" };
 
const admin = Object.create(base, {
  name: {
    value: "Admin",
    writable: true,
    enumerable: true,
    configurable: true
  },
  level: {
    value: 10,
    writable: false,
    enumerable: true,
    configurable: false
  }
});
 
console.log(admin.name);  // "Admin"
console.log(admin.level); // 10
console.log(admin.role);  // "user" (inherited from prototype)
 
admin.level = 20; // Silently fails (writable: false)
console.log(admin.level); // Still 10

function createUser(firstName, lastName, role) {
  const fullName = `${firstName} ${lastName}`;
 
  return {
    firstName,
    lastName,
    role,
    getFullName() {
      return fullName;
    },
    hasPermission(action) {
      const permissions = {
        admin: ["read", "write", "delete"],
        editor: ["read", "write"],
        viewer: ["read"]
      };
      return (permissions[role] || []).includes(action);
    }
  };
}
 
const admin = createUser("Alice", "Johnson", "admin");
const viewer = createUser("Bob", "Smith", "viewer");
 
console.log(admin.getFullName());         // "Alice Johnson"
console.log(admin.hasPermission("delete")); // true
console.log(viewer.hasPermission("write")); // false

function createBankAccount(owner, initialBalance) {
  let balance = initialBalance; // Truly private
  const transactions = [];      // Truly private
 
  return {
    owner,
    getBalance() {
      return balance;
    },
    deposit(amount) {
      if (amount <= 0) throw new Error("Deposit must be positive");
      balance += amount;
      transactions.push({ type: "deposit", amount, date: new Date() });
      return balance;
    },
    withdraw(amount) {
      if (amount <= 0) throw new Error("Withdrawal must be positive");
      if (amount > balance) throw new Error("Insufficient funds");
      balance -= amount;
      transactions.push({ type: "withdrawal", amount, date: new Date() });
      return balance;
    },
    getTransactionHistory() {
      return [...transactions]; // Return copy, not reference
    }
  };
}
 
const account = createBankAccount("Alice", 1000);
account.deposit(500);
account.withdraw(200);
console.log(account.getBalance()); // 1300
console.log(account.balance);      // undefined (truly private!)

const obj1 = new Object();
obj1.name = "Alice";
obj1.age = 28;
 
// Equivalent to:
const obj2 = {};
obj2.name = "Alice";
obj2.age = 28;
 
// Object literal is preferred (shorter and clearer):
const obj3 = { name: "Alice", age: 28 };

const defaults = {
  theme: "light",
  language: "en",
  notifications: true,
  fontSize: 16
};
 
const userPreferences = {
  theme: "dark",
  fontSize: 18
};
 
const settings = Object.assign({}, defaults, userPreferences);
console.log(settings);
// { theme: "dark", language: "en", notifications: true, fontSize: 18 }

const settings = { ...defaults, ...userPreferences };

const API_CONFIG = Object.freeze({
  baseUrl: "https://api.example.com",
  version: "v2",
  timeout: 5000
});
 
API_CONFIG.timeout = 10000; // Silently fails (frozen)
console.log(API_CONFIG.timeout); // Still 5000

// WRONG: mutating a shared prototype
const proto = { items: [] };
const a = Object.create(proto);
const b = Object.create(proto);
 
a.items.push("task 1");
console.log(b.items); // ["task 1"] - both share the SAME array!
 
// CORRECT: initialize own properties
const c = Object.create(proto);
c.items = []; // Own property shadows prototype
c.items.push("task 1");
console.log(proto.items); // [] - prototype unchanged

// Inefficient: creates new method copies each iteration
const users = [];
for (let i = 0; i < 1000; i++) {
  users.push({
    id: i,
    getName() { return `User ${this.id}`; } // 1000 copies of this function
  });
}
 
// Better: use a class or constructor (shared methods via prototype)
class User {
  constructor(id) { this.id = id; }
  getName() { return `User ${this.id}`; } // One copy shared by all instances
}
 
const betterUsers = [];
for (let i = 0; i < 1000; i++) {
  betterUsers.push(new User(i));
}

class FormField {
  constructor(name, type, options = {}) {
    this.name = name;
    this.type = type;
    this.required = options.required || false;
    this.defaultValue = options.defaultValue || "";
    this.validators = options.validators || [];
  }
 
  validate(value) {
    if (this.required && !value) {
      return { valid: false, error: `${this.name} is required` };
    }
    for (const validator of this.validators) {
      const result = validator(value);
      if (!result.valid) return result;
    }
    return { valid: true, error: null };
  }
}
 
function createContactForm() {
  const fields = [
    new FormField("name", "text", { required: true }),
    new FormField("email", "email", {
      required: true,
      validators: [
        (val) => ({
          valid: val.includes("@"),
          error: "Invalid email format"
        })
      ]
    }),
    new FormField("message", "textarea", {
      required: true,
      validators: [
        (val) => ({
          valid: val.length >= 10,
          error: "Message must be at least 10 characters"
        })
      ]
    }),
    new FormField("phone", "tel", { required: false })
  ];
 
  return {
    fields,
    validateAll(data) {
      const errors = {};
      for (const field of fields) {
        const result = field.validate(data[field.name]);
        if (!result.valid) errors[field.name] = result.error;
      }
      return {
        valid: Object.keys(errors).length === 0,
        errors
      };
    }
  };
}
 
const form = createContactForm();
const result = form.validateAll({
  name: "Alice",
  email: "invalid",
  message: "Hi",
  phone: ""
});
 
console.log(result);
// { valid: false, errors: { email: "Invalid email format", message: "Message must be at least 10 characters" } }