Why classes are introduced in Javascript - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use classes instead of functions?

In JavaScript, why were classes introduced when we already had functions?

A To replace all functions with a new syntax that does not support inheritance.

B To provide a clearer and simpler syntax for creating objects and handling inheritance.

C To make JavaScript run faster by removing prototypes.

D To prevent the use of objects and only allow primitive data types.

💡 Hint

Think about how classes help organize code and reuse features.

Classes give a simpler and more readable way to create objects and manage inheritance compared to using functions and prototypes directly.

❓ Predict Output

intermediate

Output of class vs function object creation

What is the output of this code?

Javascript

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

class Animal {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return `Hi, ${this.name}`;
  }
}

const p = new Person('Alice');
const a = new Animal('Dog');
console.log(p.greet());
console.log(a.greet());

A

Hello, Alice
Hello, Dog

B

Hi, Alice
Hello, Dog

C

Hello, Alice
Hi, Dog

D

Hi, Alice
Hi, Dog

💡 Hint

Look at how greet() is defined in each case.

The function Person uses prototype to define greet which returns 'Hello, name'. The class Animal defines greet as a method returning 'Hi, name'.

❓ Predict Output

advanced

What happens with inheritance in classes?

What is the output of this code?

Javascript

class Vehicle {
  constructor(type) {
    this.type = type;
  }
  describe() {
    return `This is a ${this.type}`;
  }
}

class Car extends Vehicle {
  constructor(type, brand) {
    super(type);
    this.brand = brand;
  }
  describe() {
    return `${super.describe()} of brand ${this.brand}`;
  }
}

const myCar = new Car('car', 'Toyota');
console.log(myCar.describe());

A TypeError: super.describe is not a function

B This is a Vehicle of brand Toyota

C This is a car

D This is a car of brand Toyota

💡 Hint

Check how super is used to call the parent method.

The Car class extends Vehicle and calls super.describe() to get 'This is a car', then adds 'of brand Toyota'.

🧠 Conceptual

advanced

Why classes improve code organization?

How do classes help organize code better compared to using only functions and objects?

A Classes group data and behavior together, making code easier to understand and reuse.

B Classes force all code to be written in one place, reducing modularity.

C Classes remove the need for variables and constants in code.

D Classes prevent the use of inheritance and polymorphism.

💡 Hint

Think about how classes bundle properties and methods.

Classes bundle related data (properties) and actions (methods) in one place, which helps keep code clean and easier to maintain.

❓ Predict Output

expert

Output of class with private fields and methods

What is the output of this code?

Javascript

class Counter {
  #count = 0;
  increment() {
    this.#count++;
  }
  getCount() {
    return this.#count;
  }
}

const c = new Counter();
c.increment();
c.increment();
console.log(c.getCount());
console.log(c.#count);

A

2
TypeError

B

2
undefined

C

2
0

D

2
SyntaxError

💡 Hint

Private fields cannot be accessed outside the class.

The private field #count can be accessed inside the class methods but trying to access c.#count outside causes a TypeError.

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