अपने JSON पार्सर (पोल्का डॉट्स और पर्ल बटन) लिखना

यह लेख एरोन पैटरसन द्वारा लिखा गया था, जो सिएटल, वाशिंगटन के एक रूबी डेवलपर थे। वह रूबी विकास के बारे में 7 वर्षों से भावुक है और इस अद्भुत भाषा के लिए अपने प्यार को साझा करने में खुशी होगी।

सभी को सलाम! मुझे उम्मीद है कि आप अच्छे मूड में हैं। आज, सूरज थोड़ी देर के लिए बादलों के पीछे से बाहर झांकता है, इसलिए मेरे पास निश्चित रूप से पूरी तरह से सब कुछ है!

इस लेख में, हम रूबी के साथ संयोजन में उपयोग के लिए कई संकलन उपकरण देखेंगे। और विषय में गोता लगाने के लिए, हम एक JSON पार्सर लिखेंगे। पहले से ही मैं असंतुष्ट विस्मयादिबोधक सुनता हूं जैसे: "ठीक है, हारून, क्यों? वे पहले से ही 1,234,567 टुकड़े नहीं लिखे गए हैं? ”यह बात है! हमारे पास पहले से 1,234,567 रूबी जॉन्स पार्सर हैं! और हम JSON विश्लेषण भी कर रहे हैं क्योंकि इसका व्याकरण एक ही बार में काम पूरा करने के लिए काफी सरल है, और क्योंकि यह पर्याप्त रूप से रूबी के लिए समझदारी से विकसित संकलन उपकरण का उपयोग करने के लिए पर्याप्त जटिल है।

इससे पहले कि आप पढ़ना जारी रखें, मैं इस तथ्य पर ध्यान आकर्षित करना चाहता हूं कि यह JSON को पार्स करने के तरीके पर कोई लेख नहीं है, लेकिन रूबी में विश्लेषण और संकलन उपकरण का उपयोग कैसे करें।

हमें क्या चाहिए?

मैं रूबी 1.9.3 पर परीक्षण करूंगा, लेकिन यह किसी भी कार्यान्वयन पर काम करना चाहिए जो आप चुनते हैं। हम मुख्य रूप से StringScanner और StringScanner जैसे उपकरणों का उपयोग करेंगे।

RACC:

हमें स्वचालित रूप से विश्लेषक को उत्पन्न करने के लिए आरसीसी की आवश्यकता है। यह YACC के समान कई मायनों में एक LALR विश्लेषक जनरेटर है। अंतिम संक्षिप्त नाम "फिर भी एक और संकलक संकलक" (एक और संकलक संकलक) है, हालांकि, चूंकि यह रूबी के लिए एक संस्करण है, इसलिए इसने आरसीसी को बदल दिया। .y रूबी फ़ाइल के लिए व्याकरण नियमों के एक सेट ( .y एक्सटेंशन के साथ एक फ़ाइल) को परिवर्तित करने के लिए प्रतिबद्ध है जो एक राज्य मशीन के लिए संक्रमण नियमों का वर्णन करता है। बाद वाले की व्याख्या आरएसी स्टेट मशीन (रनटाइम) द्वारा की जाती है। रनटाइम रूबी के साथ आता है, लेकिन इसमें वह टूल नहीं है जो मशीन के स्टेट टेबल में ".y" एक्सटेंशन के साथ फाइलों को परिवर्तित करता है। gem install racc करके इसे gem install racc ।

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

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

StringScanner:

StringScanner एक वर्ग है जो (जैसा कि नाम से पता चलता है) आपको स्कैनर के सिद्धांत के अनुसार क्रमिक रूप से प्रक्रिया करने की अनुमति देता है। यह इस बारे में जानकारी संग्रहीत करता है कि हम कहां हैं और आपको नियमित अभिव्यक्तियों और पात्रों के प्रत्यक्ष पढ़ने का उपयोग करके शुरुआत से अंत तक स्थानांतरित करने की अनुमति देता है।

चलो शुरू हो जाओ! सबसे पहले, एक StringScanner ऑब्जेक्ट बनाएँ और इसके साथ कुछ वर्णों को संसाधित करें:

 irb(main):001:0> require 'strscan' => true irb(main):002:0> ss = StringScanner.new 'aabbbbb' => #<StringScanner 0/7 @ "aabbb..."> irb(main):003:0> ss.scan /a/ => "a" irb(main):004:0> ss.scan /a/ => "a" irb(main):005:0> ss.scan /a/ => nil irb(main):006:0> ss => #<StringScanner 2/7 "aa" @ "bbbbb"> irb(main):007:0> 

ध्यान दें कि StringScanner # स्कैन की तीसरी कॉल nil , क्योंकि इस स्थिति में नियमित अभिव्यक्ति अब फिट नहीं होती है। और यह भी, जब StringScanner उदाहरण के लिए inspect जाता है, तो आप स्ट्रिंग में हैंडलर की वर्तमान स्थिति देख सकते हैं (इस मामले में 2/7 )।

आप StringScanner # getch का उपयोग करके हैंडलर कैरेक्टर-बाय-कैरेक्टर को भी स्थानांतरित कर सकते हैं:

 irb(main):006:0> ss => #<StringScanner 2/7 "aa" @ "bbbbb"> irb(main):007:0> ss.getch => "b" irb(main):008:0> ss => #<StringScanner 3/7 "aab" @ "bbbb"> irb(main):009:0> 

getch विधि अगले वर्ण को वापस करती है और पॉइंटर को आगे बढ़ाती है।

अब जब हमने अनुक्रमिक स्ट्रिंग प्रसंस्करण की मूल बातें समझ ली हैं, तो आइए देखें कि कैसे आरएसी का उपयोग किया जाता है।

आरएसी मूल बातें

जैसा कि मैंने कहा, आरएसी एक एलएएलआर विश्लेषक जनरेटर है। हम यह मान सकते हैं कि यह एक ऐसा तंत्र है जो आपको सीमित संख्या में नियमित भाव बनाने की अनुमति देता है, जो बदले में विभिन्न पदों पर मनमाने ढंग से कोड निष्पादित कर सकता है कि उनकी तुलना कैसे की जाती है।

आइए एक उदाहरण देखें। मान लें कि हम फ़ॉर्म की नियमित अभिव्यक्ति प्रतिस्थापन के लिए जाँच करना चाहते हैं: (a|c)*abb | दूसरे शब्दों में, ऐसे मामलों को दर्ज करें जब 'अ' या 'ग' के बाद वर्णों की एक मनमानी संख्या होती है। इसे एक आरसीआर व्याकरण में अनुवाद करने के लिए, हम इस नियमित अभिव्यक्ति को इसके घटक भागों में तोड़ने की कोशिश करेंगे, और फिर इसे फिर से एक साथ रखेंगे। प्रत्येक व्यक्तिगत व्याकरण तत्व को एक उत्पत्ति नियम या उत्पाद कहा जाता है। तो, आइए इस अभिव्यक्ति को अलग करते हुए देखें कि उत्पाद कैसे दिखते हैं और आरसीसी का व्याकरण किस प्रारूप में है।

सबसे पहले, एक व्याकरण फ़ाइल बनाएँ। फ़ाइल की शुरुआत में रूबी वर्ग की घोषणा है जिसे हम प्राप्त करना चाहते हैं, इसके बाद rule कीवर्ड का अर्थ है कि हम उत्पादों की घोषणा करने जा रहे हैं, उसके बाद end कीवर्ड, उनके अंत का संकेत देते हैं:

 class Parser rule end 

अब "a | c" के लिए उत्पाद जोड़ें। चलो उसे a_or_c कहते हैं:

 class Parser rule a_or_c : 'a' | 'c' ; end 

परिणामस्वरूप, हमारे पास नियम a_or_c , जो 'a' या 'c' अक्षर से मेल खाता है। तुलना एक या अधिक बार करने के लिए, हम एक पुनरावर्ती उत्पाद बनाएंगे, जिसे हम a_or_cs :

 class Parser rule a_or_cs : a_or_cs a_or_c | a_or_c ; a_or_c : 'a' | 'c' ; end 

जैसा कि मैंने कहा, a_or_cs का उत्पादन प्रकृति में पुनरावर्ती है, नियमित अभिव्यक्ति के बराबर होने (a|c)+ । अगला, 'abb' के लिए उत्पाद जोड़ें:

 class Parser rule a_or_cs : a_or_cs a_or_c | a_or_c ; a_or_c : 'a' | 'c' ; abb : 'a' 'b' 'b'; end 

और सभी स्ट्रिंग उत्पादन को पूरा करें:

 class Parser rule string : a_or_cs abb | abb ; a_or_cs : a_or_cs a_or_c | a_or_c ; a_or_c : 'a' | 'c' ; abb : 'a' 'b' 'b'; end 

यह अंतिम आउटपुट उस पैटर्न से मेल खाता है जिसमें एक या अधिक अक्षर 'a' या 'c' के बाद 'abb' या फ्री-स्टैंडिंग स्ट्रिंग 'abb' मौजूद है। यह सब हमारे मूल नियमित रूप के समान है (a|c)*abb ।

हारून, लेकिन यह बहुत उबाऊ है!

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

 class Parser rule string : a_or_cs abb | abb { puts " abb, !" } ; a_or_cs : a_or_cs a_or_c | a_or_c ; a_or_c : 'a' | 'c' ; abb : 'a' 'b' 'b'; end 

कोड जिसे हम निष्पादित करना चाहते हैं, उसे घुंघराले ब्रेसिज़ में संलग्न किया जाना चाहिए और उस नियम के तुरंत बाद स्थित होना चाहिए जो इसके निष्पादन के लिए जिम्मेदार होगा। अब हम अपना स्वयं का JSON विश्लेषक तैयार करने के लिए तैयार हैं, जो हमारे मामले में अर्जित ज्ञान से लैस होकर घटना आधारित होगा।

एक विश्लेषक बनाएँ

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

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

लेक्सिकल विश्लेषक

हमारा लेक्सिकल विश्लेषक एक IO सुविधा पर बनाया गया है। यह इससे है कि हम स्रोत डेटा पढ़ेंगे। हर बार next_token कहा जाता है next_token लेक्सिकल विश्लेषक इनपुट स्ट्रीम से एक टोकन पढ़ता है और इसे वापस करता है। यह टोकन की निम्नलिखित सूची के साथ काम करेगा, जिसे हमने JSON विनिर्देशों से उधार लिया था:

• स्ट्रिंग्स (रेखाएं)
• नंबर (संख्या)
• यह सच है (सत्य)
• झूठी (झूठी)
• नल (कोई मूल्य नहीं)

सरणियों और वस्तुओं जैसे जटिल प्रकारों के लिए, पार्सर जिम्मेदार होगा।

अगले द्वारा वापस किए गए मान next_token :

जब पार्सर लेक्सिकल एनालाइज़र के next_token कॉल करता है, तो इसके परिणामस्वरूप दो तत्वों की एक सरणी प्राप्त करने की अपेक्षा की जाती है। सरणी के पहले तत्व में टोकन का नाम होना चाहिए, और दूसरा कुछ भी हो सकता है (आमतौर पर यह केवल मिलान पाठ है)। nil लौटने nil शाब्दिक विश्लेषक रिपोर्ट करता है कि अधिक टोकन नहीं हैं।

Tokenizer लेक्सिकल विश्लेषक Tokenizer :

आइए क्लास कोड देखें और देखें कि यह क्या करता है:

 module RJSON class Tokenizer STRING = /"(?:[^"\\]|\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4}))*"/ NUMBER = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/ TRUE = /true/ FALSE = /false/ NULL = /null/ def initialize io @ss = StringScanner.new io.read end def next_token return if @ss.eos? case when text = @ss.scan(STRING) then [:STRING, text] when text = @ss.scan(NUMBER) then [:NUMBER, text] when text = @ss.scan(TRUE) then [:TRUE, text] when text = @ss.scan(FALSE) then [:FALSE, text] when text = @ss.scan(NULL) then [:NULL, text] else x = @ss.getch [x, x] end end end end 

पहले कई नियमित अभिव्यक्तियों की घोषणाएं करें, जिनका उपयोग हम स्ट्रिंगसेंकेर स्ट्रिंग हैंडलर के साथ मिलकर करेंगे। वे json.org से ली गई परिभाषाओं के आधार पर बनाए गए हैं। कंस्ट्रक्टर में एक StringScanner इंस्टेंस बनाया जाता है। चूंकि इसे बनाते समय एक स्ट्रिंग की आवश्यकता होती है, इसलिए हम IO ऑब्जेक्ट के पढ़ने को आमंत्रित करते हैं। यह, हालांकि, एक वैकल्पिक कार्यान्वयन को बाहर नहीं करता है जिसमें लेक्सिकल विश्लेषक ऑब्जेक्ट के IO से डेटा नहीं पढ़ता है, लेकिन आवश्यकतानुसार।

मुख्य कार्य next_token विधि में किया जाता है। स्ट्रिंग हैंडलर में अधिक डेटा नहीं होने पर यह nil हो जाता है, अन्यथा यह प्रत्येक नियमित अभिव्यक्ति की जांच करेगा जब तक कि यह सही न मिल जाए। यदि कोई मिलान पाया गया था, तो यह उस पाठ के साथ टोकन नाम (उदाहरण के लिए :STRING ) लौटाएगा जो पैटर्न से मेल खाता है। यदि नियमित अभिव्यक्तियों में से कोई भी मेल नहीं खाता है, तो एक चरित्र हैंडलर से पढ़ा जाएगा, और रीड वैल्यू टोकन के नाम और उसके मूल्य के रूप में एक साथ वापस आ जाएगी।

आइए JSON फॉर्मेट में लेक्सिकल एनालाइज़र को एक स्ट्रिंग का उदाहरण दें और देखें कि आउटपुट में हमें कौन से टोकन मिलते हैं:

 irb(main):003:0> tok = RJSON::Tokenizer.new StringIO.new '{"foo":null}' => #<RJSON::Tokenizer:0x007fa8529fbeb8 @ss=#<StringScanner 0/12 @ "{\"foo...">> irb(main):004:0> tok.next_token => ["{", "{"] irb(main):005:0> tok.next_token => [:STRING, "\"foo\""] irb(main):006:0> tok.next_token => [":", ":"] irb(main):007:0> tok.next_token => [:NULL, "null"] irb(main):008:0> tok.next_token => ["}", "}"] irb(main):009:0> tok.next_token => nil 

इस उदाहरण में, हमने IO के साथ बतख टाइपिंग प्राप्त करने के लिए स्ट्रिंग स्ट्रिंग ऑब्जेक्ट में JSON स्ट्रिंग StringIO । इसके बाद, कुछ टोकन पढ़ने का प्रयास करें। विश्लेषक के लिए परिचित प्रत्येक टोकन में एक ऐसा नाम होता है जो सरणी के पहले तत्व के साथ आता है, जबकि अज्ञात टोकन में यह स्थान एक वर्ण द्वारा कब्जा कर लिया जाता है। उदाहरण के लिए, लाइन टोकन [:STRING, "foo"] और अज्ञात टोकन, विशेष स्थिति में, ['(', '('] । अंत में, जब इनपुट डेटा समाप्त हो जाएगा, तो आउटपुट nil हो जाएगा।

यह शाब्दिक विश्लेषक के साथ काम पूरा करता है। इनपुट पर इनिशियलाइज़ेशन के दौरान, यह एक IO ऑब्जेक्ट प्राप्त करता है और एक एकल next_token विधि को लागू करता है। आप सभी पार्सर जा सकते हैं।

पार्सर

सिंटेक्स में आने का समय हो गया है। शुरू करने के लिए, चलो थोड़ा रेक काम करते हैं। हमें एक .y फ़ाइल के आधार पर रूबी-आधारित फ़ाइल पीढ़ी को लागू करने की आवश्यकता है। सिर्फ rake लिए नौकरी ^१ ।

हम संकलन कार्य का वर्णन करते हैं:

सबसे पहले, हम रेक-फाइल में एक नियम जोड़ेंगे जो कहता है: " .y फ़ाइलों को .rb फ़ाइलों में निम्न कमांड का उपयोग करके परिवर्तित करें : "

 rule '.rb' => '.y' do |t| sh "racc -l -o #{t.name} #{t.source}" end 

फिर हम "संकलित" कार्य जोड़ते हैं, जो उत्पन्न parser.rb फ़ाइल पर निर्भर करता है।

 task :compile => 'lib/rjson/parser.rb' 

चूँकि व्याकरण फ़ाइल को lib/rjson/parser.y में संग्रहीत किया जाता है, अब जब हम rake compile चलाते हैं, रेक स्वचालित रूप से .y फ़ाइल को एक्सटेंशन के साथ .rb का उपयोग करके एक फ़ाइल में परिवर्तित कर .y ।

और अंत में, हम "परीक्षण" कार्य को "संकलन" कार्य पर निर्भर करेंगे, ताकि जब हम rake test चलाएं, तो संकलित संस्करण स्वतः उत्पन्न हो जाए:

 task :test => :compile 

अब आप .y फ़ाइल के संकलन और सत्यापन पर सीधे जा सकते हैं।

JSON.org विनिर्देशन पार्स करना:

अब हम json.org से चार्ट्स का अनुवाद करने जा रहे हैं। स्रोत दस्तावेज़ की जड़ में या तो एक ऑब्जेक्ट या एक सरणी होना चाहिए, इसलिए हम एक document उत्पादन बनाएंगे जो ऑब्जेक्ट - object या सरणी - array मेल खाता है:

 rule document : object | array ; 

आगे हम array के उत्पादों को परिभाषित करते हैं। सरणी के लिए उत्पाद या तो खाली हो सकते हैं या उनमें एक या अधिक मान हो सकते हैं:

  array : '[' ']' | '[' values ']' ; 

मूल्यों के लिए उत्पादन को एक मान के रूप में पुनरावर्ती रूप से परिभाषित किया जाता है, या कई मान अल्पविराम द्वारा अलग किए जाते हैं:

  values : values ',' value | value ; 

JSON विनिर्देशन में, value को एक स्ट्रिंग, संख्या, वस्तु, सरणी, सही (सत्य), असत्य (असत्य), या अशक्त (कोई मूल्य) के रूप value परिभाषित किया जाता है। हमारी परिभाषा समान होगी, केवल अंतर यह होगा कि NUMBER (संख्या), TRUE (सत्य) और FALSE (गलत) जैसे तात्कालिक मानों के लिए हम लेक्सिकल विश्लेषक में परिभाषित संबंधित टोकन नामों का उपयोग करते हैं:

  value : string | NUMBER | object | array | TRUE | FALSE | NULL ; 

हम ऑब्जेक्ट ( object ) के लिए उत्पादों की परिभाषा पर आगे बढ़ते हैं। ऑब्जेक्ट रिक्त हो सकते हैं, या जोड़े से मिलकर बन सकते हैं:

  object : '{' '}' | '{' pairs '}' ; 

एक या कई जोड़े हो सकते हैं और उन्हें अल्पविराम द्वारा अलग किया जाना चाहिए। फिर से, पुनरावर्ती परिभाषा का उपयोग करें:

  pairs : pairs ',' pair | pair ; 

अंत में, एक जोड़ी को परिभाषित करें, जो एक स्ट्रिंग है और एक कोलन द्वारा अलग की गई संख्या है:

  pair : string ':' value ; 

अब आरसीसी को हमारे लेक्सिकल टोकन के बारे में सूचित करें, जो बहुत शुरुआत में एक परिभाषा जोड़ रहा है, और हमारा पार्सर तैयार है:

 class RJSON::Parser token STRING NUMBER TRUE FALSE NULL rule document : object | array ; object : '{' '}' | '{' pairs '}' ; pairs : pairs ',' pair | pair ; pair : string ':' value ; array : '[' ']' | '[' values ']' ; values : values ',' value | value ; value : string | NUMBER | object | array | TRUE | FALSE | NULL ; string : STRING ; end 

डॉक्यूमेंट हैंडलर

दस्तावेज़ हैंडलर हमारे पार्सर से घटनाओं को प्राप्त करेगा। वह JSON के अद्भुत टुकड़ों से हमारी अतुलनीय रूबी वस्तु का निर्माण करेगा! आपके विवेक पर मैं जितने इवेंट छोड़ता हूं, लेकिन मैं खुद को 5 तक सीमित रखूंगा:

• start_object - वस्तु की शुरुआत में कहा जाता है
• end_object - वस्तु के अंत में कहा जाता है
• start_array - सरणी की शुरुआत में कहा जाता है
• end_array - सरणी के अंत में कहा जाता है
• scalar - टर्मिनल मामलों में बुलाया जाता है जैसे तार, सच, गलत, आदि।

इन पांच घटनाओं का उपयोग करते हुए, हम एक ऑब्जेक्ट इकट्ठा करेंगे जो मूल JSON संरचना को दर्शाता है।

हम घटनाओं का अनुसरण करते हैं

हमारा हैंडलर बस पार्सर से आने वाली घटनाओं पर नज़र रखेगा। परिणाम एक पेड़ की संरचना है, जिसके आधार पर हम अंतिम रूबी ऑब्जेक्ट का निर्माण करेंगे।

 module RJSON class Handler def initialize @stack = [[:root]] end def start_object push [:hash] end def start_array push [:array] end def end_array @stack.pop end alias :end_object :end_array def scalar(s) @stack.last << [:scalar, s] end private def push(o) @stack.last << o @stack << o end end end 

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

मैं बाहर नहीं करता हूं कि पहली बार समझना मुश्किल है, इसलिए चलो कुछ उदाहरणों को देखें। JSON स्ट्रिंग को फॉर्म {"foo":{"bar":null}} में पास करने पर, हमें @stack स्टैक चर में निम्नलिखित मिलता है:

 [[:root, [:hash, [:scalar, "foo"], [:hash, [:scalar, "bar"], [:scalar, nil]]]]] 

उदाहरण के लिए, @stack में @stack का एक @stack ["foo",null,true] , हमें निम्नलिखित मिलता है:

 [[:root, [:array, [:scalar, "foo"], [:scalar, nil], [:scalar, true]]]] 

रूबी में परिवर्तित करें:

इस प्रकार JSON दस्तावेज़ का एक मध्यवर्ती प्रतिनिधित्व प्राप्त करने के बाद, हम इसे रूबी में एक डेटा संरचना में बदलने के लिए आगे बढ़ते हैं। ऐसा करने के लिए, हम परिणामस्वरूप पेड़ के प्रसंस्करण के लिए एक पुनरावर्ती कार्य लिखते हैं:

 def result root = @stack.first.last process root.first, root.drop(1) end private def process type, rest case type when :array rest.map { |x| process(x.first, x.drop(1)) } when :hash Hash[rest.map { |x| process(x.first, x.drop(1)) }.each_slice(2).to_a] when :scalar rest.first end end 

result विधि root नोड को हटा देती है और process विधि को छोड़ दिया जाता है। जब process एक hash चरित्र का पता लगाती है, तो यह पुनरावर्ती कॉल के बच्चों को process लिए एक सहयोगी सरणी बनाती process । इसके समान, वर्ण array के सामने आने पर, सरणी के बच्चों पर एक पुनरावर्ती कॉल एक सरणी का निर्माण करता है। स्केलर मान - scalar प्रसंस्करण के बिना लौटाए scalar (जो अनंत पुनरावृत्ति को रोकता है)। अब, यदि हम अपने हैंडलर से result कहते हैं, तो हमें आउटपुट पर रूबी ऑब्जेक्ट मिलता है।
आइए देखें कि यह व्यवहार में कैसे काम करता है:

 require 'rjson' input = StringIO.new '{"foo":"bar"}' tok = RJSON::Tokenizer.new input parser = RJSON::Parser.new tok handler = parser.parse handler.result # => {"foo"=>"bar"} 

सॉफ्टवेयर इंटरफ़ेस में सुधार:

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

 module RJSON def self.load(json) input = StringIO.new json tok = RJSON::Tokenizer.new input parser = RJSON::Parser.new tok handler = parser.parse handler.result end end 

चूंकि हमारा विश्लेषक मूल रूप से एक IO ऑब्जेक्ट पर आधारित था, इसलिए हम उन लोगों के लिए एक विधि जोड़ सकते हैं जो इनपुट पर सॉकेट या फ़ाइल डिस्क्रिप्टर को स्थानांतरित करना चाहते हैं:

 module RJSON def self.load_io(input) tok = RJSON::Tokenizer.new input parser = RJSON::Parser.new tok handler = parser.parse handler.result end def self.load(json) load_io StringIO.new json end end 

हम यह सुनिश्चित करते हैं कि इंटरफ़ेस थोड़ा और सुविधाजनक हो गया है:

 require 'rjson' require 'open-uri' RJSON.load '{"foo":"bar"}' # => {"foo"=>"bar"} RJSON.load_io open('http://example.org/some_endpoint.json') 

विचार जोर से

तो, विश्लेषक पर काम पूरा हो गया है। इस प्रक्रिया में, हम संकलन तकनीक से परिचित हुए, जिसमें पार्सिंग और लेक्सिकल विश्लेषण की मूल बातें शामिल हैं, और यहां तक ​​कि दुभाषियों पर भी छुआ गया (यह वास्तव में, हम JSON की व्याख्या करने में लगे हुए थे)। आपके पास गर्व करने के लिए कुछ है!

हमारे द्वारा लिखा गया विश्लेषक काफी लचीला निकला। हम कर सकते हैं:

• एक हैंडलर हैंडलर को लागू करके एक घटना प्रतिमान में इसका उपयोग करें
• एक सरलीकृत इंटरफ़ेस का उपयोग करें और बस इनपुट के लिए तार पास करें
• IO ऑब्जेक्ट के माध्यम से JSON फॉर्मेट में स्ट्रीम भेजने के लिए

मुझे उम्मीद है कि यह लेख आपको आत्मविश्वास देगा, और आप रूबी में लागू किए गए विश्लेषण और संकलन प्रौद्योगिकियों के साथ अपने दम पर प्रयोग करना शुरू कर देंगे। यदि आपके पास अभी भी मेरे लिए प्रश्न हैं, तो टिप्पणियों में आपका स्वागत है।

पुनश्च

अंत में, मैं कुछ विवरणों को स्पष्ट करना चाहता हूं जिन्हें मैंने प्रस्तुति के दौरान छोड़ दिया था, ताकि अतिरिक्त अस्पष्टता का परिचय न हो:

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

वह सब है। आपका ध्यान के लिए धन्यवाद!

---

¹ अंग्रेजी रेक - रेक

अनुवाद पर टिप्पणियाँ, कृपया एक व्यक्तिगत में भेजें।