Introduction
A Base Class is a class that contains common properties and methods that can be shared by multiple child classes. Instead of writing the same code repeatedly, developers create a base class and allow other classes to inherit from it.
Base classes are an important part of abstraction because they define common functionality while allowing child classes to provide their own specific implementations.
In JavaScript, base classes are created using the class keyword, and child classes inherit from them using the extends keyword.
For automation engineers, base classes are widely used in Page Object Models (POM), browser utilities, API clients, database helpers, and reporting modules. Common functionality such as browser launch, page navigation, login, screenshots, and waiting for elements is placed inside a base class so that all child classes can reuse it.
In this tutorial, you’ll learn how to create and use base classes in Node.js.
What is a Base Class?
A Base Class is a parent class that provides common functionality for one or more child classes.
Child classes inherit the properties and methods of the base class and can also add their own features or override inherited methods.
Why Use Base Classes?
Base classes help developers:
-
Eliminate duplicate code.
-
Improve code reusability.
-
Simplify application design.
-
Support abstraction.
-
Improve maintainability.
-
Create scalable applications.
-
Organize related functionality.
Syntax
class Animal {
eat() {
console.log(
"Animal is eating."
);
}
}
class Dog extends Animal {
}
const dog =
new Dog();
dog.eat();
Example 1: Basic Base Class
class Animal {
eat() {
console.log(
"Animal is eating."
);
}
}
class Dog extends Animal {
}
const dog =
new Dog();
dog.eat();
Sample Output
Animal is eating.
The Dog class inherits the eat() method from the Animal base class.
Example 2: Base Class with Multiple Child Classes
class Vehicle {
start() {
console.log(
"Vehicle started."
);
}
}
class Car extends Vehicle {
}
class Bike extends Vehicle {
}
const car =
new Car();
const bike =
new Bike();
car.start();
bike.start();
Sample Output
Vehicle started.
Vehicle started.
Example 3: Base Class with Constructor
class Employee {
constructor(name) {
this.name = name;
}
displayName() {
console.log(this.name);
}
}
class Developer extends Employee {
}
const developer =
new Developer("Rahul");
developer.displayName();
Sample Output
Rahul
Example 4: Base Class with Overridden Method
class Animal {
sound() {
console.log(
"Animal makes a sound."
);
}
}
class Dog extends Animal {
sound() {
console.log(
"Dog barks."
);
}
}
const dog =
new Dog();
dog.sound();
Sample Output
Dog barks.
The child class overrides the method inherited from the base class.
Example 5: Real-World Example
Employee management system.
class Employee {
login() {
console.log(
"Employee logged in."
);
}
}
class Manager extends Employee {
}
class Tester extends Employee {
}
const manager =
new Manager();
const tester =
new Tester();
manager.login();
tester.login();
Sample Output
Employee logged in.
Employee logged in.
Automation Testing Example
Base classes are one of the most important components of automation frameworks.
Playwright Example
Reusable page functionality.
class BasePage {
openApplication() {
console.log(
"Opening application."
);
}
}
class LoginPage extends BasePage {
}
const page =
new LoginPage();
page.openApplication();
Selenium Example
Reusable browser methods.
class Browser {
launchBrowser() {
console.log(
"Launching browser."
);
}
}
class ChromeBrowser extends Browser {
}
const browser =
new ChromeBrowser();
browser.launchBrowser();
Cypress Example
Common page actions.
class BaseCommands {
visitHomePage() {
console.log(
"Visiting Home Page."
);
}
}
class DashboardPage extends BaseCommands {
}
const dashboard =
new DashboardPage();
dashboard.visitHomePage();
API Testing Example
Reusable API methods.
class BaseApi {
sendRequest() {
console.log(
"Sending API request."
);
}
}
class UserApi extends BaseApi {
}
const api =
new UserApi();
api.sendRequest();
Data-Driven Testing Example
Reusable test utilities.
class BaseTest {
loadTestData() {
console.log(
"Loading test data."
);
}
}
class LoginTest extends BaseTest {
}
const test =
new LoginTest();
test.loadTestData();
Common Mistakes
Duplicating Code in Child Classes
Avoid rewriting functionality that already exists in the base class.
Creating Large Base Classes
Keep base classes focused on common functionality. Avoid adding unrelated methods.
Overriding Methods Unnecessarily
Only override a base class method when the child class needs different behavior.
Best Practices
-
Store common functionality in the base class.
-
Keep base classes generic.
-
Use inheritance to reduce duplicate code.
-
Override methods only when necessary.
-
Use meaningful class names.
-
Keep child classes focused on specialized behavior.
-
Design reusable class hierarchies.
Conclusion
Base classes are the foundation of abstraction and inheritance in Object-Oriented Programming. They provide reusable functionality that can be shared across multiple child classes, reducing duplication and improving maintainability.
For automation engineers, base classes are essential for building scalable automation frameworks. They centralize common browser actions, page interactions, API requests, and utility methods, making test scripts cleaner and easier to maintain.
Understanding base classes is an important step toward designing reusable and professional Node.js applications.
Frequently Asked Questions (FAQs)
What is a base class?
A base class is a parent class that provides common properties and methods for child classes.
Why are base classes important?
They reduce duplicate code, improve reusability, and simplify application design.
Can multiple child classes inherit from one base class?
Yes. Multiple child classes can inherit common functionality from the same base class.
Can child classes override base class methods?
Yes. Child classes can override inherited methods to provide specialized behavior.
Why are base classes useful in automation testing?
They provide reusable methods for browser operations, page interactions, API requests, test utilities, and other common framework functionality.
Key Takeaways
-
A base class is a parent class.
-
Base classes contain common functionality.
-
Child classes inherit properties and methods from the base class.
-
Base classes reduce duplicate code.
-
They improve code reusability and maintainability.
-
Child classes can override inherited methods.
-
Base classes are widely used in Playwright, Selenium, Cypress, and API testing frameworks.
-
Keep base classes generic and reusable.
-
Use inheritance to build scalable applications.
-
Base classes are a key component of abstraction in Node.js.