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

ग्रैस्प क्या है?

नौ GRASP पैटर्न हैं:

1. सूचना विशेषज्ञ
2. निर्माता
3. नियंत्रक
4. कम युग्मन
5. उच्च सामंजस्य
6. बहुरूपता
7. शुद्ध निर्माण
8. निर्देश
9. संरक्षित विविधताएं

सूचना विशेषज्ञ

उन कार्यों को जिम्मेदारियां सौंपें जिनके पास किसी कार्य को करने के लिए आवश्यक डेटा या ज्ञान है। कार्यात्मक प्रोग्रामिंग में, इस सिद्धांत को उन कार्यों या मॉड्यूलों को जिम्मेदारियां सौंपकर लागू किया जा सकता है जिनमें किसी कार्य को करने के लिए आवश्यक डेटा या संदर्भ होता है।

// User management module
const createUser = (name, email) => ({ name, email });

const getUserEmail = (user) => user.email;

const updateUserEmail = (user, newEmail) => ({
  ...user,
  email: newEmail,
});

const user = createUser('John Doe', '[email protected]');
console.log(getUserEmail(user));  // '[email protected]'

const updatedUser = updateUserEmail(user, '[email protected]');
console.log(getUserEmail(updatedUser));  // '[email protected]'

निर्माता

जटिल डेटा संरचनाएं या ऑब्जेक्ट बनाने के लिए फ़ैक्टरी फ़ंक्शंस का उपयोग करें। कार्यात्मक प्रोग्रामिंग में, जबकि हम ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग की तरह कक्षाओं से निपटते नहीं हैं, हम डेटा संरचनाओं को बनाने या ऑब्जेक्ट को फ़ंक्शन या मॉड्यूल में प्रारंभ करने की ज़िम्मेदारी सौंपकर निर्माता सिद्धांत को लागू कर सकते हैं जिनमें आवश्यक जानकारी होती है और प्रसंग।

const createUser = (name, email) => ({ name, email });

नियंत्रक

सिस्टम घटनाओं को संभालने और कार्यों को सौंपने के लिए उच्च-क्रम फ़ंक्शन का उपयोग करें। कार्यात्मक प्रोग्रामिंग में, नियंत्रक अक्सर ऐसे कार्यों का रूप लेते हैं जो सिस्टम के विभिन्न हिस्सों के बीच डेटा और कार्यों के प्रवाह को व्यवस्थित करते हैं, यह सुनिश्चित करते हुए कि जिम्मेदारियां स्पष्ट रूप से अलग हो गई हैं।

// Example of express.js controller
const handleRequest = (req, res, userService) => {
  const user = userService.createUser(req.body.name, req.body.email);
  res.send(user);
};

कम युग्मन

सुनिश्चित करें कि फ़ंक्शन स्वतंत्र हैं और केवल स्पष्ट इनपुट पर निर्भर हैं। कार्यात्मक प्रोग्रामिंग में, कम युग्मन उन कार्यों और मॉड्यूल को डिज़ाइन करके प्राप्त किया जाता है जो एक दूसरे से स्वतंत्र रूप से संचालित होते हैं, अन्य कार्यों या मॉड्यूल के आंतरिक विवरण पर न्यूनतम निर्भरता के साथ।

const sendEmail = (emailService, email) => emailService.send(email);

उच्च सामंजस्य

उच्च सामंजस्य उस डिग्री को संदर्भित करता है जिस तक मॉड्यूल या फ़ंक्शन के तत्व एक साथ होते हैं। कार्यात्मक प्रोग्रामिंग में, उच्च सामंजस्य प्राप्त करने का अर्थ है कार्यों और मॉड्यूल को डिजाइन करना ताकि वे एक एकल, अच्छी तरह से परिभाषित कार्य या कार्यों के निकट से संबंधित सेट को निष्पादित कर सकें।

const createUser = (name, email) => ({ name, email });
const addUser = (users, user) => [...users, user];

const createAndAddUser = (users, name, email)=>{
  const user = createUser(name, email);
  return addUser(users, user)
}
// usage
const users = [
  { name: 'Alice', email: '[email protected]' },
  { name: 'Bob', email: '[email protected]' },
];

const newUsers = createAndAddUser(users, 'Charlie', '[email protected]');

बहुरूपता

बहुरूपता प्राप्त करने के लिए उच्च-क्रम फ़ंक्शंस और प्रथम श्रेणी फ़ंक्शंस का उपयोग करें। कार्यात्मक प्रोग्रामिंग में, बहुरूपता आमतौर पर उच्च-क्रम के कार्यों, सामान्य कार्यों और टाइपस्क्रिप्ट जैसे प्रकार प्रणालियों के माध्यम से प्राप्त की जाती है

const processPayment = (paymentMethod) => paymentMethod.process();

शुद्ध निर्माण

उपयोगिता फ़ंक्शन बनाएं जो सीधे डोमेन अवधारणाओं से मेल नहीं खाते हैं लेकिन कोई उपयुक्त डोमेन फ़ंक्शन या क्लास मौजूद नहीं होने पर आवश्यक कार्यक्षमता प्रदान करते हैं।

const log = (message) => console.log(message);

अविवेक

कार्यात्मक प्रोग्रामिंग में अप्रत्यक्षता एक प्रणाली के विभिन्न भागों के बीच बातचीत को प्रबंधित करने के लिए मध्यवर्ती कार्यों के उपयोग को संदर्भित करती है। Node.js में एक अच्छा उदाहरण मिडलवेयर पैटर्न हो सकता है।

const withNumberFilterMiddleware = (data) => data.filter(item => !isNaN(Number(item)));

संरक्षित विविधताएँ

कार्यात्मक प्रोग्रामिंग में संरक्षित विविधताओं का मतलब एक ऐसा डिज़ाइन बनाना है जो अलग-अलग हिस्सों को समाहित करके परिवर्तनों के प्रति लचीला है और यह सुनिश्चित करता है कि सिस्टम के बाकी हिस्से इन विविधताओं से सुरक्षित हैं। कार्यात्मक प्रोग्रामिंग में, इस सिद्धांत को मजबूत और रखरखाव योग्य कोड बनाने के लिए अमूर्तता, अपरिवर्तनीयता और एनकैप्सुलेशन के उपयोग के माध्यम से लागू किया जा सकता है जो परिवर्तनों के प्रति कम संवेदनशील है।

const processCreditCardPayment = (amount) => {
  console.log(`Processing credit card payment of ${amount}`);
  // Credit card payment logic
};

const processPayPalPayment = (amount) => {
  console.log(`Processing PayPal payment of ${amount}`);
  // PayPal payment logic
};

const processPayment = (paymentMethod, amount) => {
  paymentMethod(amount);
};

// Use different payment methods without changing the processPayment function
processPayment(processCreditCardPayment, 100);
processPayment(processPayPalPayment, 200);

सारांश

जैसा कि आप देख सकते हैं कि GRASP सिद्धांत कई ज्ञात डिज़ाइन पैटर्न के साथ-साथ SOLID सिद्धांतों से संबंधित हैं। उच्च सामंजस्य लगभग एकल उत्तरदायित्व सिद्धांत वगैरह के बराबर है।
वे सिद्धांत न केवल ओओपी सिद्धांत हैं बल्कि अच्छी तरह से संरचित स्वच्छ कोड प्रोग्रामिंग के लिए सामान्य सिद्धांत हैं, चाहे वह कार्यात्मक हो या ओओपी प्रोग्रामिंग।