M

MLOG

తెలుగు

మా పూర్తి అమలు మార్గదర్శితో జావాస్క్రిప్ట్ డిజైన్ ప్యాట్రన్స్‌పై పట్టు సాధించండి. ఆచరణాత్మక కోడ్ ఉదాహరణలతో క్రియేషనల్, స్ట్రక్చరల్, మరియు బిహేవియరల్ ప్యాట్రన్స్‌ను నేర్చుకోండి.

జావాస్క్రిప్ట్ డిజైన్ ప్యాట్రన్స్: ఆధునిక డెవలపర్‌ల కోసం ఒక సమగ్ర అమలు మార్గదర్శి

పరిచయం: పటిష్టమైన కోడ్ కోసం బ్లూప్రింట్

సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ యొక్క డైనమిక్ ప్రపంచంలో, కేవలం పనిచేసే కోడ్ రాయడం మొదటి అడుగు మాత్రమే. అసలైన సవాలు, మరియు ఒక ప్రొఫెషనల్ డెవలపర్ యొక్క గుర్తు, స్కేలబుల్, మెయింటెనబుల్, మరియు ఇతరులకు అర్థం చేసుకోవడానికి, సహకరించడానికి సులభంగా ఉండే కోడ్ సృష్టించడం. ఇక్కడే డిజైన్ ప్యాట్రన్స్ వస్తాయి. అవి నిర్దిష్ట అల్గోరిథంలు లేదా లైబ్రరీలు కావు, కానీ సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్‌లో పునరావృతమయ్యే సమస్యలను పరిష్కరించడానికి ఉన్నత-స్థాయి, భాష-అజ్ఞాత బ్లూప్రింట్లు.

జావాస్క్రిప్ట్ డెవలపర్‌ల కోసం, డిజైన్ ప్యాట్రన్స్‌ను అర్థం చేసుకోవడం మరియు వర్తింపజేయడం గతంలో కంటే చాలా కీలకం. క్లిష్టమైన ఫ్రంట్-ఎండ్ ఫ్రేమ్‌వర్క్‌ల నుండి Node.js పై శక్తివంతమైన బ్యాకెండ్ సేవల వరకు, అప్లికేషన్ల సంక్లిష్టత పెరిగేకొద్దీ, ఒక పటిష్టమైన ఆర్కిటెక్చరల్ పునాది చర్చించలేనిది. డిజైన్ ప్యాట్రన్స్ ఈ పునాదిని అందిస్తాయి, లూజ్ కప్లింగ్, సెపరేషన్ ఆఫ్ కన్సర్న్స్, మరియు కోడ్ పునర్వినియోగాన్ని ప్రోత్సహించే యుద్ధ-పరీక్షిత పరిష్కారాలను అందిస్తాయి.

ఈ సమగ్ర మార్గదర్శి మీకు డిజైన్ ప్యాట్రన్స్ యొక్క మూడు ప్రాథమిక వర్గాల ద్వారా మార్గనిర్దేశం చేస్తుంది, స్పష్టమైన వివరణలు మరియు ఆచరణాత్మక, ఆధునిక జావాస్క్రిప్ట్ (ES6+) అమలు ఉదాహరణలను అందిస్తుంది. ఇచ్చిన సమస్యకు ఏ ప్యాట్రన్‌ను ఉపయోగించాలో గుర్తించడానికి మరియు మీ ప్రాజెక్ట్‌లలో దానిని సమర్థవంతంగా ఎలా అమలు చేయాలో మీకు జ్ఞానాన్ని అందించడమే మా లక్ష్యం.

డిజైన్ ప్యాట్రన్స్ యొక్క మూడు స్తంభాలు

డిజైన్ ప్యాట్రన్స్ సాధారణంగా మూడు ప్రధాన సమూహాలుగా వర్గీకరించబడతాయి, ప్రతి ఒక్కటి భిన్నమైన ఆర్కిటెక్చరల్ సవాళ్లను పరిష్కరిస్తుంది:

ఆచరణాత్మక ఉదాహరణలతో ప్రతి వర్గంలోకి ప్రవేశిద్దాం.

క్రియేషనల్ ప్యాట్రన్స్: ఆబ్జెక్ట్ క్రియేషన్‌లో నైపుణ్యం

క్రియేషనల్ ప్యాట్రన్స్ వివిధ ఆబ్జెక్ట్ క్రియేషన్ మెకానిజంలను అందిస్తాయి, ఇవి ఫ్లెక్సిబిలిటీని మరియు ఇప్పటికే ఉన్న కోడ్ యొక్క పునర్వినియోగాన్ని పెంచుతాయి. అవి దాని ఆబ్జెక్ట్‌లు ఎలా సృష్టించబడతాయి, కంపోజ్ చేయబడతాయి మరియు సూచించబడతాయి అనే దాని నుండి ఒక సిస్టమ్‌ను వేరు చేయడానికి సహాయపడతాయి.

ది సింగిల్‌టన్ ప్యాట్రన్

భావన: సింగిల్‌టన్ ప్యాట్రన్ ఒక క్లాస్‌కు ఒకే ఒక ఇన్‌స్టాన్స్ ఉందని నిర్ధారిస్తుంది మరియు దానికి ఒకే, గ్లోబల్ యాక్సెస్ పాయింట్‌ను అందిస్తుంది. కొత్త ఇన్‌స్టాన్స్‌ను సృష్టించడానికి ఏ ప్రయత్నం చేసినా అసలు దానిని తిరిగి ఇస్తుంది.

సాధారణ వినియోగ సందర్భాలు: ఈ ప్యాట్రన్ షేర్డ్ రిసోర్స్‌లు లేదా స్టేట్‌ను నిర్వహించడానికి ఉపయోగపడుతుంది. ఉదాహరణలలో ఒకే డేటాబేస్ కనెక్షన్ పూల్, ఒక గ్లోబల్ కాన్ఫిగరేషన్ మేనేజర్, లేదా మొత్తం అప్లికేషన్‌లో ఏకీకృతం చేయాల్సిన లాగింగ్ సర్వీస్ ఉన్నాయి.

జావాస్క్రిప్ట్‌లో అమలు: ఆధునిక జావాస్క్రిప్ట్, ముఖ్యంగా ES6 క్లాసులతో, సింగిల్‌టన్‌ను అమలు చేయడం సూటిగా ఉంటుంది. ఒకే ఇన్‌స్టాన్స్‌ను ఉంచడానికి మనం క్లాస్‌పై స్టాటిక్ ప్రాపర్టీని ఉపయోగించవచ్చు.

ఉదాహరణ: ఒక లాగర్ సర్వీస్ సింగిల్‌టన్

class Logger { constructor() { if (Logger.instance) { return Logger.instance; } this.logs = []; Logger.instance = this; } log(message) { const timestamp = new Date().toISOString(); this.logs.push({ message, timestamp }); console.log(`${timestamp} - ${message}`); } getLogCount() { return this.logs.length; } } // The 'new' keyword is called, but the constructor logic ensures a single instance. const logger1 = new Logger(); const logger2 = new Logger(); console.log("Are loggers the same instance?", logger1 === logger2); // true logger1.log("First message from logger1."); logger2.log("Second message from logger2."); console.log("Total logs:", logger1.getLogCount()); // 2

ప్రోస్ మరియు కాన్స్:

ది ఫ్యాక్టరీ ప్యాట్రన్

భావన: ఫ్యాక్టరీ ప్యాట్రన్ ఒక సూపర్‌క్లాస్‌లో ఆబ్జెక్ట్‌లను సృష్టించడానికి ఒక ఇంటర్‌ఫేస్‌ను అందిస్తుంది, కానీ సబ్‌క్లాస్‌లు సృష్టించబడే ఆబ్జెక్ట్‌ల రకాన్ని మార్చడానికి అనుమతిస్తుంది. ఇది వాటి కాంక్రీట్ క్లాసులను పేర్కొనకుండా ఆబ్జెక్ట్‌లను సృష్టించడానికి ఒక ప్రత్యేక "ఫ్యాక్టరీ" పద్ధతి లేదా క్లాస్‌ను ఉపయోగించడం గురించి.

సాధారణ వినియోగ సందర్భాలు: ఒక క్లాస్ సృష్టించాల్సిన ఆబ్జెక్ట్‌ల రకాన్ని ఊహించలేనప్పుడు, లేదా మీ లైబ్రరీ వినియోగదారులకు అంతర్గత అమలు వివరాలు తెలియకుండా ఆబ్జెక్ట్‌లను సృష్టించడానికి ఒక మార్గాన్ని అందించాలనుకున్నప్పుడు ఇది ఉపయోగపడుతుంది. ఒక పారామీటర్ ఆధారంగా వివిధ రకాల యూజర్‌లను (అడ్మిన్, మెంబర్, గెస్ట్) సృష్టించడం ఒక సాధారణ ఉదాహరణ.

జావాస్క్రిప్ట్‌లో అమలు:

ఉదాహరణ: ఒక యూజర్ ఫ్యాక్టరీ

class RegularUser { constructor(name) { this.name = name; this.role = 'Regular'; } viewDashboard() { console.log(`${this.name} is viewing the user dashboard.`); } } class AdminUser { constructor(name) { this.name = name; this.role = 'Admin'; } viewDashboard() { console.log(`${this.name} is viewing the admin dashboard with full privileges.`); } } class UserFactory { static createUser(type, name) { switch (type.toLowerCase()) { case 'admin': return new AdminUser(name); case 'regular': return new RegularUser(name); default: throw new Error('Invalid user type specified.'); } } } const admin = UserFactory.createUser('admin', 'Alice'); const regularUser = UserFactory.createUser('regular', 'Bob'); admin.viewDashboard(); // Alice is viewing the admin dashboard... regularUser.viewDashboard(); // Bob is viewing the user dashboard. console.log(admin.role); // Admin console.log(regularUser.role); // Regular

ప్రోస్ మరియు కాన్స్:

ది ప్రోటోటైప్ ప్యాట్రన్

భావన: ప్రోటోటైప్ ప్యాట్రన్ అనేది "ప్రోటోటైప్" అని పిలువబడే ఇప్పటికే ఉన్న ఆబ్జెక్ట్‌ను కాపీ చేయడం ద్వారా కొత్త ఆబ్జెక్ట్‌లను సృష్టించడం గురించి. ఒక ఆబ్జెక్ట్‌ను మొదటి నుండి నిర్మించడానికి బదులుగా, మీరు ముందుగా కాన్ఫిగర్ చేయబడిన ఆబ్జెక్ట్ యొక్క క్లోన్‌ను సృష్టిస్తారు. ఇది ప్రోటోటైపల్ ఇన్హెరిటెన్స్ ద్వారా జావాస్క్రిప్ట్ పనిచేసే విధానానికి ప్రాథమికం.

సాధారణ వినియోగ సందర్భాలు: ఒక ఆబ్జెక్ట్‌ను సృష్టించే ఖర్చు, ఇప్పటికే ఉన్నదాన్ని కాపీ చేయడం కంటే ఎక్కువ ఖరీదైనది లేదా సంక్లిష్టంగా ఉన్నప్పుడు ఈ ప్యాట్రన్ ఉపయోగపడుతుంది. రన్‌టైమ్‌లో టైప్ పేర్కొనబడిన ఆబ్జెక్ట్‌లను సృష్టించడానికి కూడా ఇది ఉపయోగించబడుతుంది.

జావాస్క్రిప్ట్‌లో అమలు: జావాస్క్రిప్ట్ `Object.create()` ద్వారా ఈ ప్యాట్రన్‌కు అంతర్నిర్మిత మద్దతును కలిగి ఉంది.

ఉదాహరణ: క్లోనబుల్ వెహికల్ ప్రోటోటైప్

const vehiclePrototype = { init: function(model) { this.model = model; }, getModel: function() { return `The model of this vehicle is ${this.model}`; } }; // Create a new car object based on the vehicle prototype const car = Object.create(vehiclePrototype); car.init('Ford Mustang'); console.log(car.getModel()); // The model of this vehicle is Ford Mustang // Create another object, a truck const truck = Object.create(vehiclePrototype); truck.init('Tesla Cybertruck'); console.log(truck.getModel()); // The model of this vehicle is Tesla Cybertruck

ప్రోస్ మరియు కాన్స్:

స్ట్రక్చరల్ ప్యాట్రన్స్: కోడ్‌ను తెలివిగా సమీకరించడం

స్ట్రక్చరల్ ప్యాట్రన్స్ అంటే ఆబ్జెక్ట్‌లు మరియు క్లాసులను పెద్ద, మరింత సంక్లిష్టమైన నిర్మాణాలను రూపొందించడానికి ఎలా కలపవచ్చో చెప్పేవి. అవి నిర్మాణాన్ని సరళీకృతం చేయడం మరియు సంబంధాలను గుర్తించడంపై దృష్టి పెడతాయి.

ది అడాప్టర్ ప్యాట్రన్

భావన: అడాప్టర్ ప్యాట్రన్ రెండు అననుకూల ఇంటర్‌ఫేస్‌ల మధ్య వారధిగా పనిచేస్తుంది. ఇది స్వతంత్ర లేదా అననుకూల ఇంటర్‌ఫేస్‌ల కార్యాచరణలను కలిపే ఒకే క్లాస్ (అడాప్టర్) ను కలిగి ఉంటుంది. మీ పరికరాన్ని విదేశీ విద్యుత్ అవుట్‌లెట్‌లోకి ప్లగ్ చేయడానికి మిమ్మల్ని అనుమతించే పవర్ అడాప్టర్‌గా దీనిని భావించండి.

సాధారణ వినియోగ సందర్భాలు: భిన్నమైన API ని ఆశించే ఇప్పటికే ఉన్న అప్లికేషన్‌తో కొత్త థర్డ్-పార్టీ లైబ్రరీని ఇంటిగ్రేట్ చేయడం, లేదా లెగసీ కోడ్‌ను తిరిగి వ్రాయకుండా ఆధునిక సిస్టమ్‌తో పనిచేసేలా చేయడం.

జావాస్క్రిప్ట్‌లో అమలు:

ఉదాహరణ: కొత్త API ని పాత ఇంటర్‌ఫేస్‌కు అనుగుణంగా మార్చడం

// The old, existing interface our application uses class OldCalculator { operation(term1, term2, operation) { switch (operation) { case 'add': return term1 + term2; case 'sub': return term1 - term2; default: return NaN; } } } // The new, shiny library with a different interface class NewCalculator { add(term1, term2) { return term1 + term2; } subtract(term1, term2) { return term1 - term2; } } // The Adapter class class CalculatorAdapter { constructor() { this.calculator = new NewCalculator(); } operation(term1, term2, operation) { switch (operation) { case 'add': // Adapting the call to the new interface return this.calculator.add(term1, term2); case 'sub': return this.calculator.subtract(term1, term2); default: return NaN; } } } // Client code can now use the adapter as if it were the old calculator const oldCalc = new OldCalculator(); console.log("Old calculator result:", oldCalc.operation(10, 5, 'add')); // 15 const adaptedCalc = new CalculatorAdapter(); console.log("Adapted calculator result:", adaptedCalc.operation(10, 5, 'add')); // 15

ప్రోస్ మరియు కాన్స్:

ది డెకరేటర్ ప్యాట్రన్

భావన: డెకరేటర్ ప్యాట్రన్ ఒక ఆబ్జెక్ట్ యొక్క అసలు కోడ్‌ను మార్చకుండా దానికి డైనమిక్‌గా కొత్త ప్రవర్తనలను లేదా బాధ్యతలను జోడించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇది అసలు ఆబ్జెక్ట్‌ను కొత్త కార్యాచరణను కలిగి ఉన్న ఒక ప్రత్యేక "డెకరేటర్" ఆబ్జెక్ట్‌లో చుట్టడం ద్వారా సాధించబడుతుంది.

సాధారణ వినియోగ సందర్భాలు: UI కాంపోనెంట్‌కు ఫీచర్‌లను జోడించడం, అనుమతులతో యూజర్ ఆబ్జెక్ట్‌ను వృద్ధి చేయడం, లేదా ఒక సేవకు లాగింగ్/క్యాచింగ్ ప్రవర్తనను జోడించడం. ఇది సబ్‌క్లాసింగ్‌కు ఒక ఫ్లెక్సిబుల్ ప్రత్యామ్నాయం.

జావాస్క్రిప్ట్‌లో అమలు: జావాస్క్రిప్ట్‌లో ఫంక్షన్‌లు ఫస్ట్-క్లాస్ సిటిజన్‌లు, ఇది డెకరేటర్‌లను అమలు చేయడం సులభం చేస్తుంది.

ఉదాహరణ: కాఫీ ఆర్డర్‌ను అలంకరించడం

// The base component class SimpleCoffee { getCost() { return 10; } getDescription() { return 'Simple coffee'; } } // Decorator 1: Milk function MilkDecorator(coffee) { const originalCost = coffee.getCost(); const originalDescription = coffee.getDescription(); coffee.getCost = function() { return originalCost + 2; }; coffee.getDescription = function() { return `${originalDescription}, with milk`; }; return coffee; } // Decorator 2: Sugar function SugarDecorator(coffee) { const originalCost = coffee.getCost(); const originalDescription = coffee.getDescription(); coffee.getCost = function() { return originalCost + 1; }; coffee.getDescription = function() { return `${originalDescription}, with sugar`; }; return coffee; } // Let's create and decorate a coffee let myCoffee = new SimpleCoffee(); console.log(myCoffee.getCost(), myCoffee.getDescription()); // 10, Simple coffee myCoffee = MilkDecorator(myCoffee); console.log(myCoffee.getCost(), myCoffee.getDescription()); // 12, Simple coffee, with milk myCoffee = SugarDecorator(myCoffee); console.log(myCoffee.getCost(), myCoffee.getDescription()); // 13, Simple coffee, with milk, with sugar

ప్రోస్ మరియు కాన్స్:

ది ఫసాడ్ ప్యాట్రన్

భావన: ఫసాడ్ ప్యాట్రన్ ఒక సంక్లిష్టమైన సబ్‌సిస్టమ్ ఆఫ్ క్లాసులు, లైబ్రరీలు, లేదా APIలకు సరళీకృత, ఉన్నత-స్థాయి ఇంటర్‌ఫేస్‌ను అందిస్తుంది. ఇది అంతర్లీన సంక్లిష్టతను దాచిపెట్టి, సబ్‌సిస్టమ్‌ను ఉపయోగించడం సులభతరం చేస్తుంది.

సాధారణ వినియోగ సందర్భాలు: ఒక సంక్లిష్టమైన చర్యల సమితి కోసం ఒక సాధారణ API ని సృష్టించడం, ఉదాహరణకు ఇన్వెంటరీ, చెల్లింపు, మరియు షిప్పింగ్ సబ్‌సిస్టమ్‌లను కలిగి ఉన్న ఇ-కామర్స్ చెక్అవుట్ ప్రక్రియ. మరో ఉదాహరణ, అంతర్గతంగా సర్వర్, డేటాబేస్, మరియు మిడిల్‌వేర్‌ను కాన్ఫిగర్ చేసే వెబ్ అప్లికేషన్‌ను ప్రారంభించడానికి ఒకే పద్ధతి.

జావాస్క్రిప్ట్‌లో అమలు:

ఉదాహరణ: ఒక మార్ట్‌గేజ్ అప్లికేషన్ ఫసాడ్

// Complex Subsystems class BankService { verify(name, amount) { console.log(`Verifying sufficient funds for ${name} for amount ${amount}`); return amount < 100000; } } class CreditHistoryService { get(name) { console.log(`Checking credit history for ${name}`); // Simulate a good credit score return true; } } class BackgroundCheckService { run(name) { console.log(`Running background check for ${name}`); return true; } } // The Facade class MortgageFacade { constructor() { this.bank = new BankService(); this.credit = new CreditHistoryService(); this.background = new BackgroundCheckService(); } applyFor(name, amount) { console.log(`--- Applying for mortgage for ${name} ---`); const isEligible = this.bank.verify(name, amount) && this.credit.get(name) && this.background.run(name); const result = isEligible ? 'Approved' : 'Rejected'; console.log(`--- Application result for ${name}: ${result} ---\n`); return result; } } // Client code interacts with the simple Facade const mortgage = new MortgageFacade(); mortgage.applyFor('John Smith', 75000); // Approved mortgage.applyFor('Jane Doe', 150000); // Rejected

ప్రోస్ మరియు కాన్స్:

బిహేవియరల్ ప్యాట్రన్స్: ఆబ్జెక్ట్ కమ్యూనికేషన్‌ను ఆర్కెస్ట్రేట్ చేయడం

బిహేవియరల్ ప్యాట్రన్స్ అంటే ఆబ్జెక్ట్‌లు ఒకదానితో ఒకటి ఎలా కమ్యూనికేట్ చేస్తాయో, బాధ్యతలను కేటాయించడం మరియు పరస్పర చర్యలను సమర్థవంతంగా నిర్వహించడంపై దృష్టి సారిస్తాయి.

ది అబ్జర్వర్ ప్యాట్రన్

భావన: అబ్జర్వర్ ప్యాట్రన్ ఆబ్జెక్ట్‌ల మధ్య ఒకదాని నుండి అనేకం ఆధారపడటాన్ని నిర్వచిస్తుంది. ఒక ఆబ్జెక్ట్ ("సబ్జెక్ట్" లేదా "అబ్జర్వబుల్") దాని స్థితిని మార్చినప్పుడు, దాని ఆధారపడిన అన్ని ఆబ్జెక్ట్‌లకు ("అబ్జర్వర్‌లు") స్వయంచాలకంగా తెలియజేయబడుతుంది మరియు అప్‌డేట్ చేయబడుతుంది.

సాధారణ వినియోగ సందర్భాలు: ఈ ప్యాట్రన్ ఈవెంట్-డ్రివెన్ ప్రోగ్రామింగ్ యొక్క పునాది. ఇది UI డెవలప్‌మెంట్ (DOM ఈవెంట్ లిజనర్‌లు), స్టేట్ మేనేజ్‌మెంట్ లైబ్రరీలు (Redux లేదా Vuex వంటివి), మరియు మెసేజింగ్ సిస్టమ్‌లలో ఎక్కువగా ఉపయోగించబడుతుంది.

జావాస్క్రిప్ట్‌లో అమలు:

ఉదాహరణ: ఒక న్యూస్ ఏజెన్సీ మరియు సబ్‌స్క్రైబర్‌లు

// The Subject (Observable) class NewsAgency { constructor() { this.subscribers = []; } subscribe(subscriber) { this.subscribers.push(subscriber); console.log(`${subscriber.name} has subscribed.`); } unsubscribe(subscriber) { this.subscribers = this.subscribers.filter(sub => sub !== subscriber); console.log(`${subscriber.name} has unsubscribed.`); } notify(news) { console.log(`--- NEWS AGENCY: Broadcasting news: "${news}" ---`); this.subscribers.forEach(subscriber => subscriber.update(news)); } } // The Observer class Subscriber { constructor(name) { this.name = name; } update(news) { console.log(`${this.name} received the latest news: "${news}"`); } } const agency = new NewsAgency(); const sub1 = new Subscriber('Reader A'); const sub2 = new Subscriber('Reader B'); const sub3 = new Subscriber('Reader C'); agency.subscribe(sub1); agency.subscribe(sub2); agency.notify('Global markets are up!'); agency.subscribe(sub3); agency.unsubscribe(sub2); agency.notify('New tech breakthrough announced!');

ప్రోస్ మరియు కాన్స్:

ది స్ట్రాటజీ ప్యాట్రన్

భావన: స్ట్రాటజీ ప్యాట్రన్ పరస్పరం మార్చుకోగలిగిన అల్గోరిథంల కుటుంబాన్ని నిర్వచిస్తుంది మరియు ప్రతి ఒక్క దానిని దాని స్వంత క్లాస్‌లో పొందుపరుస్తుంది. ఇది అల్గోరిథంను రన్‌టైమ్‌లో ఎంచుకోవడానికి మరియు మార్చడానికి అనుమతిస్తుంది, దానిని ఉపయోగించే క్లయింట్ నుండి స్వతంత్రంగా.

సాధారణ వినియోగ సందర్భాలు: వివిధ సార్టింగ్ అల్గోరిథంలు, ధ్రువీకరణ నియమాలు, లేదా ఒక ఇ-కామర్స్ సైట్ కోసం షిప్పింగ్ ఖర్చు గణన పద్ధతులను అమలు చేయడం (ఉదాహరణకు, ఫ్లాట్ రేట్, బరువు ప్రకారం, గమ్యం ప్రకారం).

జావాస్క్రిప్ట్‌లో అమలు:

ఉదాహరణ: షిప్పింగ్ ఖర్చు గణన వ్యూహం

// The Context class Shipping { constructor() { this.company = null; } setStrategy(company) { this.company = company; console.log(`Shipping strategy set to: ${company.constructor.name}`); } calculate(pkg) { if (!this.company) { throw new Error('Shipping strategy has not been set.'); } return this.company.calculate(pkg); } } // The Strategies class FedExStrategy { calculate(pkg) { // Complex calculation based on weight, etc. const cost = pkg.weight * 2.5 + 5; console.log(`FedEx cost for package of ${pkg.weight}kg is $${cost}`); return cost; } } class UPSStrategy { calculate(pkg) { const cost = pkg.weight * 2.1 + 4; console.log(`UPS cost for package of ${pkg.weight}kg is $${cost}`); return cost; } } class PostalServiceStrategy { calculate(pkg) { const cost = pkg.weight * 1.8; console.log(`Postal Service cost for package of ${pkg.weight}kg is $${cost}`); return cost; } } const shipping = new Shipping(); const packageA = { from: 'New York', to: 'London', weight: 5 }; shipping.setStrategy(new FedExStrategy()); shipping.calculate(packageA); shipping.setStrategy(new UPSStrategy()); shipping.calculate(packageA); shipping.setStrategy(new PostalServiceStrategy()); shipping.calculate(packageA);

ప్రోస్ మరియు కాన్స్:

ఆధునిక ప్యాట్రన్స్ మరియు ఆర్కిటెక్చరల్ పరిశీలనలు

క్లాసిక్ డిజైన్ ప్యాట్రన్స్ కాలాతీతమైనవి అయినప్పటికీ, జావాస్క్రిప్ట్ ఎకోసిస్టమ్ అభివృద్ధి చెందింది, ఇది నేటి డెవలపర్‌లకు కీలకమైన ఆధునిక వ్యాఖ్యానాలు మరియు పెద్ద-స్థాయి ఆర్కిటెక్చరల్ ప్యాట్రన్‌లకు దారితీసింది.

ది మాడ్యూల్ ప్యాట్రన్

మాడ్యూల్ ప్యాట్రన్ అనేది ప్రైవేట్ మరియు పబ్లిక్ స్కోప్‌లను సృష్టించడానికి ES6-ముందు జావాస్క్రిప్ట్‌లో అత్యంత ప్రబలమైన ప్యాట్రన్‌లలో ఒకటి. ఇది స్టేట్ మరియు ప్రవర్తనను పొందుపరచడానికి క్లోజర్‌లను ఉపయోగిస్తుంది. నేడు, ఈ ప్యాట్రన్ చాలా వరకు స్థానిక ES6 మాడ్యూల్స్ (`import`/`export`) ద్వారా భర్తీ చేయబడింది, ఇది ఒక ప్రామాణిక, ఫైల్-ఆధారిత మాడ్యూల్ వ్యవస్థను అందిస్తుంది. ఏ ఆధునిక జావాస్క్రిప్ట్ డెవలపర్‌కైనా ES6 మాడ్యూల్స్‌ను అర్థం చేసుకోవడం ప్రాథమికం, ఎందుకంటే అవి ఫ్రంట్-ఎండ్ మరియు బ్యాక్-ఎండ్ అప్లికేషన్‌లలో కోడ్‌ను నిర్వహించడానికి ప్రమాణం.

ఆర్కిటెక్చరల్ ప్యాట్రన్స్ (MVC, MVVM)

డిజైన్ ప్యాట్రన్స్ మరియు ఆర్కిటెక్చరల్ ప్యాట్రన్స్ మధ్య తేడాను గుర్తించడం ముఖ్యం. డిజైన్ ప్యాట్రన్స్ నిర్దిష్ట, స్థానిక సమస్యలను పరిష్కరిస్తుండగా, ఆర్కిటెక్చరల్ ప్యాట్రన్స్ మొత్తం అప్లికేషన్‌కు ఉన్నత-స్థాయి నిర్మాణాన్ని అందిస్తాయి.

రియాక్ట్, Vue, లేదా యాంగ్యులర్ వంటి ఫ్రేమ్‌వర్క్‌లతో పనిచేస్తున్నప్పుడు, మీరు స్వాభావికంగా ఈ ఆర్కిటెక్చరల్ ప్యాట్రన్‌లను ఉపయోగిస్తున్నారు, తరచుగా పటిష్టమైన అప్లికేషన్‌లను నిర్మించడానికి చిన్న డిజైన్ ప్యాట్రన్‌లతో (స్టేట్ మేనేజ్‌మెంట్ కోసం అబ్జర్వర్ ప్యాట్రన్ వంటివి) కలిపి.

ముగింపు: ప్యాట్రన్స్‌ను తెలివిగా ఉపయోగించడం

జావాస్క్రిప్ట్ డిజైన్ ప్యాట్రన్స్ కఠినమైన నియమాలు కావు, కానీ ఒక డెవలపర్ ఆయుధాగారంలో శక్తివంతమైన సాధనాలు. అవి సాఫ్ట్‌వేర్ ఇంజనీరింగ్ కమ్యూనిటీ యొక్క సామూహిక జ్ఞానాన్ని సూచిస్తాయి, సాధారణ సమస్యలకు సొగసైన పరిష్కారాలను అందిస్తాయి.

వాటిని నేర్చుకోవడంలో కీలకం ప్రతి ప్యాట్రన్‌ను కంఠస్థం చేయడం కాదు, కానీ ప్రతి ఒక్కటి పరిష్కరించే సమస్యను అర్థం చేసుకోవడం. మీ కోడ్‌లో మీరు ఒక సవాలును ఎదుర్కొన్నప్పుడు - అది టైట్ కప్లింగ్, సంక్లిష్ట ఆబ్జెక్ట్ క్రియేషన్, లేదా అనమ్యమైన అల్గోరిథంలు కావచ్చు - అప్పుడు మీరు బాగా నిర్వచించబడిన పరిష్కారంగా తగిన ప్యాట్రన్ కోసం చేరవచ్చు.

మా చివరి సలహా ఇదే: పనిచేసే సరళమైన కోడ్‌ను రాయడం ద్వారా ప్రారంభించండి. మీ అప్లికేషన్ అభివృద్ధి చెందుతున్న కొద్దీ, మీ కోడ్‌ను ఈ ప్యాట్రన్‌ల వైపు రీఫ్యాక్టర్ చేయండి, అవి సహజంగా సరిపోయే చోట. అవసరం లేని చోట ఒక ప్యాట్రన్‌ను బలవంతం చేయవద్దు. వాటిని వివేకంతో వర్తింపజేయడం ద్వారా, మీరు కేవలం ఫంక్షనల్‌గా మాత్రమే కాకుండా, శుభ్రంగా, స్కేలబుల్‌గా, మరియు రాబోయే సంవత్సరాల్లో నిర్వహించడానికి ఆనందంగా ఉండే కోడ్‌ను వ్రాస్తారు.