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

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

जारी रखने से पहले, मैं कुछ बिंदुओं पर ध्यान देता हूं। लेख मानता है कि आप पहले से ही फ़ंक्शन रचना और करी के बारे में जानते हैं। और एक चेतावनी। यदि आप पहले भिक्षुओं के पार नहीं आए हैं, तो वे वास्तव में ... अजीब लग सकते हैं। ऐसे उपकरणों के साथ काम करने के लिए सोच में बदलाव की आवश्यकता है। पहले तो यह कठिन हो सकता है।

अगर आप तुरंत भ्रमित हैं तो चिंता न करें। सबके पास है। लेख के अंत में, मैंने कुछ लिंक सूचीबद्ध किए जो मदद कर सकते हैं। हार मत मानो। दिमाग में घुसते ही ये चीजें नशे में आ जाती हैं।

समस्या का उदाहरण

अपवादों की समस्याओं पर चर्चा करने से पहले, आइए बात करते हैं कि वे क्यों मौजूद हैं और क्यों try...catch ब्लॉक दिखाई दिए। ऐसा करने के लिए, आइए एक समस्या को देखें जो मैंने कम से कम आंशिक रूप से यथार्थवादी बनाने की कोशिश की। कल्पना करें कि हम सूचनाओं की सूची प्रदर्शित करने के लिए एक फ़ंक्शन लिख रहे हैं। हमने सर्वर से डेटा वापस करने के लिए (किसी तरह) पहले से ही प्रबंधित किया है। लेकिन किसी कारण से, बैकेंड इंजीनियरों ने इसे CSV प्रारूप में भेजने का फैसला किया, JSON नहीं। कच्चा डेटा कुछ इस तरह दिख सकता है:

  टाइमस्टैम्प, सामग्री, देखी, href
 2018-10-27T05: 33: 34 + 00: 00, @ मैडमटर ने आपको चाय, अपठित, https: //example.com/invite/tea/3801 पर आमंत्रित किया
 2018-10-26T13: 47: 12 + 00: 00, @ queenofhearts ने 'क्रोकेट टूर्नामेंट' चर्चा में आपका उल्लेख किया, देखा, https: //example.com/discussions/croquet/1168
 2018-10-25T03: 50: 08 + 00: 00, @ cheshirecat ने आपको एक मुस्कराहट, अपठित, https: //example.com/interactions/grin/88 भेजा 

हम इसे HTML में प्रदर्शित करना चाहते हैं। यह कुछ इस तरह दिख सकता है:

 <ul class="MessageList"> <li class="Message Message--viewed"> <a href="https://example.com/invite/tea/3801" class="Message-link">@madhatter invited you to tea</a> <time datetime="2018-10-27T05:33:34+00:00">27 October 2018</time> <li> <li class="Message Message--viewed"> <a href="https://example.com/discussions/croquet/1168" class="Message-link">@queenofhearts mentioned you in 'Croquet Tournament' discussion</a> <time datetime="2018-10-26T13:47:12+00:00">26 October 2018</time> </li> <li class="Message Message--viewed"> <a href="https://example.com/interactions/grin/88" class="Message-link">@cheshirecat sent you a grin</a> <time datetime="2018-10-25T03:50:08+00:00">25 October 2018</time> </li> </ul> 

कार्य को सरल बनाने के लिए, अभी CSV डेटा की प्रत्येक पंक्ति को संसाधित करने पर ध्यान केंद्रित करें। चलो स्ट्रिंग के प्रसंस्करण के लिए कुछ सरल कार्यों के साथ शुरू करते हैं। पहला पाठ स्ट्रिंग को फ़ील्ड में विभाजित करता है:

 function splitFields(row) { return row.split('","'); } 

यहां समारोह को सरल बनाया गया है क्योंकि यह शैक्षिक सामग्री है। हम त्रुटि से निपटने के लिए, सीएसवी विश्लेषण से नहीं। यदि किसी एक संदेश में अल्पविराम होता है, तो यह सब बहुत गलत होगा। कृपया वास्तविक CSV डेटा का विश्लेषण करने के लिए इस कोड का उपयोग कभी न करें। यदि आपको कभी भी CSV डेटा का विश्लेषण करना है, तो अच्छी तरह से परीक्षण की गई CSV पार्सिंग लाइब्रेरी का उपयोग करें ।

डेटा को विभाजित करने के बाद, हम एक ऑब्जेक्ट बनाना चाहते हैं। और इसलिए कि प्रत्येक संपत्ति का नाम सीएसवी हेडर से मेल खाता है। मान लीजिए कि हमने किसी तरह पहले ही टाइटल बार (उस पर बाद में) का विश्लेषण किया। हम एक ऐसे बिंदु पर आ गए हैं, जहां कुछ गलत हो सकता है। हमें प्रसंस्करण के लिए एक त्रुटि मिली। हम एक त्रुटि फेंकते हैं यदि स्ट्रिंग की लंबाई शीर्षक पट्टी से मेल नहीं खाती है। ( _.zipObject एक लॉश समारोह है )।

 function zipRow(headerFields, fieldData) { if (headerFields.length !== fieldData.length) { throw new Error("Row has an unexpected number of fields"); } return _.zipObject(headerFields, fieldData); } 

उसके बाद, हमारे टेम्पलेट में प्रदर्शित करने के लिए ऑब्जेक्ट में मानव-पढ़ने योग्य दिनांक जोड़ें। यह थोड़ा वर्बोज़ निकला, क्योंकि जावास्क्रिप्ट में डेट फॉर्मेटिंग के लिए बिल्कुल सही बिल्ट-इन सपोर्ट नहीं है। और फिर, हम संभावित समस्याओं का सामना करते हैं। यदि कोई अमान्य दिनांक सामने आई है, तो हमारा फ़ंक्शन एक त्रुटि फेंकता है।

 function addDateStr(messageObj) { const errMsg = 'Unable to parse date stamp in message object'; const months = [ 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December' ]; const d = new Date(messageObj.datestamp); if (isNaN(d)) { throw new Error(errMsg); } const datestr = `${d.getDate()} ${months[d.getMonth()]} ${d.getFullYear()}`; return {datestr, ...messageObj}; } 

अंत में, ऑब्जेक्ट लें और इसे HTML स्ट्रिंग प्राप्त करने के लिए टेम्पलेट फ़ंक्शन के माध्यम से पास करें।

 const rowToMessage = _.template(`<li class="Message Message--<%= viewed %>"> <a href="<%= href %>" class="Message-link"><%= content %></a> <time datetime="<%= datestamp %>"><%= datestr %></time> <li>`); 

यह मिला तो त्रुटि प्रिंट करना भी अच्छा होगा:

 const showError = _.template(`<li class="Error"><%= message %></li>`); 

जब सब कुछ हो जाता है, तो आप प्रत्येक पंक्ति को संसाधित करने के लिए एक फ़ंक्शन डाल सकते हैं।

 function processRow(headerFieldNames, row) { try { fields = splitFields(row); rowObj = zipRow(headerFieldNames, fields); rowObjWithDate = addDateStr(rowObj); return rowToMessage(rowObj); } catch(e) { return showError(e); } } 

तो समारोह तैयार है। आइए अपवादों को कैसे संभालते हैं, इस पर एक नज़र डालें।

अपवाद: अच्छा हिस्सा

तो try...catch बारे में क्या अच्छा है try...catch ? यह ध्यान दिया जाना चाहिए कि उपरोक्त उदाहरण में, try ब्लॉक में किसी भी चरण में त्रुटि हो सकती है। zipRow() और addDateStr() हम जानबूझकर त्रुटियों को फेंकते हैं। और अगर कोई समस्या आती है, तो बस त्रुटि को पकड़ें और पृष्ठ पर कोई भी संदेश प्रदर्शित करें। इस तंत्र के बिना, कोड वास्तव में बदसूरत हो जाता है। यहाँ है कि यह कैसे दिख सकता है। मान लें कि फ़ंक्शंस त्रुटियों को नहीं फेंकते हैं, लेकिन null लौटते हैं।

 function processRowWithoutExceptions(headerFieldNames, row) { fields = splitFields(row); rowObj = zipRow(headerFieldNames, fields); if (rowObj === null) { return showError(new Error('Encountered a row with an unexpected number of items')); } rowObjWithDate = addDateStr(rowObj); if (rowObjWithDate === null) { return showError(new Error('Unable to parse date in row object')); } return rowToMessage(rowObj); } 

जैसा कि आप देख सकते हैं, if बड़ी संख्या में टेम्प्लेट if । कोड अधिक क्रिया है। और मूल तर्क का पालन करना कठिन है। इसके अलावा, null हमें ज्यादा कुछ नहीं बताता है। हम वास्तव में नहीं जानते हैं कि पिछला फ़ंक्शन कॉल विफल क्यों हुआ। हमें अनुमान लगाना होगा। हम एक त्रुटि संदेश बनाते हैं और showError() । इस तरह के कोड गंदगी और अधिक भ्रामक है।

अपवाद हैंडलिंग संस्करण को फिर से देखें। यह प्रोग्राम के सफल पथ और अपवाद हैंडलिंग कोड को स्पष्ट रूप से अलग करता है। try ब्रांच एक अच्छा तरीका है, और catch ब्रांच एक त्रुटि है। सभी अपवाद हैंडलिंग एक ही स्थान पर होती हैं। और व्यक्तिगत कार्य रिपोर्ट कर सकते हैं कि वे असफल क्यों हुए। सब सब में, यह बहुत प्यारा लगता है। मुझे लगता है कि बहुमत पहले उदाहरण को काफी उपयुक्त मानता है। एक अलग दृष्टिकोण क्यों?

अपवाद से निपटने में समस्याएं ... पकड़ने की कोशिश करें

यह दृष्टिकोण आपको इन कष्टप्रद गलतियों को अनदेखा करने की अनुमति देता है। दुर्भाग्य से, try...catch अपना काम बहुत अच्छा करता है। आप सिर्फ एक अपवाद फेंकते हैं और आगे बढ़ते हैं। हम उसे बाद में पकड़ सकते हैं। और हर कोई हमेशा इस तरह के ब्लॉक लगाने का इरादा रखता है। लेकिन यह हमेशा स्पष्ट नहीं होता है कि त्रुटि कहां तक ​​जाती है। और ब्लॉक को भूलना बहुत आसान है। और इससे पहले कि आप यह महसूस करें, आपका एप्लिकेशन क्रैश हो जाता है।

इसके अलावा, अपवाद कोड को प्रदूषित करते हैं। हम यहां कार्यात्मक शुद्धता के बारे में विस्तार से चर्चा नहीं करेंगे। लेकिन आइए कार्यात्मक शुद्धता के एक छोटे से पहलू को देखें: संदर्भात्मक पारदर्शिता। लिंक-पारदर्शी फ़ंक्शन हमेशा किसी विशेष इनपुट के लिए समान परिणाम देता है। लेकिन अपवादों वाले कार्यों के लिए, हम ऐसा नहीं कह सकते। वे मूल्य वापस करने के बजाय किसी भी समय एक अपवाद फेंक सकते हैं। इससे तर्क उलझता है। लेकिन क्या होगा यदि आप एक जीत-जीत विकल्प ढूंढते हैं - त्रुटियों को संभालने का एक साफ तरीका?

हम एक विकल्प के साथ आते हैं

शुद्ध कार्य हमेशा एक मान लौटाते हैं (भले ही वह मान गायब हो)। इसलिए, हमारे त्रुटि हैंडलिंग कोड को यह मान लेना चाहिए कि हम हमेशा एक मान लौटाते हैं। तो, पहले प्रयास के रूप में, मुझे क्या करना चाहिए, यदि विफलता पर, हम एक त्रुटि वस्तु लौटाते हैं? यही है, हम जहां भी त्रुटि करते हैं, हम ऐसी वस्तु को वापस करते हैं। यह कुछ इस तरह दिख सकता है:

 function processRowReturningErrors(headerFieldNames, row) { fields = splitFields(row); rowObj = zipRow(headerFieldNames, fields); if (rowObj instanceof Error) { return showError(rowObj); } rowObjWithDate = addDateStr(rowObj); if (rowObjWithDate instanceof Error) { return showError(rowObjWithDate); } return rowToMessage(rowObj); } 

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

बहुरूपता

यह कैसे करना है? यह एक कठिन समस्या है। लेकिन इसे बहुरूपता के जादू की मदद से हल किया जा सकता है। यदि आपने पहले बहुरूपता का सामना नहीं किया है, तो चिंता न करें। संक्षेप में, यह "विभिन्न प्रकार की संस्थाओं के लिए एक एकल इंटरफ़ेस प्रदान कर रहा है" (स्ट्रैजेनअप, बी। "सी + ग्लोजरी ऑफ ब्योर्न स्ट्रैज़ेनुप")। जावास्क्रिप्ट में, इसका मतलब है कि हम समान नाम और विधियों के साथ ऑब्जेक्ट बनाते हैं। लेकिन अलग व्यवहार। एक क्लासिक उदाहरण अनुप्रयोग लॉगिंग है। हम अपनी पत्रिकाओं को उस वातावरण के आधार पर विभिन्न स्थानों पर भेज सकते हैं जिसमें हम हैं। उदाहरण के लिए, यदि हम दो लकड़हारा ऑब्जेक्ट बनाते हैं, तो क्या होगा?

 const consoleLogger = { log: function log(msg) { console.log('This is the console logger, logging:', msg); } }; const ajaxLogger = { log: function log(msg) { return fetch('https://example.com/logger', {method: 'POST', body: msg}); } }; 

दोनों ऑब्जेक्ट एक लॉग फ़ंक्शन को परिभाषित करते हैं जो एकल स्ट्रिंग पैरामीटर की अपेक्षा करता है। लेकिन वे अलग तरह से व्यवहार करते हैं। सुंदरता यह है कि हम कोड लिख सकते हैं जो कॉल .log() , कोई फर्क नहीं पड़ता कि कौन सी वस्तु का उपयोग करता है। यह consoleLogger या ajaxLogger consoleLogger हो सकता है। सब कुछ वैसे भी काम करता है। उदाहरण के लिए, नीचे दिया गया कोड किसी भी वस्तु के साथ समान रूप से काम करेगा:

 function log(logger, message) { logger.log(message); } 

एक और उदाहरण सभी JS वस्तुओं के लिए .toString() विधि है। हम किसी भी वर्ग के लिए .toString() विधि लिख सकते हैं जो हम बनाते हैं। इसके बाद, आप दो कक्षाएं बना सकते हैं जो .toString() विधि को अलग तरीके से लागू करती हैं। हम उनका नाम Left और Right (थोड़ी देर बाद नाम बताएंगे) बताएंगे।

 class Left { constructor(val) { this._val = val; } toString() { const str = this._val.toString(); return `Left(${str})`; } } 

 class Right { constructor(val) { this._val = val; } toString() { const str = this._val.toString(); return `Right(${str})`; } } 

अब एक फ़ंक्शन बनाएं जो इन दो ऑब्जेक्ट्स पर .toString() कहता है:

 function trace(val) { console.log(val.toString()); return val; } trace(new Left('Hello world')); // ⦘ Left(Hello world) trace(new Right('Hello world')); // ⦘ Right(Hello world); 

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

बाएँ और दाएँ

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

आइए एक विधि बनाएं जो फ़ंक्शन को चलाता है यदि हम एक अच्छे रास्ते पर हैं, लेकिन इसे एक बुरे पर अनदेखा करें:

 /** * Left represents the sad path. */ class Left { constructor(val) { this._val = val; } runFunctionOnlyOnHappyPath() { // Left is the sad path. Do nothing } toString() { const str = this._val.toString(); return `Left(${str})`; } } 

 /** * Right represents the happy path. */ class Right { constructor(val) { this._val = val; } runFunctionOnlyOnHappyPath(fn) { return fn(this._val); } toString() { const str = this._val.toString(); return `Right(${str})`; } } 

कुछ इस तरह:

 const leftHello = new Left('Hello world'); const rightHello = new Right('Hello world'); leftHello.runFunctionOnlyOnHappyPath(trace); // does nothing rightHello.runFunctionOnlyOnHappyPath(trace); // ⦘ Hello world // ￩ "Hello world" 

अनुवाद

हम कुछ उपयोगी के लिए संपर्क कर रहे हैं, लेकिन अभी तक नहीं। हमारी .runFunctionOnlyOnHappyPath() विधि _val संपत्ति _val है। सब कुछ ठीक है, लेकिन बहुत असुविधाजनक है अगर हम एक से अधिक फ़ंक्शन चलाना चाहते हैं। क्यों? क्योंकि हम नहीं जानते कि हम सही या गलत रास्ते पर हैं। जैसे ही हम लेफ्ट और राइट के बाहर वैल्यू लेते हैं, सूचना गायब हो जाती है। तो हम क्या कर सकते हैं कि अंदर नए _val साथ बाएं या दाएं रास्ते को वापस करें। और हम नाम छोटा कर देंगे, क्योंकि हम यहाँ हैं। हम जो करते हैं, वह एक फ़ंक्शन को सरल मानों की दुनिया से लेफ्ट और राइट की दुनिया में अनुवाद करता है। इसलिए, हम map() विधि कहते हैं:

 /** * Left represents the sad path. */ class Left { constructor(val) { this._val = val; } map() { // Left is the sad path // so we do nothing return this; } toString() { const str = this._val.toString(); return `Left(${str})`; } } 

 /** * Right represents the happy path */ class Right { constructor(val) { this._val = val; } map(fn) { return new Right( fn(this._val) ); } toString() { const str = this._val.toString(); return `Right(${str})`; } } 

हम इस पद्धति को सम्मिलित करते हैं और मुक्त वाक्य रचना में बाएँ या दाएँ का उपयोग करते हैं:

 const leftHello = new Left('Hello world'); const rightHello = new Right('Hello world'); const helloToGreetings = str => str.replace(/Hello/, 'Greetings,'); leftHello.map(helloToGreetings).map(trace); // Doesn't print any thing to the console // ￩ Left(Hello world) rightHello.map(helloToGreetings).map(trace); // ⦘ Greetings, world // ￩ Right(Greetings, world) 

हमने निष्पादन के दो मार्ग बनाए हैं। हम new Right() , या फेल हुए पथ पर new Left() कॉल करके डेटा को एक सफल पथ पर रख सकते हैं।


प्रत्येक वर्ग एक पथ का प्रतिनिधित्व करता है: सफल या असफल। मैंने स्कॉट वेलास्चीना के इस रेलवे रूपक को चुरा लिया

यदि map एक अच्छे रास्ते पर काम करता है, तो उसके साथ जाएं और डेटा को संसाधित करें। अगर हम खुद को असफल पाते हैं, तो कुछ नहीं होगा। बस आगे वैल्यू पास करते रहिए। यदि हम, उदाहरण के लिए, इस असफल पथ पर त्रुटि डालते हैं, तो हमें बहुत कुछ इसी तरह का try…catch ।


पथ के साथ जाने के लिए .map() का उपयोग करें

जैसे-जैसे आप आगे बढ़ते हैं, लेफ्ट या राइट लिखने में हर समय थोड़ा मुश्किल हो जाता है, तो आइए इस संयोजन को या तो सरलता से कहें (या तो "या तो")। या तो बाएं या दाएं।

या तो ऑब्जेक्ट्स बनाने के लिए शॉर्टकट

इसलिए, अगला कदम हमारे उदाहरण कार्यों को फिर से लिखना है ताकि वे या तो वापस आ जाएं। मूल्य के लिए त्रुटि या अधिकार के लिए छोड़ दिया। लेकिन इससे पहले कि हम ऐसा करते हैं, कुछ मजा करें। आइये एक दो शार्टकट लिखते हैं। पहला एक स्थिर विधि है जिसे .of() कहा जाता है। यह सिर्फ एक नया वामपंथी या अधिकार देता है। कोड इस तरह दिख सकता है:

 Left.of = function of(x) { return new Left(x); }; Right.of = function of(x) { return new Right(x); }; 

ईमानदारी से, यहां तक ​​कि Left.of() और Right.of() लिखने के लिए थकाऊ है। इसलिए मैं और भी छोटे left() और right() लेबल की ओर झुक रहा हूँ:

 function left(x) { return Left.of(x); } function right(x) { return Right.of(x); } 

इन शॉर्टकट्स के साथ, हम एप्लिकेशन फ़ंक्शंस को फिर से लिखना शुरू करते हैं:

 function zipRow(headerFields, fieldData) { const lengthMatch = (headerFields.length == fieldData.length); return (!lengthMatch) ? left(new Error("Row has an unexpected number of fields")) : right(_.zipObject(headerFields, fieldData)); } function addDateStr(messageObj) { const errMsg = 'Unable to parse date stamp in message object'; const months = [ 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December' ]; const d = new Date(messageObj.datestamp); if (isNaN(d)) { return left(new Error(errMsg)); } const datestr = `${d.getDate()} ${months[d.getMonth()]} ${d.getFullYear()}`; return right({datestr, ...messageObj}); } 

संशोधित कार्य पुराने लोगों से इतने अलग नहीं हैं। हम केवल वाम या अधिकार में वापसी मूल्य को लपेटते हैं, इस पर निर्भर करता है कि क्या कोई त्रुटि है।

उसके बाद, हम मुख्य फ़ंक्शन को संसाधित करना शुरू कर सकते हैं जो एक पंक्ति को संसाधित करता है। आरंभ करने के लिए, स्ट्रिंग को right() , और फिर विभाजित करने के लिए विभाजन का अनुवाद करें:

 function processRow(headerFields, row) { const fieldsEither = right(row).map(splitFields); // … } 

यह ठीक काम करता है, लेकिन परेशानी तब होती है जब आप zipRow() साथ भी ऐसा ही करने की कोशिश करते हैं:

  function processRow(headerFields, row) { const fieldsEither = right(row).map(splitFields); const rowObj = fieldsEither.map(zipRow /* wait. this isn't right */); // ... } 

तथ्य यह है कि zipRow() दो मापदंडों की अपेक्षा करता है। लेकिन हम जो ._val .map() पास करते हैं, उन्हें ._val संपत्ति से केवल एक मूल्य मिलता है। zipRow() के zipRow() संस्करण का उपयोग करके स्थिति को ठीक किया जा सकता है। यह कुछ इस तरह दिख सकता है:

 function zipRow(headerFields) { return function zipRowWithHeaderFields(fieldData) { const lengthMatch = (headerFields.length == fieldData.length); return (!lengthMatch) ? left(new Error("Row has an unexpected number of fields")) : right(_.zipObject(headerFields, fieldData)); }; } 

यह छोटा सा परिवर्तन zipRow के रूपांतरण को सरल zipRow , इसलिए यह zipRow .map() साथ अच्छी तरह से काम करेगा:

 function processRow(headerFields, row) { const fieldsEither = right(row).map(splitFields); const rowObj = fieldsEither.map(zipRow(headerFields)); // ... But now we have another problem ... } 

शामिल हों

.map() को चलाने के लिए splitFields() का उपयोग करना .map() splitFields() ठीक है, जैसा कि .splitFields() या तो वापस नहीं आता है। लेकिन जब आपको zipRow() चलाना होता है, तो एक समस्या उत्पन्न होती है क्योंकि यह या तो वापस आ जाती है। तो .map() का उपयोग करते समय हम अंत में या तो अंदर चल रहे होते हैं। यदि हम और आगे बढ़ें, तो तब तक .map() रहें, जब तक हम .map() अंदर .map() चलाते। वह भी काम नहीं करेगा। हमें इन नेस्टेड या तो गठबंधन करने के लिए किसी तरह की आवश्यकता है। तो चलिए एक नई विधि लिखते हैं, जिसे हम .join() :

 /** *Left represents the sad path. */ class Left { constructor(val) { this._val = val; } map() { // Left is the sad path // so we do nothing return this; } join() { // On the sad path, we don't // do anything with join return this; } toString() { const str = this._val.toString(); return `Left(${str})`; } } 

 /** * Right represents the happy path */ class Right { constructor(val) { this._val = val; } map(fn) { return new Right( fn(this._val) ); } join() { if ((this._val instanceof Left) || (this._val instanceof Right)) { return this._val; } return this; } toString() { const str = this._val.toString(); return `Right(${str})`; } } 

अब हम अपनी संपत्ति को “अनपैक” कर सकते हैं:

 function processRow(headerFields, row) { const fieldsEither = right(row).map(splitFields); const rowObj = fieldsEither.map(zipRow(headerFields)).join(); const rowObjWithDate = rowObj.map(addDateStr).join(); // Slowly getting better... but what do we return? } 

श्रृंखला

हमने एक लंबा सफर तय किया है। लेकिन आपको याद रखना होगा .join() हर समय कॉल करें, जो कि कष्टप्रद है। हालाँकि, हमारे पास एक सामान्य कॉल पैटर्न है .join() और .join() , तो चलिए इसके लिए एक त्वरित एक्सेस विधि बनाते हैं। चलो इसे chain() , क्योंकि यह एक साथ उन कार्यों को बांधता है जो वाम या अधिकार वापस करते हैं।

 /** *Left represents the sad path. */ class Left { constructor(val) { this._val = val; } map() { // Left is the sad path // so we do nothing return this; } join() { // On the sad path, we don't // do anything with join return this; } chain() { // Boring sad path, // do nothing. return this; } toString() { const str = this._val.toString(); return `Left(${str})`; } } 

 /** * Right represents the happy path */ class Right { constructor(val) { this._val = val; } map(fn) { return new Right( fn(this._val) ); } join() { if ((this._val instanceof Left) || (this._val instanceof Right)) { return this._val; } return this; } chain(fn) { return fn(this._val); } toString() { const str = this._val.toString(); return `Right(${str})`; } } 

यदि हम किसी त्रुटि का सामना करते हैं, तो रेल की सादृश्य,। हालांकि, आरेख पर दिखाना आसान है।


यदि कोई त्रुटि होती है, तो .chain () विधि आपको बाएं मार्ग पर स्विच करने की अनुमति देती है। कृपया ध्यान दें कि स्विच केवल एक ही तरह से काम करते हैं।

कोड को थोड़ा क्लीनर मिला:

 function processRow(headerFields, row) { const fieldsEither = right(row).map(splitFields); const rowObj = fieldsEither.chain(zipRow(headerFields)); const rowObjWithDate = rowObj.chain(addDateStr); // Slowly getting better... but what do we return? } 

मूल्यों के साथ कुछ करें

processRow() फ़ंक्शन का रीफैक्टरिंग लगभग पूरा हो गया है। लेकिन जब हम मूल्य वापस करते हैं तो क्या होता है? अंत में, हम किस तरह की स्थिति के आधार पर अलग-अलग कार्रवाई करना चाहते हैं: वाम या अधिकार। इसलिए, हम एक फ़ंक्शन लिखेंगे जो उचित उपाय करेगा:

 function either(leftFunc, rightFunc, e) { return (e instanceof Left) ? leftFunc(e._val) : rightFunc(e._val); } 

Left Right. , . :

 function processRow(headerFields, row) { const fieldsEither = right(row).map(splitFields); const rowObj = fieldsEither.chain(zipRow(headerFields)); const rowObjWithDate = rowObj.chain(addDateStr); return either(showError, rowToMessage, rowObjWithDate); } 

, :

 function processRow(headerFields, row) { const rowObjWithDate = right(row) .map(splitFields) .chain(zipRow(headerFields)) .chain(addDateStr); return either(showError, rowToMessage, rowObjWithDate); } 

. try...catch . if- . - , . , processRow() Left Right , right() . .map() .chain() .

ap lift

, . , , CSV, . () :

 function splitCSVToRows(csvData) { // There should always be a header row... so if there's no // newline character, something is wrong. return (csvData.indexOf('\n') < 0) ? left('No header row found in CSV data') : right(csvData.split('\n')); } function processRows(headerFields, dataRows) { // Note this is Array map, not Either map. return dataRows.map(row => processRow(headerFields, row)); } function showMessages(messages) { return `<ul class="Messages">${messages.join('\n')}</ul>`; } 

, , CSV . Either. .map() lodash- . …

 function csvToMessages(csvData) { const csvRows = splitCSVToRows(csvData); const headerFields = csvRows.map(_.head).map(splitFields); const dataRows = csvRows.map(_.tail); // What's next? } 

, processRows() . headerFields dataRows Either. - processRows() , Either. processRows .

 function processRows(headerFields) { return function processRowsWithHeaderFields(dataRows) { // Note this is Array map, not Either map. return dataRows.map(row => processRow(headerFields, row)); }; } 

. headerFields , Either, . , headerFields .map() processRows() ?

 function csvToMessages(csvData) { const csvRows = splitCSVToRows(csvData); const headerFields = csvRows.map(_.head).map(splitFields); const dataRows = csvRows.map(_.tail); // How will we pass headerFields and dataRows to // processRows() ? const funcInEither = headerFields.map(processRows); } 

.map() processRows() , . , processRows() . .map() , Either. , Either, funcInEither . . - dataRows . Left Right. .ap() .

, Left:

  // In Left (the sad path) ap() { return this; } 

Right Either :

  // In Right (the happy path) ap(otherEither) { const functionToRun = otherEither._val; return this.map(functionToRun); } 

:

  function csvToMessages(csvData) { const csvRows = splitCSVToRows(csvData); const headerFields = csvRows.map(_.head).map(splitFields); const dataRows = csvRows.map(_.tail); const funcInEither = headerFields.map(processRows); const messagesArr = dataRows.ap(funcInEither); return either(showError, showMessages, messagesArr); } 

.ap() ( Fantasy Land , ). , : « , . , Either». .ap() , . liftA2() , . , , «» (lift) «». ( , .ap() , .of() ). , liftA2 « lift, ».

, liftA2 :

 function liftA2(func) { return function runApplicativeFunc(a, b) { return b.ap(a.map(func)); }; } 

:

 function csvToMessages(csvData) { const csvRows = splitCSVToRows(csvData); const headerFields = csvRows.map(_.head).map(splitFields); const dataRows = csvRows.map(_.tail); const processRowsA = liftA2(processRows); const messagesArr = processRowsA(headerFields, dataRows); return either(showError, showMessages, messagesArr); } 

CodePen .

सच? ?

, ? , ? , . , if-. « , , ». . , . , - . if'. .

. . , - . , . Either , , . . Right, Left. , Left . , either() .

, , . , ( , , ). . , either() csvToMessages() processRow() . - . Either , . Either .

, try...catch . , . . Either , try...catch . . , , . , , . , Crocks , Sanctuary , Folktale Monet . . - .

• « », ( .)
  
• Fantasy Land
  
• « JavaScript: Either »,
  
• « JavaScript: »,