The SOLID principles are a set of five design principles intended to make software designs more understandable, flexible, and maintainable. They are particularly useful in object-oriented programming (OOP). While JavaScript has evolved to support OOP paradigms, these principles apply well to JavaScript code, especially in modern frameworks and libraries. Here's a breakdown of each principle and how it translates to JavaScript:
1. Single Responsibility Principle (SRP):
- Definition: A class should have only one reason to change, meaning it should have only one job or responsibility.
- In JavaScript: Apply this to modules, objects, or functions. A module should focus on one specific task and have no unrelated responsibilities.
- Example:
```javascript
// Violates SRP: This class handles both user data and email sending
class User {
constructor(name, email) {
this.name = name;
this.email = email;
}
saveUser() {
// Code to save user data to a database
console.log('Saving user to database');
}
sendWelcomeEmail() {
// Code to send a welcome email
console.log('Sending welcome email');
}
}
// SRP Applied: Separated concerns into two different classes
class UserRepository {
saveUser(user) {
// Code to save user data to a database
console.log('Saving user to database');
}
}
class EmailService {
sendWelcomeEmail(user) {
// Code to send a welcome email
console.log('Sending welcome email');
}
}
```
- In the corrected example, `UserRepository` handles data persistence and `EmailService` handles email sending, making each class focused and easier to maintain.
2. Open/Closed Principle (OCP):
- Definition: Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means you should be able to add new functionality without changing existing code.
- In JavaScript: Use inheritance, composition, or strategy patterns to add functionality without altering existing functions or objects.
- Example:
```javascript
// Violates OCP: Each time a new shape is added, the areaCalculator needs modification
class AreaCalculator {
calculateArea(shapes) {
let area = 0;
for (let shape of shapes) {
if (shape instanceof Rectangle) {
area += shape.width shape.height;
} else if (shape instanceof Circle) {
area += Math.PI shape.radius shape.radius;
}
// Adding new shapes requires modification of this class
}
return area;
}
}
// OCP Applied: Abstract class and polymorphism allows extension without modification
class Shape {
area() {
throw new Error('Area method must be implemented.');
}
}
class Rectangle extends Shape {
constructor(width, height) {
super();
this.width = width;
this.height = height;
}
area() {
....
Log in to view the answer
