Why classes are introduced in Javascript - Performance Analysis

Time Complexity: Why classes are introduced

O(n)

Understanding Time Complexity

We want to understand how using classes affects the time it takes for JavaScript code to run.

Specifically, we ask: does introducing classes change how the program's work grows as input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

const people = [];
for (let i = 0; i < n; i++) {
  people.push(new Person(`Person ${i}`));
}

This code creates n Person objects and stores them in an array.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop creating new Person objects.
• How many times: Exactly n times, once per loop iteration.

How Execution Grows With Input

As n grows, the number of Person objects created grows the same way.

Input Size (n)	Approx. Operations
10	10 object creations
100	100 object creations
1000	1000 object creations

Pattern observation: The work grows directly with n, doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to create all objects grows in a straight line as the number of objects increases.

Common Mistake

[X] Wrong: "Using classes makes the code slower because of extra overhead."

[OK] Correct: Creating objects with classes still takes time proportional to how many objects you make, just like plain objects. The class syntax does not add hidden loops or repeated work.

Interview Connect

Understanding how classes affect time helps you explain your code choices clearly and shows you know how code structure relates to performance.

Self-Check

"What if we added a method inside the loop that does another loop over a fixed-size array? How would the time complexity change?"

Practice

1. Why were classes introduced in JavaScript?

easy

A. To remove the need for variables

B. To replace all functions with a new syntax

C. To make JavaScript run faster

D. To group data and related actions together in one place

Solution

1. Step 1: Understand the purpose of classes

   Classes help organize data and functions that belong together, making code easier to manage.

2. Step 2: Compare options with class purpose

   Only grouping data and actions matches the reason classes were introduced.

3. Final Answer:

   To group data and related actions together in one place -> Option D

4. Quick Check:

   Classes group data and actions = D [OK]

Hint: Classes bundle data and actions together [OK]

Common Mistakes:

• Thinking classes make code run faster
• Believing classes remove variables
• Confusing classes with replacing all functions

2. Which of the following is the correct way to define a class in JavaScript?

easy

A. var Car = () => { }

B. function Car() { }

C. class Car { constructor() { } }

D. class Car() { }

Solution

1. Step 1: Recall class syntax in JavaScript

   The correct syntax uses the keyword class followed by the class name and curly braces.

2. Step 2: Check each option

   class Car { constructor() { } } uses correct syntax with class Car { constructor() { } }. class Car() { } has wrong parentheses after class name.

3. Final Answer:

   class Car { constructor() { } } -> Option C

4. Quick Check:

   Correct class syntax = A [OK]

Hint: Class syntax uses 'class Name { constructor() {} }' [OK]

Common Mistakes:

• Adding parentheses after class name
• Using function syntax instead of class
• Confusing arrow functions with classes

3. What will be the output of this code?

class Dog {
  constructor(name) {
    this.name = name;
  }
  bark() {
    return `${this.name} says woof!`;
  }
}
const dog1 = new Dog('Buddy');
console.log(dog1.bark());

medium

A. "Buddy says woof!"

B. "dog1 says woof!"

C. undefined says woof!

D. Error: bark is not a function

Solution

1. Step 1: Understand class and method usage

   The class Dog sets the name property via constructor and bark() returns a string using that name.

2. Step 2: Trace the code execution

   dog1 is created with name 'Buddy'. Calling dog1.bark() returns 'Buddy says woof!'.

3. Final Answer:

   "Buddy says woof!" -> Option A

4. Quick Check:

   dog1.bark() = "Buddy says woof!" [OK]

Hint: Constructor sets name; bark() uses it in string [OK]

Common Mistakes:

• Expecting dog1 as name instead of 'Buddy'
• Thinking bark() is undefined
• Confusing method call syntax

4. Find the error in this class definition:

class Person {
  constructor(name) {
    this.name = name;
  }
  greet() {
    console.log('Hello, ' + name);
  }
}
const p = new Person('Alice');
p.greet();

medium

A. Missing 'this' before 'name' inside greet() method

B. Constructor is missing parentheses

C. Class name should be lowercase

D. greet() method should return a string, not console.log

Solution

1. Step 1: Check variable usage inside greet()

   The method uses name without this., so it looks for a local variable which does not exist.

2. Step 2: Identify correct property access

   It should use this.name to access the instance property.

3. Final Answer:

   Missing 'this' before 'name' inside greet() method -> Option A

4. Quick Check:

   Use this.name to access property [OK]

Hint: Use 'this.' to access class properties inside methods [OK]

Common Mistakes:

• Forgetting 'this' keyword
• Thinking constructor syntax is wrong
• Believing method must return instead of console.log

5. You want to create many similar objects representing books with title and author. Why is using a class better than creating separate objects manually?

hard

A. Classes make the code run faster than objects

B. Classes let you create many objects easily with shared structure and behavior

C. Classes automatically save objects to a database

D. Classes prevent any changes to the objects after creation

Solution

1. Step 1: Understand the benefit of classes for similar objects

   Classes provide a blueprint to create many objects with the same properties and methods easily.

2. Step 2: Compare options with class benefits

   Only Classes let you create many objects easily with shared structure and behavior correctly states that classes simplify creating many similar objects with shared structure and behavior.

3. Final Answer:

   Classes let you create many objects easily with shared structure and behavior -> Option B

4. Quick Check:

   Classes simplify creating many similar objects = A [OK]

Hint: Classes are blueprints for many similar objects [OK]

Common Mistakes:

• Thinking classes speed up code execution
• Believing classes save data automatically
• Assuming classes make objects immutable