JavaScript में SOLID सिद्धांत: सिद्धांत और व्यवहार

JavaScript में SOLID सिद्धांतों का परिचय

SOLID — पाँच मौलिक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग सिद्धांतों का एक संक्षिप्त नाम है, जिसे रॉबर्ट मार्टिन (अंकल बॉब) ने प्रतिपादित किया था। हालाँकि JavaScript मूल रूप से एक सख्ती से टाइप किया गया OOP भाषा नहीं था, आधुनिक JavaScript (ES6+) क्लासेस, मॉड्यूल्स और TypeScript के साथ स्केलेबल और मेंटेन करने योग्य एप्लिकेशन बनाने के लिए, विशेष रूप से Node.js वातावरण में, इन सिद्धांतों का सक्रिय रूप से उपयोग करता है।

इस लेख में, हम JavaScript में व्यावहारिक कोड उदाहरणों के साथ SOLID के पाँचों सिद्धांतों में से प्रत्येक का विश्लेषण करेंगे। इन सिद्धांतों को समझने से आपको स्वच्छ, लचीला और परिवर्तनों के प्रति प्रतिरोधी कोड लिखने में मदद मिलेगी।

1. Single Responsibility Principle (SRP) — एकल उत्तरदायित्व का सिद्धांत

सिद्धांत कहता है: एक क्लास या मॉड्यूल में बदलाव का केवल एक ही कारण होना चाहिए। दूसरे शब्दों में, प्रत्येक मॉड्यूल एक विशिष्ट कार्यक्षमता के लिए जिम्मेदार होता है।

SRP का उल्लंघन

एक क्लास UserService पर विचार करें जो एक साथ उपयोगकर्ताओं का प्रबंधन करता है, ईमेल भेजता है और क्रियाओं को लॉग करता है:

class UserService {  constructor() {    this.users = [];  }

  addUser(name) {    this.users.push({ name });    console.log('User added'); // लॉगिंग    this.sendEmail(name); // ईमेल भेजना  }

  sendEmail(name) {    console.log(`Email sent to ${name}`);  }

  getUsers() {    return this.users;  }}

यहाँ क्लास की तीन जिम्मेदारियाँ हैं: डेटा प्रबंधन, लॉगिंग और सूचनाएँ भेजना। लॉगिंग या ईमेल भेजने के तर्क में बदलाव से UserService क्लास में बदलाव होगा।

SRP का पालन

जिम्मेदारियों को अलग-अलग क्लासेस में विभाजित करें:

class Logger {  log(message) {    console.log(`[LOG]: ${message}`);  }}

class EmailService {  send(name) {    console.log(`Email sent to ${name}`);  }}

class UserService {  constructor(logger, emailService) {    this.users = [];    this.logger = logger;    this.emailService = emailService;  }

  addUser(name) {    this.users.push({ name });    this.logger.log(`User ${name} added`);    this.emailService.send(name);  }

  getUsers() {    return this.users;  }}

अब प्रत्येक क्लास अपने कार्य के लिए जिम्मेदार है, और एक सेवा में बदलाव दूसरों को प्रभावित नहीं करता।

2. Open-Closed Principle (OCP) — खुले/बंद होने का सिद्धांत

सिद्धांत कहता है: सॉफ्टवेयर संस्थाएँ विस्तार के लिए खुली होनी चाहिए, लेकिन संशोधन के लिए बंद होनी चाहिए। अर्थात, हमें मौजूदा कोड को बदले बिना नई कार्यक्षमता जोड़ने में सक्षम होना चाहिए।

OCP का उल्लंघन

मान लीजिए, हमारे पास आकृतियों के क्षेत्रफल की गणना करने का एक फंक्शन है:

function calculateArea(shape) {  if (shape.type === 'circle') {    return Math.PI * shape.radius ** 2;  } else if (shape.type === 'rectangle') {    return shape.width * shape.height;  }  // नई आकृति जोड़ने पर इस फंक्शन को संशोधित करना होगा}

OCP का पालन

क्लासेस के माध्यम से पॉलीमॉर्फिज़्म का उपयोग करें:

class Shape {  area() {    throw new Error('Method "area()" must be implemented');  }}

class Circle extends Shape {  constructor(radius) {    super();    this.radius = radius;  }  area() {    return Math.PI * this.radius ** 2;  }}

class Rectangle extends Shape {  constructor(width, height) {    super();    this.width = width;    this.height = height;  }  area() {    return this.width * this.height;  }}

// मौजूदा कोड को बदले बिना नई आकृति जोड़नाclass Triangle extends Shape {  constructor(base, height) {    super();    this.base = base;    this.height = height;  }  area() {    return (this.base * this.height) / 2;  }}

function calculateArea