🙍🏾 👼🏿 🎧 पायथन और जावास्क्रिप्ट में एनालॉग्स। भाग दो 👂🏼 👩🏻‍🌾 🛣️

हम दो भाषाओं के बीच समानता और अंतर पर लेखों की एक श्रृंखला का अनुवाद जारी रखते हैं।

आज हम शब्दकोशों क्रमांकन, JSON, नियमित, त्रुटियों और अपवादों के बारे में बात करेंगे।

इस श्रृंखला के अन्य लेख:

पहला भाग प्रकार रूपांतरण, टर्नरी ऑपरेटर, संपत्ति के नाम, शब्दकोष, सूचियों, तार, स्ट्रिंग संघनन द्वारा संपत्ति तक पहुंच है।
यह लेख
भाग तीन : आधुनिक पायथन और जेएस: स्ट्रिंग पैटर्न (एफ-लाइन), सूची अनपैकिंग, लैम्ब्डा फ़ंक्शन, सूची पुनरावृत्तियों, जनरेटर, सेट।
चौथा हिस्सा फ़ंक्शन तर्क, कक्षाएं, विरासत, सेटर गेटर्स और क्लास प्रॉपर्टीज़ के साथ बनाना और काम करना है।

JSON

कई एपीआई के साथ काम करते समय, ट्रांसफर और बाद के पार्सिंग में आसानी के लिए JSON ऑब्जेक्ट्स में ऑब्जेक्ट्स को सीरियल करना सुविधाजनक होता है।

पायथन में एक मानक जेट मॉड्यूल है:

import json json_data = json.dumps(dictionary, indent=4) dictionary = json.loads(json_data)

यहाँ हम JSON को 4 स्थानों के इंडेंटेशन के साथ प्रारूपित करते हैं।

JS में, JSON स्ट्रिंग्स बनाने और पार्स करने के तरीकों के साथ एक JSON ऑब्जेक्ट है:

 json_data = JSON.stringify(dictionary, null, 4); dictionary = JSON.parse(json_data);

पार्स नियमित के साथ तार

पिछले लेख में, हमने कई पंक्तियों को एक में जोड़ा। लेकिन एक लंबी स्ट्रिंग को कई में कैसे बांटा जाए, खासकर अगर विभाजक अल्पविराम की तरह एकल वर्ण नहीं है, लेकिन विभिन्न विकल्पों की एक पूरी श्रृंखला है? यह वह जगह है जहाँ नियमित अभिव्यक्ति और split() विधि split() में आती है।

पायथन में, split() विधि एक नियमित अभिव्यक्ति पैटर्न को संदर्भित करता है। यहाँ एक पाठ स्ट्रिंग को विराम चिह्नों में विभाजित करने का तरीका बताया गया है:

 import re #     "!?."         delimiter = re.compile(r'[!?\.]+\s*') text = "Hello!!! What's new? Follow me." sentences = delimiter.split(text) # sentences == ['Hello', "What's new", 'Follow me', '']

जेएस में, split() विधि तार को संदर्भित करता है:

 //     "!?."         delimiter = /[!?\.]+\s*/; text = "Hello!!! What's new? Follow me."; sentences = text.split(delimiter) // sentences === ["Hello", "What's new", "Follow me", ""]

पैटर्न द्वारा नियमित खोज

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

पाठ्यक्रम में अनुवाद के लेखक

नियमित के साथ पते की जाँच करना एक गैर-तुच्छ कार्य है और इस लेख में दी गई विधि की तुलना में कुछ अधिक जटिल है

पायथन में, यह कुछ इस तरह दिखाई देगा:

 import re # name, "@", and domain pattern = re.compile(r'([\w.+\-]+)@([\w\-]+\.[\w\-.]+)') match = pattern.match('hi@example.com') # match.group(0) == 'hi@example.com' # match.group(1) == 'hi' # match.group(2) == 'example.com'

यदि पाठ का एक खंड टेम्पलेट से मेल खाता है, तो group() पद्धति का उपयोग करके पूरे खंड को वापस लौटाता है जिसमें आप टेम्पलेट में परिभाषित व्यक्तिगत समूहों का चयन कर सकते हैं।

0 - पूरी लाइन (उप) मिलान, 1 - पहला समूह, 2 - दूसरा, आदि।

यदि कोई मिलान नहीं पाया जाता है, तो कोई None प्रकार की वस्तु वापस None जाएगी।

JS में, एक स्ट्रिंग विधि match() जो किसी स्ट्रिंग या null के मिलान किए गए हिस्से को लौटाता है।

 // name, "@", and domain pattern = /([\w.+\-]+)@([\w\-]+\.[\w\-.]+)/; match = 'hi@example.com'.match(pattern); // match[0] === 'hi@example.com' // match[1] === 'hi' // match[2] === 'example.com'

जेएस में, मिलान की गई वस्तु एक सरणी की तरह दिखती है। सूचकांक वाला तत्व [0] पूरी (उप) पंक्ति है जो मेल खाती है, पहला तत्व पहला समूह है, दूसरा तत्व दूसरा है, आदि। - सभी टेम्पलेट में परिभाषित समूहों के अनुसार।

कभी-कभी, खोज के अलावा, पाठ में नमूने की स्थिति निर्धारित करना आवश्यक है। यह search() विधि का उपयोग करके किया जा सकता है।
पायथन में, यह विधि नियमित अभिव्यक्तियों को संदर्भित करती है और एक मिलान वस्तु लौटाती है। इस मिलान वस्तु की एक start() विधि है जो मुख्य लाइन में इस सबस्ट्रिंग की घटना की शुरुआत को लौटाती है:

 text = 'Say hi at hi@example.com' first_match = pattern.search(text) if first_match: start = first_match.start() # start == 10

जेएस विधि में एक स्ट्रिंग विधि search() प्रतिस्थापन की शुरुआत के सूचकांक को लौटाती है। या -1 अगर कोई मैच नहीं मिला।

 text = 'Say hi at hi@example.com'; first_match = text.search(pattern); if (first_match > -1) { start = first_match; // start === 10 }

नियमित अभिव्यक्ति का उपयोग करके पैटर्न द्वारा प्रतिस्थापित करें

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

पायथन में इसके लिए एक sub() रेगेक्स पैटर्न विधि है:

 html = pattern.sub( r'<a href="mailto:\g<0>">\g<0></a>', 'Say hi at hi@example.com', ) # html == 'Say hi at <a href="mailto:hi@example.com">hi@example.com</a>'

JS डेवलपर replace() स्ट्रिंग विधि का उपयोग कर सकते हैं:

 html = 'Say hi at hi@example.com'.replace( pattern, '<a href="mailto:$&">$&</a>', ); // html === 'Say hi at <a href="mailto:hi@example.com">hi@example.com</a>'

पायथन में, मिलान समूह \g<0>, \g<1>, \g<2> , आदि के रूप में उपलब्ध हैं।
जेएस में, जैसे $&, $1, $2 , आदि।

मिलान वाले हिस्से को एक फ़ंक्शन के साथ बदलना भी संभव है। स्रोत पाठ के रैपिंग की जगह या गिनती के लिए, पाठ के बारे में अन्य जानकारी प्राप्त करने, एकत्र करने या प्राप्त करने के लिए ऐसे कार्य उपयोगी होते हैं। उदाहरण के लिए, जब मैं प्रतिस्थापित करते समय फ़ंक्शन कॉल का उपयोग करता हूं, तो मैं HTML सिंटैक्स हाइलाइटिंग लिख सकता हूं।

आइए CAPITAL LETTERS में सभी ई-मेल पते बदलें।

पायथन में, प्रतिस्थापित फ़ंक्शन को मिलान की गई वस्तु मिलती है। हम मिलान पाठ के साथ क्रिया करने और उसे प्रतिस्थापन के रूप में वापस करने के लिए समूह () विधि का उपयोग करते हैं:

 text = pattern.sub( lambda match: match.group(0).upper(), 'Say hi at hi@example.com', ) # text == 'Say hi at HI@EXAMPLE.COM'

जेएस में, प्रतिस्थापित फ़ंक्शन को पूरे स्ट्रिंग मिलान, पहली घटना, दूसरा, आदि मिलता है। हम आवश्यक कार्रवाई करते हैं और संशोधित रेखा लौटाते हैं:

 text = 'Say hi at hi@example.com'.replace( pattern, function(match, p1, p2) { return match.toUpperCase(); } ); // text === 'Say hi at HI@EXAMPLE.COM'

हैंडलिंग में त्रुटि

पायथन के विपरीत, फ्रंट-एंड ब्राउज़र-आधारित जावास्क्रिप्ट आमतौर पर फ़ाइलों को लिखने / पढ़ने या डेटाबेस तक पहुंचने के लिए उपयोग नहीं किया जाता है। इसलिए, try..catch ब्लॉक की try..except की तुलना में जेएस में ब्लॉक काफी दुर्लभ try..catch ।

लेकिन, किसी भी मामले में, त्रुटि हैंडलिंग उपयोगकर्ता स्क्रिप्ट में, लाइब्रेरी फ़ंक्शन से कॉल की जा सकती है, और मुख्य कोड में इंटरसेप्ट की जा सकती है।

निम्नलिखित MyException उदाहरण में, हम अपने MyException को परिभाषित करेंगे, इसे एक फ़ंक्शन में MyException , और देखें कि इसे कैसे पकड़ा जाए और इसे try..except..finally ब्लॉक में हैंडल करें:

 class MyException(Exception): def __init__(self, message): self.message = message def __str__(self): return self.message def proceed(): raise MyException('Error happened!') try: proceed() except MyException as err: print('Sorry! {}'.format(err)) finally: print('Finishing')

निम्न JS कोड समान है - हम MyException क्लास को परिभाषित करते हैं, इसे एक फंक्शन में MyException , इंटरसेप्ट करते हैं और इसे एक try..catch..finally ब्लॉक में प्रोसेस करते हैं:

 function MyException(message) { this.message = message; this.toString = function() { return this.message; } } function proceed() { throw new MyException('Error happened!'); } try { proceed(); } catch (err) { if (err instanceof MyException) { console.log('Sorry! ' + err); } } finally { console.log('Finishing'); }

दोनों भाषाओं में, MyException class में message पैरामीटर और message के मूल्य के आधार पर स्ट्रिंग प्रतिनिधित्व के लिए एक विधि है।

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

निष्कर्ष

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

जैसा कि पिछली बार कहा गया था, आप समान डेटा संरचनाओं और उनके साथ काम करने के तरीकों को समझने के लिए यहां दिए गए कोड उदाहरणों की रेखा-दर-पंक्ति कर सकते हैं: तार, सरणियाँ, शब्दकोशों, वस्तुओं तक पहुंच।

अगले भाग में, हम पाठ पैटर्न, अनपैकिंग लिस्ट, लैम्ब्डा फंक्शन्स, इंडेक्स, जनरेटर और सेट का उपयोग किए बिना पुनरावृत्तियों के बारे में बात करेंगे।