XML क्यों है:: सरल हतोत्साहित?




perl xml-simple (2)

XML::Simple के प्रलेखन से XML::Simple :

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

इस मॉड्यूल के साथ प्रमुख समस्याएं बड़ी संख्या में विकल्प और मनमाने तरीके हैं, जिसमें ये विकल्प बातचीत करते हैं - अक्सर अप्रत्याशित परिणाम के साथ।

क्या कोई मेरे लिए स्पष्ट कर सकता है कि इसके प्रमुख कारण क्या हैं?


मैं डॉक्स से असहमत हूं

मैं असंतुष्ट होकर कहूंगा कि XML::Simple बस इतना ही है .. सिंपल। और, मेरे लिए इसका इस्तेमाल करना हमेशा आसान और सुखद रहा है। आपको प्राप्त इनपुट के साथ इसका परीक्षण करें। इसलिए जब तक इनपुट नहीं बदलता, आप अच्छे हैं। XML::Simple का उपयोग करने के बारे में शिकायत करने वाले वही लोग JSON::Syck मूस को JSON::Syck करने के लिए JSON::Syck का उपयोग JSON::Syck बारे में XML::Simple शिकायत करते हैं। डॉक्स गलत हैं क्योंकि वे दक्षता से अधिक शुद्धता को ध्यान में रखते हैं। यदि आप केवल निम्नलिखित के बारे में परवाह करते हैं, तो आप अच्छे हैं:

  • डेटा फेंक नहीं है
  • एक प्रारूप में निर्मित आपूर्ति और सार स्कीमा नहीं

यदि आप एक अमूर्त पार्सर बना रहे हैं जो कि अनुप्रयोग द्वारा परिभाषित नहीं है, लेकिन कल्पना से, मैं कुछ और उपयोग करूँगा। मैंने एक बार एक कंपनी में काम किया और हमें XML के 300 अलग-अलग स्कीमा स्वीकार करने पड़े, जिनमें से किसी में भी कोई युक्ति नहीं थी। XML::Simple ने काम आसानी से कर दिया। अन्य विकल्प हमें वास्तव में काम पाने के लिए किसी को किराए पर लेने की आवश्यकता होगी। हर कोई सोचता है कि XML एक ऐसी चीज है जिसे सभी कठोर प्रारूप में भेजा जाता है, जैसे कि यदि आप एक पार्सर लिखते हैं तो आप अच्छे हैं। अगर ऐसा है तो XML::Simple उपयोग न करें XML::Simple । XML, JSON से पहले, एक भाषा से दूसरी भाषा में "यह डंप और वॉक" प्रारूप था। लोग वास्तव में XML::Dumper जैसी चीजों का इस्तेमाल करते थे। वास्तव में किसी को नहीं पता था कि आउटपुट क्या है। उस परिदृश्य के साथ काम करना XML::Simple बहुत बढ़िया है! साने लोग अभी भी JSON को उसी चीज़ को पूरा करने के लिए कल्पना के बिना डंप करते हैं। यह सिर्फ यह है कि दुनिया कैसे काम करती है।

में डेटा पढ़ना चाहते हैं, और प्रारूप के बारे में चिंता नहीं? पर्ल संरचनाओं को पार करना चाहते हैं और एक्सएमएल संभावनाओं को नहीं? जाओ XML::Simple

विस्तार से...

इसी तरह, अधिकांश अनुप्रयोगों के लिए JSON::Syck इसे डंप करने और चलने के लिए पर्याप्त है हालांकि अगर आप बहुत से लोगों को भेज रहे हैं, तो मैं अत्यधिक सुझाव दूंगा कि नोजल नोजल नहीं है और एक युक्ति बना रहा है जिसे आप निर्यात करते हैं। लेकिन, आप जानते हैं कि .. शायद ही कभी आप किसी ऐसे व्यक्ति से एक कॉल प्राप्त करने जा रहे हों जो आपसे बात नहीं करना चाहता है, जो उसका डेटा चाहता है जिसे आप सामान्य रूप से निर्यात नहीं करते हैं। और, आप इसे JSON::Syck के वूडू के माध्यम से पाइप करने जा रहे हैं और उन्हें इसके बारे में चिंता करने दें। अगर वे XML चाहते हैं? उन्हें $ 500 अधिक चार्ज करें और आपको आग लगा दें 'ole XML::Dumper

ले जाओ

यह पूर्ण से कम हो सकता है, लेकिन XML::Simple बहुत कुशल है। इस क्षेत्र में बचाए गए हर घंटे आप संभावित रूप से अधिक उपयोगी क्षेत्र में खर्च कर सकते हैं। यह एक वास्तविक विश्व विचार है।

अन्य उत्तर

देखो XPath कुछ अपडाउन है। यहाँ पर हर उत्तर पर्ल के ऊपर XPath पसंद करने के लिए उबलता है। कोई बात नहीं। यदि आप अपने XML तक पहुँचने के लिए एक मानकीकृत XML डोमेन विशिष्ट भाषा का उपयोग करेंगे, तो उस पर ध्यान दें!

पर्ल नेस्टेड वैकल्पिक संरचनाओं तक पहुंचने के लिए एक आसान तंत्र के लिए प्रदान नहीं करता है।

var $xml = [ { foo => 1 } ];  ## Always w/ ForceArray.

var $xml = { foo => 1 };

इन दो संदर्भों में यहाँ foo का मूल्य प्राप्त करना मुश्किल हो सकता है। XML::Simple को यह पता है और इसीलिए आप पूर्व को बाध्य कर सकते हैं .. हालाँकि, ForceArray साथ भी, अगर तत्व नहीं है तो आप एक त्रुटि फेंक देंगे ..

var $xml = { bar => [ { foo => 1 } ] };

अब, यदि bar वैकल्पिक है, तो आप इसे $xml->{bar}[0]{foo} और @{$xml->{bar}}[0] पहुंचाना छोड़ देंगे। वैसे भी, यह सिर्फ पर्ल है। यह XML::Simple साथ 0 करने के लिए है XML::Simple imho। और, मैंने स्वीकार किया कि XML::Simple बिल्डिंग के लिए अच्छा नहीं है। मुझे डेटा दिखाएं, और मैं इसे XML :: Simple के साथ एक्सेस कर सकता हूं।


XML :: Simple सबसे जटिल XML parser उपलब्ध है

XML के साथ मुख्य समस्या :: सरल यह है कि परिणामी संरचना सही तरीके से नेविगेट करने के लिए अत्यंत कठिन है। $ele->{ele_name} निम्नलिखित में से कोई भी लौटा सकता है (समान युक्ति का पालन करने वाले तत्वों के लिए भी):

[ { att => 'val', ..., content => 'content' }, ... ]
[ { att => 'val', ..., }, ... ]
[ 'content', ... ]
{ 'id' => { att => 'val', ..., content => 'content' }, ... }
{ 'id' => { att => 'val', ... }, ... }
{ 'id' => { content => 'content' }, ... }
{ att => 'val', ..., content => 'content' }
{ att => 'val', ..., }
'content'

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

अधिक नियमित पेड़ बनाने के विकल्प कम हो जाते हैं

अधिक नियमित पेड़ बनाने के लिए आप निम्नलिखित विकल्पों का उपयोग कर सकते हैं:

ForceArray => 1, KeyAttr => [], ForceContent => 1

लेकिन इन विकल्पों के साथ, एक पेड़ से जानकारी निकालने के लिए अभी भी कई जांच की आवश्यकता है। उदाहरण के लिए, दस्तावेज़ से /root/eles/ele नोड प्राप्त करना एक सामान्य ऑपरेशन है जिसे करने के लिए तुच्छ होना चाहिए, लेकिन XML का उपयोग करते समय निम्नलिखित आवश्यक है :: सरल:

# Requires: ForceArray => 1, KeyAttr => [], ForceContent => 1, KeepRoot => 0
# Assumes the format doesn't allow for more than one /root/eles.
# The format wouldn't be supported if it allowed /root to have an attr named eles.
# The format wouldn't be supported if it allowed /root/eles to have an attr named ele.
my @eles;
if ($doc->{eles} && $doc->{eles}[0]{ele}) {
    @eles = @{ $doc->{eles}[0]{ele} };
}

दूसरे पार्सर में, एक निम्नलिखित का उपयोग करेगा:

my @eles = $doc->findnodes('/root/eles/ele');

XML :: सरल कई सीमाएँ लगाता है, और इसमें सामान्य विशेषताओं का अभाव है

  • यह XML उत्पादन के लिए पूरी तरह से बेकार है। यहां तक ​​कि ForceArray => 1, ForceContent => 1, KeyAttr => [], KeepRoot => 1 , बहुत सारे विवरण हैं जिन्हें नियंत्रित नहीं किया जा सकता है।

  • यह अलग-अलग नामों वाले बच्चों के सापेक्ष क्रम को संरक्षित नहीं करता है।

  • इसमें नामस्थान और नेमस्पेस उपसर्गों के लिए सीमित (XML :: SAX बैकएंड के साथ) या नहीं (XML :: Parser बैकेंड के साथ) समर्थन है।

  • कुछ बैकएंड (जैसे XML :: पार्सर) ASCII (जैसे UTF-16le) के आधार पर एन्कोडिंग को संभालने में असमर्थ हैं।

  • एक तत्व में एक बाल तत्व और एक ही नाम के साथ एक विशेषता नहीं हो सकती है।

  • यह टिप्पणियों के साथ XML दस्तावेज़ नहीं बना सकता है।

पहले बताए गए प्रमुख मुद्दों को नजरअंदाज करते हुए, XML :: सरल अभी भी इन सीमाओं के साथ प्रयोग करने योग्य हो सकता है। लेकिन अगर XML :: Simple आपके दस्तावेज़ प्रारूप और जोखिम को बाद में किसी अन्य पार्सर पर स्विच करने में सक्षम हो सकता है, तो चेकिंग की समस्या पर क्यों जाएं? आप शुरू से ही अपने सभी दस्तावेजों के लिए बेहतर पार्सर का उपयोग कर सकते हैं।

न केवल कुछ अन्य पार्सर आपको इन सीमाओं के अधीन नहीं करते हैं, वे इसके अतिरिक्त अन्य उपयोगी सुविधाओं का भार प्रदान करते हैं। निम्नलिखित कुछ विशेषताएं हैं जो उनके पास हो सकती हैं कि XML :: सरल नहीं:

  • स्पीड। XML :: Simple बेहद धीमा है, खासकर अगर आप XML :: Parser के अलावा किसी बैकएंड का उपयोग करते हैं। मैं अन्य लोगों की तुलना में परिमाण के क्रम की बात कर रहा हूं।

  • XPath चयनकर्ता या समान।

  • अत्यंत बड़े दस्तावेजों के लिए समर्थन।

  • सुंदर मुद्रण के लिए समर्थन।

क्या XML :: सरल कभी उपयोगी है?

एकमात्र प्रारूप जिसके लिए XML :: सरल सबसे सरल है, जहां कोई भी तत्व वैकल्पिक नहीं है। मेरे पास अनगिनत XML प्रारूपों के साथ अनुभव है, और मैंने कभी भी इस तरह के प्रारूप का सामना नहीं किया है।

यह नाजुकता और जटिलता अकेले कारण हैं जो XML से दूर रहने के लिए पर्याप्त हैं :: सरल, लेकिन अन्य हैं।

वैकल्पिक

मैं XML :: LibXML का उपयोग करता हूं। यह एक बहुत तेज़, पूर्ण विशेषताओं वाला पार्सर है। अगर मुझे कभी स्मृति में फिट नहीं होने वाले दस्तावेज़ों को संभालने की आवश्यकता होती है, तो मैं XML :: LibXML :: Reader (और इसकी copyCurrentNode(1) ) या XML :: twig_roots ( twig_roots का उपयोग twig_roots ) का उपयोग twig_roots







xml-simple