Why classes are introduced in Javascript

Introduction

Classes were introduced to make it easier to create and organize objects that share similar features and actions. They help group related code together in a clear and simple way.

When you want to create many objects with the same properties and behaviors, like multiple cars or users.

When you want to organize your code better by grouping data and functions that belong together.

When you want to reuse code easily without writing the same code again and again.

When you want to model real-world things in your program, like animals, books, or bank accounts.

Syntax

Javascript

class ClassName {
  constructor(parameters) {
    // initialize properties
  }

  methodName() {
    // actions or behaviors
  }
}

The constructor is a special function that runs when you create a new object.

Methods inside the class define what the objects can do.

Examples

This class creates car objects with make and model, and a method to show the car details.

Javascript

class Car {
  constructor(make, model) {
    this.make = make;
    this.model = model;
  }

  display() {
    console.log(`Car: ${this.make} ${this.model}`);
  }
}

This class creates person objects with a name and a greeting method.

Javascript

class Person {
  constructor(name) {
    this.name = name;
  }

  greet() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

Sample Program

This program creates a Dog class with name and breed. It has a bark method that prints a message. We create a dog named Buddy and call bark.

Javascript

class Dog {
  constructor(name, breed) {
    this.name = name;
    this.breed = breed;
  }

  bark() {
    console.log(`${this.name} says Woof!`);
  }
}

const myDog = new Dog('Buddy', 'Golden Retriever');
myDog.bark();

Important Notes

Classes are a cleaner way to create objects compared to older methods like functions and prototypes.

Using classes helps keep your code organized and easier to understand.

Summary

Classes group data and actions together in one place.

They make creating many similar objects simple and clear.

Classes help model real-world things in code.

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