XML पार्स करणे म्हणजे XML दस्तऐवजातून जाणे आणि संबंधित डेटा परत करणे. जरी वेब सेवांची वाढती संख्या JSON स्वरूपात डेटा परत करते, तरीही बहुतेक XML वापरतात, त्यामुळे तुम्हाला उपलब्ध API ची संपूर्ण श्रेणी वापरायची असल्यास XML पार्सिंगमध्ये प्रभुत्व मिळवणे महत्त्वाचे आहे.
विस्तार वापरणे SimpleXML PHP मध्ये, जे PHP 5.0 मध्ये परत जोडले गेले होते, XML सह काम करणे खूप सोपे आणि सोपे आहे. या लेखात, मी तुम्हाला ते कसे करायचे ते दर्शवेल.
वापर मूलभूत
चला खालील उदाहरणाने सुरुवात करूया language.xml:
>
>
>
>
या XML दस्तऐवजात प्रत्येक भाषेबद्दल काही माहितीसह प्रोग्रामिंग भाषांची सूची आहे: त्याच्या अंमलबजावणीचे वर्ष आणि त्याच्या निर्मात्याचे नाव.
पहिली पायरी म्हणजे फंक्शन्स वापरून XML लोड करणे simplexml_load_file(), किंवा simplexml_load_string(). फंक्शन्सच्या नावाप्रमाणे, पहिला फाईलमधून XML लोड करेल आणि दुसरा स्ट्रिंगमधून XML लोड करेल.
दोन्ही फंक्शन्स संपूर्ण DOM ट्री मेमरीमध्ये वाचतात आणि ऑब्जेक्ट परत करतात SimpleXMLE घटक. वरील उदाहरणात, ऑब्जेक्ट $languages व्हेरिएबलमध्ये संग्रहित केले आहे. तुम्ही फंक्शन्स वापरू शकता var_dump()किंवा print_r()तुम्हाला हवे असल्यास परत केलेल्या वस्तूबद्दल तपशीलवार माहिती मिळवण्यासाठी.
SimpleXMLElement ऑब्जेक्ट
[lang] => अॅरे
[ 0 ] => SimpleXMLElementObject
[@attributes] => अॅरे
[नाम] => सी
[दिसले] => १९७२
[निर्माता] => डेनिस रिची
[ 1 ] => SimpleXMLElement ऑब्जेक्ट
[@attributes] => अॅरे
[नाम] => PHP
[दिसले] => 1995
[ निर्माता] => रॅस्मस लेर्डॉर्फ
[ 2 ] => SimpleXMLElement ऑब्जेक्ट
[@attributes] => अॅरे
[नाम] => जावा
[दिसले] => 1995
[निर्माता] => जेम्स गोसलिंग
)
)
या XML मध्ये मूळ घटक आहे भाषा, ज्यामध्ये तीन घटक आहेत langप्रत्येक अॅरे घटक घटकाशी संबंधित असतो इंग्रजी XML दस्तऐवजात.
तुम्ही ऑपरेटर वापरून ऑब्जेक्टच्या गुणधर्मांमध्ये प्रवेश करू शकता -> . उदाहरणार्थ, $languages->lang तुम्हाला पहिल्या घटकाशी जुळणारा SimpleXMLElement ऑब्जेक्ट देईल इंग्रजी. या ऑब्जेक्टमध्ये दोन गुणधर्म आहेत: प्रकट आणि निर्माता.
$languages -> lang [ 0 ] -> दिसू लागले;
$languages -> lang [ 0 ] -> निर्माता ;
भाषांची सूची प्रदर्शित करणे आणि त्यांचे गुणधर्म प्रदर्शित करणे मानक लूपसह खूप सोपे आहे जसे की प्रत्येकासाठी.
foreach ($languages -> lang $lang म्हणून) (
printf (
""
,
$lang["नाव"],
$lang -> दिसू लागले,
$lang -> निर्माता
)
;
}
भाषेचे नाव मिळविण्यासाठी मी lang घटकाचे गुणधर्म नाव कसे ऍक्सेस केले ते पहा. अशा प्रकारे तुम्ही SimpleXMLElement ऑब्जेक्ट म्हणून दर्शविलेल्‍या घटकाची कोणतीही विशेषता अ‍ॅक्सेस करू शकता.
नेमस्पेससह कार्य करणे
विविध वेब सेवांच्या XML सह काम करताना, तुम्हाला अनेकदा घटक नेमस्पेसेस भेटतील. चला आपल्यात बदल करूया language.xmlनेमस्पेस वापरण्याचे उदाहरण दाखवण्यासाठी:
xmlns:dc =>
>
>
>
>
आता घटक निर्मातानेमस्पेसमध्ये ठेवले आहे डीसी, जे http://purl.org/dc/elements/1.1/ कडे निर्देश करते. आमचा मागील कोड वापरून तुम्ही भाषा निर्माते मुद्रित करण्याचा प्रयत्न केल्यास, ते कार्य करणार नाही. घटक नेमस्पेस वाचण्यासाठी तुम्हाला खालीलपैकी एक पद्धत वापरावी लागेल.
घटकाच्या नेमस्पेसचा संदर्भ देताना कोडमध्ये थेट URI नावे वापरणे हा पहिला दृष्टिकोन आहे. हे कसे केले जाते हे खालील उदाहरण दाखवते:
$dc = $languages -> lang [ 1 ] -> मुले( "http://purl.org/dc/elements/1.1/")
;
echo $dc -> निर्माता ;
पद्धत मुले()एक नेमस्पेस घेते आणि उपसर्गाने सुरू होणारे मूल घटक मिळवते. यास दोन वितर्क लागतात, पहिला XML नेमस्पेस आहे आणि दुसरा पर्यायी युक्तिवाद आहे जो डीफॉल्ट आहे खोटे. जर दुसरा युक्तिवाद TRUE वर सेट केला असेल, तर नेमस्पेस उपसर्ग मानला जाईल. FALSE असल्यास, नेमस्पेस URL नेमस्पेस मानली जाईल.
दुसरा दृष्टिकोन म्हणजे दस्तऐवजातील URI नावे वाचणे आणि घटकाच्या नेमस्पेसचा संदर्भ देताना त्यांचा वापर करणे. घटकांमध्ये प्रवेश करण्याचा हा खरोखर सर्वोत्तम मार्ग आहे कारण तुम्हाला URI मध्ये हार्डकोड करण्याची गरज नाही.
$namespaces = $languages -> getNamespaces (सत्य) ;
$dc = $languages -> lang [ 1 ] -> मुले ($namespaces [ "dc" ] );
echo $dc -> निर्माता ;
पद्धत GetNamespaces()उपसर्ग नावांचा अॅरे आणि त्यांच्याशी संबंधित URI मिळवते. हे एक अतिरिक्त पॅरामीटर घेते जे डीफॉल्ट होते खोटे. आपण ते स्थापित केल्यास खरे, नंतर ही पद्धत पालक आणि मूल नोड्समध्ये वापरलेली नावे परत करेल. अन्यथा, ते फक्त मूळ नोडमध्ये वापरलेली नेमस्पेस शोधते.
आता आपण यासारख्या भाषांच्या सूचीद्वारे पुनरावृत्ती करू शकता:
$languages = simplexml_load_file ("languages.xml" );
$ns = $languages -> getNamespaces (सत्य) ;
foreach ($languages -> lang $lang म्हणून) (
$dc = $lang -> मुले ($ns [ "dc" ] );
printf (
"
%s %d मध्ये दिसू लागले आणि %s ने तयार केले.
" ,$lang["नाव"],
$lang -> दिसू लागले,
$dc -> निर्माता
) ;
}
केस स्टडी - YouTube व्हिडिओ चॅनेल पार्सिंग
YouTube चॅनेलवरून RSS फीड प्राप्त करणारे आणि त्यावरील सर्व व्हिडिओंच्या लिंक्स दाखवणारे उदाहरण पाहू. हे करण्यासाठी, कृपया खालील पत्त्यावर संपर्क साधा:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
URL XML स्वरूपात दिलेल्या चॅनेलवरील नवीनतम व्हिडिओंची सूची देते. आम्ही XML पार्स करू आणि प्रत्येक व्हिडिओसाठी खालील माहिती मिळवू:
- व्हिडिओची लिंक
- लघुचित्र
- नाव
आम्ही XML शोधून आणि लोड करून प्रारंभ करू:
$channel = "चॅनेलनाव" ;
$url = "http://gdata.youtube.com/feeds/api/users/". $चॅनेल. "/अपलोड" ;
$xml = file_get_contents ($url );
$feed = simplexml_load_string ($xml );
$ns = $feed -> getNameSpaces (सत्य);
आपण XML फीड पाहिल्यास, आपण पाहू शकता की तेथे अनेक घटक आहेत. अस्तित्व, ज्यापैकी प्रत्येक चॅनेलवरील विशिष्ट व्हिडिओबद्दल तपशीलवार माहिती संग्रहित करते. परंतु आम्ही फक्त प्रतिमा लघुप्रतिमा, व्हिडिओ पत्ता आणि शीर्षक वापरतो. हे तिन्ही घटक मूलद्रव्याची मुले आहेत गट, जे यामधून एक मूल आहे प्रवेश:
…
…
…
>
…
आम्ही फक्त सर्व घटकांमधून जाऊ प्रवेश, आणि त्या प्रत्येकासाठी आवश्यक माहिती काढा. लक्षात ठेवा की खेळाडू, लघुप्रतिमाआणि शीर्षकमीडिया नेमस्पेसमध्ये आहेत. अशा प्रकारे, आपण मागील उदाहरणाप्रमाणे पुढे जाणे आवश्यक आहे. आम्हाला दस्तऐवजातून नावे मिळतात आणि घटकांचा संदर्भ देताना नेमस्पेस वापरतो.
foreach ($feed -> $entry म्हणून एंट्री) (
$group = $entry -> मुले ($ns [ "मीडिया" ] );
$group = $group -> गट ;
$thumbnail_attrs = $group -> थंबनेल [ 1 ] -> विशेषता () ;
$image = $thumbnail_attrs [ "url" ] ;
$player = $group -> player -> विशेषता () ;
$link = $player["url"] ;
$title = $group -> शीर्षक ;
printf ( "
$player , $image , $title );
}
निष्कर्ष
आता तुम्हाला कसे वापरायचे ते माहित आहे SimpleXML XML डेटा पार्स करण्यासाठी, तुम्ही वेगवेगळ्या API सह विविध XML फीड पार्स करून तुमची कौशल्ये सुधारू शकता. परंतु हे लक्षात ठेवणे महत्त्वाचे आहे की SimpleXML संपूर्ण DOM मेमरीमध्ये वाचते, त्यामुळे तुम्ही मोठ्या डेटासेटचे विश्लेषण करत असल्यास, तुमची मेमरी संपू शकते. SimpleXML बद्दल अधिक जाणून घेण्यासाठी दस्तऐवजीकरण वाचा.
आपल्याला काही प्रश्न असल्यास, कृपया आमचा वापर करा
आता आपण XML सह काम करण्याचा अभ्यास करू. XML हे साइट्समधील डेटाची देवाणघेवाण करण्यासाठीचे स्वरूप आहे. हे HTML सारखेच आहे, फक्त XML स्वतःचे टॅग आणि विशेषता अनुमती देते.
पार्सिंगसाठी XML का आवश्यक आहे? काहीवेळा असे घडते की तुम्हाला ज्या साइटचे विश्लेषण करणे आवश्यक आहे त्यात API आहे जे तुम्हाला जास्त प्रयत्न न करता तुम्हाला हवे ते मिळवू देते. म्हणून, ताबडतोब सल्ला - साइटचे विश्लेषण करण्यापूर्वी, त्यात एपीआय आहे का ते तपासा.
API म्हणजे काय? हा फंक्शन्सचा एक संच आहे ज्याद्वारे तुम्ही या साइटवर विनंती पाठवू शकता आणि इच्छित प्रतिसाद मिळवू शकता. हे उत्तर बहुतेकदा XML स्वरूपात येते. चला तर मग त्याचा अभ्यास सुरू करूया.
PHP मध्ये XML सह कार्य करणे
समजा तुमच्याकडे XML आहे. हे स्ट्रिंगमध्ये असू शकते, फाइलमध्ये संग्रहित केले जाऊ शकते किंवा विशिष्ट URL ला विनंती केल्यावर दिले जाऊ शकते.
XML एका स्ट्रिंगमध्ये संग्रहित करू द्या. या प्रकरणात, आपण वापरून या ओळीतून एक ऑब्जेक्ट तयार करणे आवश्यक आहे नवीन SimpleXMLElement:
$str = "
आता आपल्याकडे व्हेरिएबल आहे $xmlविश्लेषित XML सह एक ऑब्जेक्ट संग्रहित आहे. या ऑब्जेक्टच्या गुणधर्मांमध्ये प्रवेश करून, आपण XML टॅगच्या सामग्रीमध्ये प्रवेश करू शकता. नक्की कसे - आम्ही थोडे कमी विश्लेषण करू.
जर XML फाईलमध्ये संग्रहित केले असेल किंवा URL मध्ये प्रवेश करून परत केले असेल (जे बहुतेक वेळा होते), तर तुम्ही फंक्शन वापरावे simplexml_load_fileजे समान वस्तू बनवते $xml:
$xml = simplexml_load_file(फाइल पथ किंवा url);
कामाच्या पद्धती
खालील उदाहरणांमध्ये, आमची XML फाइल किंवा URL मध्ये संग्रहित केली आहे.
खालील XML देऊ द्या:
चला एखाद्या कर्मचाऱ्याचे नाव, वय आणि पगार मिळवूया:
$xml = simplexml_load_file(फाइल पथ किंवा url); echo $xml->नाव; // "कोल्या" प्रतिध्वनी $xml->वय प्रदर्शित करते; //आउटपुट 25 echo $xml->पगार; //आउटपुट 1000
तुम्ही बघू शकता, $xml ऑब्जेक्टमध्ये टॅगशी संबंधित गुणधर्म आहेत.
तुमच्या लक्षात आले असेल की टॅग
$xml = simplexml_load_file(फाइल पथ किंवा url); echo $xml->नाव; // "कोल्या" प्रतिध्वनी $xml->वय प्रदर्शित करते; //आउटपुट 25 echo $xml->पगार; //आउटपुट 1000
रूट टॅगप्रमाणेच XML मध्ये फक्त एक रूट टॅग असू शकतो साध्या HTML मध्ये.
चला आमची XML थोडी सुधारित करूया:
या प्रकरणात, आम्हाला कॉलची साखळी मिळते:
$xml = simplexml_load_file(फाइल पथ किंवा url); echo $xml->worker->नाव; // "कोल्या" प्रतिध्वनी $xml->कामगार->वय प्रदर्शित करते; //आउटपुट 25 echo $xml->कामगार->पगार; //आउटपुट 1000
गुणधर्मांसह कार्य करणे
काही डेटा विशेषतांमध्ये संग्रहित करू द्या:
$xml = simplexml_load_file(फाइल पथ किंवा url); echo $xml->worker["name"]; // "कोल्या" इको $xml->कामगार["वय"] दाखवतो; //आउटपुट 25 echo $xml->कामगार["पगार"]; //आउटपुट 1000 echo $xml->worker; // "क्रमांक 1" छापतो
हायफनसह टॅग
XML मध्ये, हायफनसह टॅग्ज (आणि विशेषता) अनुमत आहेत. या प्रकरणात, अशा टॅग्जमध्ये याप्रमाणे प्रवेश केला जातो:
$xml = simplexml_load_file(फाइल पथ किंवा url); echo $xml->worker->(नाव); // "कोल्या" इको $xml->worker->(आडनाव) दाखवतो; // "इव्हानोव्ह" प्रदर्शित करते
लूप पुनरावृत्ती
आता आमच्याकडे एक नाही तर अनेक कामगार आहेत. या प्रकरणात, आम्ही फोरच लूपसह आमच्या ऑब्जेक्टवर पुनरावृत्ती करू शकतो:
$xml = simplexml_load_file(फाइल पथ किंवा url); foreach ($worker म्हणून $xml) ( प्रतिध्वनी $worker->नाव; // "कोल्या", "वास्या", "पेट्या" )
ऑब्जेक्टपासून सामान्य अॅरेपर्यंत
तुम्हाला एखाद्या ऑब्जेक्टसह काम करण्यास सोयीस्कर वाटत नसल्यास, तुम्ही खालील युक्तीने ते सामान्य PHP अॅरेमध्ये रूपांतरित करू शकता:
$xml = simplexml_load_file(फाइल पथ किंवा url); var_dump(json_decode(json_encode($xml), true));
अधिक माहिती
sitemap.xml वर आधारित पार्सिंग
बर्‍याचदा, साइटवर sitemap.xml फाइल असते. ही फाईल साइटच्या सर्व पृष्ठांचे लिंक्स शोध इंजिनद्वारे अनुक्रमित करण्याच्या सोयीसाठी संग्रहित करते (इंडेक्सिंग हे खरेतर, Yandex आणि Google द्वारे साइटचे पार्सिंग आहे).
सर्वसाधारणपणे, ही फाईल का आवश्यक आहे याची आपण काळजी घेऊ नये, मुख्य गोष्ट अशी आहे की ती अस्तित्वात असल्यास, आपण कोणत्याही अवघड पद्धतींनी साइटच्या पृष्ठांवर चढू शकत नाही, परंतु फक्त ही फाईल वापरा.
या फाईलची उपस्थिती कशी तपासायची: साइट site.ru चे विश्लेषण करूया, नंतर ब्राउझरमध्ये site.ru/sitemap.xml चा संदर्भ घ्या - जर तुम्हाला काही दिसले तर ते तेथे आहे आणि जर तुम्हाला ते दिसत नसेल, मग अरेरे.
साइटमॅप असल्यास, त्यात XML स्वरूपात साइटच्या सर्व पृष्ठांचे दुवे आहेत. मोकळ्या मनाने हे XML घ्या, त्याचे पार्स करा, तुमच्यासाठी सोयीस्कर पद्धतीने आवश्यक असलेल्या पृष्ठांचे वेगळे दुवे करा (उदाहरणार्थ, स्पायडर पद्धतीत वर्णन केलेल्या URL पार्स करून).
परिणामी, तुम्हाला पार्सिंगसाठी लिंक्सची एक सूची मिळते, फक्त त्यांच्याकडे जाणे आणि तुम्हाला आवश्यक असलेल्या सामग्रीचे विश्लेषण करणे बाकी आहे.
wikipedia मध्ये sitemap.xml यंत्राबद्दल अधिक वाचा.
तुम्ही पुढे काय कराल:
खालील लिंकवर समस्या सोडवणे सुरू करा: धड्यासाठी कार्ये.
जेव्हा सर्वकाही ठरवले जाते - नवीन विषयाच्या अभ्यासाकडे जा.
या लेखाचे प्रकाशन केवळ लेखाच्या लेखकाच्या साइटच्या दुव्यासह अनुमत आहे
या लेखात, मी मोठ्या XML फाईलचे विश्लेषण कसे करायचे याचे उदाहरण दाखवेन. जर तुमच्या सर्व्हरला (होस्टिंग) स्क्रिप्ट चालवण्याची वेळ वाढवण्यास मनाई नसेल, तर तुम्ही किमान गीगाबाइट्स वजनाची XML फाईल पार्स करू शकता, मी वैयक्तिकरित्या केवळ 450 मेगाबाइट वजनाच्या ओझोनच्या फाइल्स पार्स केल्या आहेत.
मोठ्या XML फायली पार्स करताना दोन समस्या आहेत:
1. पुरेशी मेमरी नाही.
2. स्क्रिप्ट काम करण्यासाठी पुरेसा वेळ दिला जात नाही.
सर्व्हरद्वारे प्रतिबंधित नसल्यास वेळेसह दुसरी समस्या सोडविली जाऊ शकते.
परंतु मेमरीसह समस्या सोडवणे कठीण आहे, जरी आम्ही आपल्या स्वतःच्या सर्व्हरबद्दल बोलत असलो तरीही 500 मेगाबाइट्सच्या फायली हलविणे फार सोपे नाही आणि होस्टिंग आणि व्हीडीएसवर देखील, आपण फक्त मेमरी वाढवू शकत नाही.
PHP मध्ये अनेक अंगभूत XML प्रक्रिया पर्याय आहेत - SimpleXML, DOM, SAX.
हे सर्व पर्याय अनेक उदाहरणे लेखांमध्ये तपशीलवार आहेत, परंतु सर्व उदाहरणे संपूर्ण XML दस्तऐवजासह कसे कार्य करायचे ते दर्शवतात.
येथे एक उदाहरण आहे, आम्हाला XML फाईलमधून एक ऑब्जेक्ट मिळतो
आता तुम्ही या ऑब्जेक्टवर प्रक्रिया करू शकता, पण...
तुम्ही बघू शकता, संपूर्ण XML फाईल मेमरीमध्ये वाचली जाते, नंतर सर्वकाही ऑब्जेक्टमध्ये पार्स केले जाते.
म्हणजेच, सर्व डेटा मेमरीमध्ये येतो आणि वाटप केलेली मेमरी पुरेशी नसल्यास, स्क्रिप्ट थांबते.
हा पर्याय मोठ्या फायलींवर प्रक्रिया करण्यासाठी योग्य नाही, तुम्हाला फाइल लाइन ओळीने वाचण्याची आणि या डेटावर प्रक्रिया करण्याची आवश्यकता आहे.
त्याच वेळी, डेटावर प्रक्रिया केल्यावर वैधता तपासणी देखील केली जाते, म्हणून तुम्हाला रोलबॅक करण्यास सक्षम असणे आवश्यक आहे, उदाहरणार्थ, गैर-वैध XML फाइलच्या बाबतीत प्रविष्ट केलेला सर्व डेटाबेस हटवा किंवा दोन पास करा. फाइलद्वारे, प्रथम वैधतेसाठी वाचा, नंतर डेटावर प्रक्रिया करण्यासाठी वाचा.
येथे मोठ्या XML फाईलचे पार्सिंग करण्याचे एक सैद्धांतिक उदाहरण आहे.
ही स्क्रिप्ट फाईलमधील एक अक्षर वाचते, हा डेटा ब्लॉकमध्ये गोळा करते आणि XML पार्सरला पाठवते.
हा दृष्टीकोन पूर्णपणे मेमरी समस्येचे निराकरण करतो आणि लोड होत नाही, परंतु कालांतराने समस्या वाढवते. कालांतराने समस्येचे निराकरण करण्याचा प्रयत्न कसा करावा, खाली वाचा.
फंक्शन webi_xml($file)
{
########
### डेटा हाताळणी कार्य
{
$डेटा मुद्रित करा;
}
############################################
{
$name छापा;
print_r($attrs);
}
## क्लोजिंग टॅग फंक्शन
फंक्शन endElement ($parser , $name )
{
$name छापा;
}
############################################
($xml_parser , "डेटा" );
// फाईल उघडा
$fp = fopen($file , "r");
$perviy_vxod = 1 ; $डेटा = "" ;
{
$simvol = fgetc($fp); $डेटा .= $simvol ;
if($simvol != ">" ) ( सुरू ठेवा;)
प्रतिध्वनी "
खंडित;
}
$डेटा = "" ;
}
fclose($fp);
webi_xml("1.xml");
?>
या उदाहरणात, मी सर्वकाही एका webi_xml() फंक्शनमध्ये ठेवले आहे आणि त्याचा कॉल अगदी तळाशी दिसत आहे.
स्क्रिप्टमध्येच तीन मुख्य कार्ये असतात:
1. एक फंक्शन जे startElement() टॅग उघडते
2. एक फंक्शन जे endElement() टॅग बंद करते
3. आणि डेटा प्राप्त करणारे फंक्शन डेटा() .
1.xml फाईलची सामग्री काही रेसिपी आहे असे गृहीत धरू
<
title
>साधी भाकरी
<
ingredient amount
=
"3"
unit
=
"стакан"
>पीठ
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>यीस्ट
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>उबदार पाणी
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>मीठ
<
instructions
>
<
step
>
सर्व साहित्य मिसळा आणि नीट मळून घ्या.
<
step
>
कापडाने झाकून ठेवा आणि उबदार खोलीत एक तास सोडा.
<
step
>
पुन्हा मळून घ्या,
बेकिंग शीटवर ठेवा आणि ओव्हनमध्ये ठेवा.
<
step
>
साइट साइटला भेट द्या
आम्ही जेनेरिक फंक्शन webi_xml("1.xml") कॉल करून सुरुवात करतो;
पुढे या फंक्शनमध्ये, पार्सर सुरू होतो आणि सर्व टॅगची नावे अप्पर केसमध्ये रूपांतरित केली जातात जेणेकरून सर्व टॅगची केस समान असेल.
$xml_parser = xml_parser_create();
xml_parser_set_option ($xml_parser , XML_OPTION_CASE_FOLDING , true );
आता टॅग उघडणे, बंद करणे आणि डेटावर प्रक्रिया करणे यासाठी कोणती फंक्शन्स कार्य करतील ते आम्ही निर्दिष्ट करतो
xml_set_element_handler($xml_parser , "startElement" , "endElement" );
xml_set_character_data_handler($xml_parser , "डेटा" );
पुढे निर्दिष्ट फाइल उघडते, फाइलवर एका वेळी एक वर्ण पुनरावृत्ती करा आणि वर्ण सापडेपर्यंत प्रत्येक वर्ण स्ट्रिंग व्हेरिएबलमध्ये जोडला जातो. >
.
जर फाईलमध्ये हा पहिलाच प्रवेश असेल, तर फाईलच्या सुरूवातीस अनावश्यक असलेली प्रत्येक गोष्ट वाटेत हटविली जाईल, आधी उभी असलेली प्रत्येक गोष्ट. , हा टॅग XML ने सुरू केला पाहिजे.
प्रथमच स्ट्रिंग व्हेरिएबल स्ट्रिंग गोळा करेल
आणि पार्सरला पाठवा
xml_parse ($xml_parser , $data , feof ($fp ));
डेटावर प्रक्रिया केल्यानंतर, स्ट्रिंग व्हेरिएबल रीसेट केले जाते आणि स्ट्रिंगमध्ये डेटाचे संकलन पुन्हा सुरू होते आणि दुसऱ्यांदा स्ट्रिंग तयार होते.
तिसऱ्या मध्ये
कृपया लक्षात घ्या की स्ट्रिंग व्हेरिएबल नेहमी पूर्ण केलेल्या टॅगद्वारे तयार केले जाते >
आणि विघटनकर्त्याला डेटासह खुले आणि बंद टॅग पाठवणे आवश्यक नाही, उदाहरणार्थ
या हँडलरला संपूर्ण अभंग टॅग, किमान एक ओपन टॅग आणि पुढच्या टप्प्यात एक बंद टॅग मिळणे किंवा फाइलच्या 1000 ओळी ताबडतोब मिळणे महत्त्वाचे आहे, काही फरक पडत नाही, मुख्य गोष्ट म्हणजे टॅग तुटत नाही, उदाहरणार्थ
le>साधी भाकरी
त्यामुळे हँडलरला डेटा पाठवणे अशक्य आहे, कारण टॅग तुटलेला आहे.
तुम्ही हँडलरला डेटा पाठवण्याची तुमची स्वतःची पद्धत शोधू शकता, उदाहरणार्थ, 1 मेगाबाइट डेटा गोळा करा आणि वेग वाढवण्यासाठी तो हँडलरला पाठवा, फक्त टॅग नेहमी संपतील याची खात्री करा आणि डेटा खंडित होऊ शकतो.
अशा प्रकारे, भागांमध्ये, आपल्या इच्छेनुसार, आपण हँडलरला एक मोठी फाइल पाठवू शकता.
आता हा डेटा कसा प्रोसेस होतो आणि तो कसा मिळवायचा ते पाहू.
ओपनिंग टॅग वैशिष्ट्यासह प्रारंभ करत आहे startElement ($parser , $name , $attrs )
समजू की प्रक्रिया ओळीपर्यंत पोहोचली आहे
<
ingredient amount
=
"3"
unit
=
"стакан"
>पीठ
नंतर फंक्शनमध्ये $name व्हेरिएबल बरोबर असेल घटकम्हणजेच, ओपन टॅगचे नाव (हे प्रकरण अद्याप टॅग बंद करण्यापर्यंत पोहोचलेले नाही).
तसेच या प्रकरणात, या $attrs टॅगच्या गुणधर्मांची अॅरे उपलब्ध असेल, ज्यामध्ये डेटा असेल रक्कम = "3" आणि युनिट = "काच".
त्यानंतर, ओपन टॅगच्या डेटावर फंक्शनद्वारे प्रक्रिया केली गेली डेटा ($पार्सर, $डेटा)
$डेटा व्हेरिएबलमध्ये ओपनिंग आणि क्लोजिंग टॅगमधील प्रत्येक गोष्ट असेल, आमच्या बाबतीत तो मजकूर मुक आहे.
आणि फंक्शनद्वारे आमच्या स्ट्रिंगची प्रक्रिया पूर्ण होते endElement ($parser , $name )
हे बंद टॅगचे नाव आहे, आमच्या बाबतीत $name समान असेल घटक
आणि त्यानंतर, हे सर्व पुन्हा पूर्ण वर्तुळात गेले.
वरील उदाहरण केवळ XML प्रक्रियेचे तत्त्व प्रदर्शित करते, परंतु वास्तविक अनुप्रयोगासाठी ते अंतिम करणे आवश्यक आहे.
सामान्यतः, डेटाबेसमध्ये डेटा प्रविष्ट करण्यासाठी तुम्हाला मोठ्या XML चे विश्लेषण करावे लागेल आणि योग्य डेटा प्रक्रियेसाठी, तुम्हाला माहिती असणे आवश्यक आहे की डेटा कोणत्या ओपन टॅगचा आहे, टॅग नेस्टिंगची कोणती पातळी आहे आणि वरील पदानुक्रमात कोणते टॅग उघडे आहेत. या माहितीसह, आपण कोणत्याही समस्यांशिवाय फाइलवर योग्यरित्या प्रक्रिया करू शकता.
हे करण्यासाठी, तुम्हाला अनेक ग्लोबल व्हेरिएबल्स सादर करणे आवश्यक आहे जे ओपन टॅग, नेस्टिंग आणि डेटाबद्दल माहिती गोळा करतील.
येथे एक उदाहरण वापरले जाऊ शकते
फंक्शन webi_xml($file)
{
जागतिक $webi_depth ; // घरट्याच्या खोलीचा मागोवा ठेवण्यासाठी काउंटर
$webi_depth = 0 ;
जागतिक $webi_tag_open ; // मध्ये सध्या उघडलेल्या टॅगचा अॅरे असेल
$webi_tag_open = अॅरे();
जागतिक $webi_data_temp ; // या अॅरेमध्ये एका टॅगचा डेटा असेल
####################################################
### डेटा हाताळणी कार्य
फंक्शन डेटा ($पार्सर, $डेटा)
{
जागतिक $webi_depth ;
जागतिक $webi_tag_open ;
जागतिक $webi_data_temp ;
// नेस्टिंग आणि सध्या उघडलेल्या टॅगसह अॅरेमध्ये डेटा जोडा
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################
####################################################
### ओपनिंग टॅग फंक्शन
फंक्शन startElement ($parser , $name , $attrs )
{
जागतिक $webi_depth ;
जागतिक $webi_tag_open ;
जागतिक $webi_data_temp ;
// जर नेस्टिंग पातळी आधीपासून शून्य नसेल, तर एक टॅग आधीच उघडलेला आहे
// आणि त्यातील डेटा आधीच अॅरेमध्ये आहे, तुम्ही त्यावर प्रक्रिया करू शकता
जर ($webi_depth)
{
"
;
छापा
"
;
print_r($webi_tag_open); // खुल्या टॅगचे अॅरे
छापा
" ;
// डेटावर प्रक्रिया केल्यानंतर, त्यांना फ्री मेमरीमध्ये हटवा
अनसेट ($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}
// आता पुढील टॅग उघडणे सुरू झाले आहे आणि पुढील प्रक्रिया पुढील चरणात होईल
$webi_depth++; // घरटे वाढवणे
$webi_tag_open [ $webi_depth ]= $name ; // माहिती अॅरेमध्ये ओपन टॅग जोडा
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // आता टॅग विशेषता जोडा
}
###############################################
#################################################
## क्लोजिंग टॅग फंक्शन
फंक्शन endElement ($parser , $name ) (
जागतिक $webi_depth ;
जागतिक $webi_tag_open ;
जागतिक $webi_data_temp ;
// डेटा प्रोसेसिंग येथे सुरू होते, उदाहरणार्थ, डेटाबेसमध्ये जोडणे, फाइलमध्ये सेव्ह करणे इ.
// $webi_tag_open मध्ये नेस्टिंग लेव्हलनुसार ओपन टॅगची साखळी असते
// उदाहरणार्थ $webi_tag_open[$webi_depth] मध्ये खुल्या टॅगचे नाव आहे ज्यांच्या माहितीवर सध्या प्रक्रिया केली जात आहे
// $webi_depth टॅग नेस्टिंग पातळी
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] टॅग विशेषतांचा अॅरे
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] टॅग डेटा
"डेटा" मुद्रित करा. $webi_tag_open [ $webi_depth ]. "--" .($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "डेटा" ]). "
"
;
print_r ($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "attrs" ]);
छापा
"
;
print_r($webi_tag_open);
छापा
" ;
अनसेट ($GLOBALS [ "webi_data_temp" ]); // डेटावर प्रक्रिया केल्यानंतर, संपूर्ण डेटासह अॅरे हटवा, कारण टॅग बंद आहे
अनसेट($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // या उघडलेल्या टॅगबद्दल माहिती काढून टाका... तो बंद झाल्यापासून
$webi_depth --; // घरटे कमी करा
}
############################################
$xml_parser = xml_parser_create();
xml_parser_set_option ($xml_parser , XML_OPTION_CASE_FOLDING , true );
// टॅग उघडताना आणि बंद करताना कोणती फंक्शन्स काम करतील ते निर्दिष्ट करा
xml_set_element_handler($xml_parser , "startElement" , "endElement" );
// डेटासह कार्य करण्यासाठी फंक्शन निर्दिष्ट करा
xml_set_character_data_handler($xml_parser , "डेटा" );
// फाईल उघडा
$fp = fopen($file , "r");
$perviy_vxod = 1 ; // फाईलमध्ये प्रथम इनपुट तपासण्यासाठी ध्वजांकित करा
$डेटा = "" ; // येथे आम्ही फाइलमधील डेटाचे काही भाग गोळा करतो आणि xml पार्सरला पाठवतो
फाइलच्या शेवटपर्यंत // लूप सापडला
तर (! feof ($fp ) आणि $fp )
{
$simvol = fgetc($fp); // फाइलमधून एक वर्ण वाचा
$डेटा .= $simvol ; // पाठवल्या जाणार्‍या डेटामध्ये हे वर्ण जोडा
// जर कॅरेक्टर शेवटचा टॅग नसेल, तर लूपच्या सुरुवातीला परत या आणि डेटामध्ये आणखी एक वर्ण जोडा आणि शेवटचा टॅग सापडेपर्यंत असेच चालू ठेवा.
if($simvol != ">" ) ( सुरू ठेवा;)
// क्लोजिंग टॅग आढळल्यास, आता हा गोळा केलेला डेटा प्रक्रियेसाठी पाठवा
// फाईलमधील ही पहिली एंट्री आहे का ते तपासा, नंतर टॅगच्या आधी सर्वकाही हटवा// कारण काहीवेळा XML सुरू होण्यापूर्वी कचरा असू शकतो (अनाडी संपादक, किंवा फाइल दुसर्‍या सर्व्हरवरून स्क्रिप्टद्वारे प्राप्त झाली होती)
if($perviy_vxod ) ( $data = strstr ($data , "
// आता आपण xml पार्सरमध्ये डेटा टाकतो
जर (! xml_parse ($xml_parser , $data , feof ($fp ))) (
// येथे तुम्ही प्रक्रिया करू शकता आणि वैधतेसाठी त्रुटी मिळवू शकता...
// त्रुटी आढळल्याबरोबर, पार्सिंग थांबते
प्रतिध्वनी "
XML त्रुटी: " .xml_error_string (xml_get_error_code ($xml_parser ));
प्रतिध्वनी "ओळीवर" xml_get_current_line_number($xml_parser);
खंडित;
}
// पार्सिंग केल्यानंतर, आम्ही लूपच्या पुढील चरणासाठी गोळा केलेला डेटा फेकून देतो.
$डेटा = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// ग्लोबल व्हेरिएबल्स हटवा
अनसेट ($GLOBALS [ "webi_depth" ]);
अनसेट ($GLOBALS [ "webi_tag_open" ]);
अनसेट ($GLOBALS [ "webi_data_temp" ]);
webi_xml("1.xml");
?>
संपूर्ण उदाहरण टिप्पण्यांसह होते, आता चाचणी आणि प्रयोग.
कृपया लक्षात घ्या की डेटा मॅनिपुलेशन फंक्शनमध्ये, डेटा फक्त अॅरेमध्ये घातला जात नाही, परंतु "वापरून जोडला जातो. .="
कारण डेटा संपूर्ण स्वरूपात येऊ शकत नाही आणि जर तुम्ही फक्त असाइनमेंट केले तर वेळोवेळी तुम्हाला भागांमध्ये डेटा प्राप्त होईल.
बरं, हे सर्व आहे, आता कोणत्याही आकाराच्या फाईलवर प्रक्रिया करताना पुरेशी मेमरी असेल, परंतु स्क्रिप्टचा चालण्याची वेळ अनेक मार्गांनी वाढविली जाऊ शकते.
स्क्रिप्टच्या सुरुवातीला फंक्शन घाला
set_time_limit(6000);
किंवा
ini_set("max_execution_time" , "6000" );
किंवा .htaccess फाइलमध्ये मजकूर जोडा
php_value max_execution_time 6000
ही उदाहरणे स्क्रिप्ट चालवण्याची वेळ 6000 सेकंदांपर्यंत वाढवतील.
तुम्ही फक्त ऑफ सेफ मोडमध्ये अशा प्रकारे वेळ वाढवू शकता.
जर तुम्हाला php.ini संपादित करण्यासाठी प्रवेश असेल तर तुम्ही वेळ वाढवू शकता
max_execution_time = 6000
उदाहरणार्थ, मास्टरहोस्ट होस्टिंगवर, या लेखनाच्या वेळी, अक्षम सुरक्षित मोड असूनही, स्क्रिप्ट वेळ वाढविण्यास मनाई आहे, परंतु आपण प्रो असल्यास, आपण मास्टरहोस्टवर आपला php तयार करू शकता, परंतु हे या लेखात नाही. .
या मार्गदर्शकातील काही उदाहरणांमध्ये XML स्ट्रिंग समाविष्ट आहे. प्रत्येक उदाहरणात त्याची पुनरावृत्ती करण्याऐवजी, ही ओळ फाईलमध्ये ठेवा आणि प्रत्येक उदाहरणात समाविष्ट करा. ही ओळ खालील उदाहरणात दर्शविली आहे. याव्यतिरिक्त, आपण एक XML दस्तऐवज तयार करू शकता आणि फंक्शनसह वाचू शकता simplexml_load_file().
XML स्ट्रिंगसह उदाहरण #1 Example.php फाइल
$xmlstr =<<
ती स्क्रिप्टिंग भाषा आहे का? हे सर्व या माहितीपटातून समोर आले आहे
भयपट चित्रपटासारखे.
XML
?>
SimpleXML वापरण्यास अतिशय सोपे आहे! अंतर्निहित XML दस्तऐवजातून काही स्ट्रिंग किंवा नंबर मिळवण्याचा प्रयत्न करा.
उदाहरण #2 दस्तऐवजाचा भाग मिळवणे
"example.php" समाविष्ट करा;
echo $movies -> चित्रपट [ 0 ]-> कथानक ;
?>
त्यामुळे ती एक भाषा आहे. ती अजूनही प्रोग्रामिंग भाषा आहे. किंवा ती एक स्क्रिप्टिंग भाषा आहे? एखाद्या हॉरर चित्रपटाप्रमाणे दिसणाऱ्या या डॉक्युमेंटरीमध्ये सर्व काही समोर आले आहे.
PHP मध्ये, दिलेल्या घटकाचे नाव कर्ली ब्रेसेस आणि ऍपोस्ट्रॉफमध्ये संलग्न करून तुम्ही XML दस्तऐवजातील घटक ऍक्सेस करू शकता ज्यात त्याच्या नावात अवैध वर्ण (जसे की हायफन) आहेत.
उदाहरण #3 स्ट्रिंग मिळवणे
"example.php" समाविष्ट करा;
echo $movies -> चित्रपट ->("ग्रेट-लाइन")-> लाइन ;
?>
हे उदाहरण चालवण्याचा परिणाम:
PHP माझ्या वेबवरील सर्व समस्या सोडवते
उदाहरण #4 SimpleXML मधील अनन्य घटकांमध्ये प्रवेश करणे
एकाच पालक घटकामध्ये मूल घटकांची अनेक उदाहरणे असल्यास, मानक पुनरावृत्ती पद्धती लागू करणे आवश्यक आहे.
"example.php" समाविष्ट करा;
$movies = नवीन SimpleXMLElement($xmlstr);
/* प्रत्येक नोडसाठी
foreach ($movies -> movie -> characters -> character as $character) (
echo $character -> नाव , " नाटके " , $ character -> अभिनेता , PHP_EOL ;
}
?>
हे उदाहरण चालवण्याचा परिणाम:
कु. कोडरने ओन्लिव्हिया अॅक्टोरा श्री. कोडर El ActÓr ची भूमिका करतो
टिप्पणी:
गुणधर्म ( $movies->चित्रपटमागील उदाहरणामध्ये) अॅरे नाहीत. हे अॅरेच्या स्वरूपात पुनरावृत्ती करण्यायोग्य ऑब्जेक्ट आहे.
उदाहरण #5 विशेषता वापरणे
आतापर्यंत, आम्ही फक्त घटकांची नावे आणि मूल्ये मिळवली आहेत. SimpleXML घटक विशेषतांमध्ये देखील प्रवेश करू शकते. घटक गुणधर्म अॅरे घटकांप्रमाणेच प्रवेश केला जाऊ शकतो ( रचना).
"example.php" समाविष्ट करा;
$movies = नवीन SimpleXMLElement($xmlstr);
/* नोडमध्ये प्रवेश करा
* आम्ही रेटिंग स्केल देखील प्रदर्शित करू. */
foreach ($movies -> चित्रपट [ 0 ]-> $रेटिंग म्हणून रेटिंग) (
स्विच((स्ट्रिंग) $रेटिंग [ "प्रकार" ]) ( // निर्देशांकानुसार घटक गुणधर्म मिळवा
केस "अंगठे" :
इको $रेटिंग , " थम्ब्स अप " ;
खंडित;
केस "तारे" :
इको $रेटिंग , "तारे" ;
खंडित;
}
}
?>
हे उदाहरण चालवण्याचा परिणाम:
7 थंब्स अप 5 तारे
उदाहरण #6 मजकूरासह घटक आणि गुणधर्मांची तुलना करणे
घटक किंवा विशेषता स्ट्रिंगशी तुलना करण्यासाठी किंवा मजकूर म्हणून फंक्शनमध्ये पास करण्यासाठी, तुम्ही ते वापरून स्ट्रिंगवर कास्ट केले पाहिजे (तार). अन्यथा, PHP घटकाला ऑब्जेक्ट मानेल.
"example.php" समाविष्ट करा;
$movies = नवीन SimpleXMLElement($xmlstr);
जर ((स्ट्रिंग) $movies -> चित्रपट -> शीर्षक == "PHP: पार्सर दिसतो") {
छापणे "माझा आवडता चित्रपट.";
}
echo htmlentities ((स्ट्रिंग) $movies -> movie -> title );
?>
हे उदाहरण चालवण्याचा परिणाम:
माझा आवडता चित्रपट. PHP: द पार्सर दिसतो
उदाहरण #7 दोन घटकांची तुलना करणे
दोन SimpleXMLE घटक जरी PHP 5.2.0 प्रमाणे समान ऑब्जेक्टकडे निर्देशित केले तरीही ते भिन्न मानले जातात.
"example.php" समाविष्ट करा;
$movies1 = नवीन SimpleXMLElement($xmlstr);
$movies2 = नवीन SimpleXMLElement($xmlstr);
var_dump ($movies1 == $movies2); PHP 5.2.0 पासून // असत्य
?>
हे उदाहरण चालवण्याचा परिणाम:
Beispiel #8 XPath वापरणे
SimpleXML मध्ये मूळ XPath समर्थन समाविष्ट आहे. सर्व आयटम शोधा
"example.php" समाविष्ट करा;
$movies = नवीन SimpleXMLElement($xmlstr);
foreach ($movies -> xpath("//character" ) $character म्हणून ) (
echo $character -> नाव , " नाटके " , $ character -> अभिनेता , PHP_EOL ;
}
?>
"// " वाइल्डकार्ड म्हणून काम करते. परिपूर्ण मार्ग निर्दिष्ट करण्यासाठी, स्लॅशपैकी एक वगळा.
हे उदाहरण चालवण्याचा परिणाम:
कु. कोडरने ओन्लिव्हिया अॅक्टोरा श्री. El ActÓr चे कोडर नाटके
उदाहरण #9 मूल्ये सेट करणे
SimpleXML मधील डेटा अपरिवर्तनीय असणे आवश्यक नाही. ऑब्जेक्ट तुम्हाला सर्व घटक हाताळण्याची परवानगी देतो.
"example.php" समाविष्ट करा;
$movies = नवीन SimpleXMLElement($xmlstr);
$movies -> चित्रपट [ 0 ] -> वर्ण -> वर्ण [ 0 ] -> नाव = "मिस कोडर" ;
echo $movies -> asXML();
?>
हे उदाहरण चालवण्याचा परिणाम:
उदाहरण #10 घटक आणि विशेषता जोडणे
PHP 5.1.3 नुसार, SimpleXML मध्ये सहज मूल घटक आणि विशेषता जोडण्याची क्षमता आहे.
"example.php" समाविष्ट करा;
$movies = नवीन SimpleXMLElement($xmlstr);
$character = $movies -> movie [ 0 ]-> characters -> addChild("character");
$character -> addChild("name" , "Mr. Parser");
$character -> addChild("अभिनेता", "जॉन डो");
$rating = $movies -> चित्रपट [ 0 ]-> addChild("रेटिंग" , "PG");
$rating -> addAttribute ("प्रकार" , "mpaa" );
echo $movies -> asXML();
?>
हे उदाहरण चालवण्याचा परिणाम:
Beispiel #11 DOM सह संवाद साधत आहे
PHP XML नोड्स SimpleXML वरून DOM फॉरमॅटमध्ये आणि त्याउलट रूपांतरित करू शकते. हे उदाहरण दाखवते की तुम्ही SimpleXML मध्ये DOM घटक कसा बदलू शकता.
$dom = नवीन DOMDdocument;
$dom -> loadXML( "
जर (! $dom ) (
प्रतिध्वनी "दस्तऐवज पार्स करताना त्रुटी";
बाहेर पडणे
}
$books = simplexml_import_dom($dom);
echo $books -> पुस्तक [ 0 ] -> शीर्षक ;
?>
हे उदाहरण चालवण्याचा परिणाम:
4 वर्षांपूर्वी
सिंपलएक्सएमएल ऑब्जेक्टला json_encode() आणि नंतर json_decode() द्वारे चालवून अॅरेमध्ये रूपांतरित करण्याची एक सामान्य "युक्ती" आहे. ही वाईट कल्पना का आहे हे मी स्पष्ट करू इच्छितो.
सर्वात सोप्या पद्धतीने, कारण SimpleXML चा संपूर्ण मुद्दा वापरण्यास सोपा आणि साध्या अॅरेपेक्षा अधिक शक्तिशाली आहे. उदाहरणार्थ, तुम्ही लिहू शकताbar -> baz [ "bing" ] ?> आणि याचा अर्थ समान आहेbar [ 0 ]-> baz [ 0 ][ "bing" ] ?>, XML मध्ये किती बार किंवा baz घटक आहेत याची पर्वा न करता; आणि जर तुम्ही लिहीले तरbar [ 0 ]-> baz [ 0 ] ?> तुम्हाला त्या नोडची सर्व स्ट्रिंग सामग्री मिळते - CDATA विभागांसह - त्यात मूल घटक किंवा विशेषता देखील आहेत की नाही याची पर्वा न करता. तुमच्याकडे नेमस्पेस माहिती, XML मध्ये साधी संपादने करण्याची क्षमता आणि अधिक शक्तिशाली हाताळणीसाठी DOM ऑब्जेक्टमध्ये "आयात" करण्याची क्षमता देखील आहे. या पृष्ठावरील उदाहरणे समजून घेण्याऐवजी ऑब्जेक्टला अॅरेमध्ये बदलून हे सर्व गमावले आहे.
याव्यतिरिक्त, ते या उद्देशासाठी डिझाइन केलेले नसल्यामुळे, JSON आणि मागे रूपांतरण काही परिस्थितींमध्ये प्रत्यक्षात माहिती गमावेल. उदाहरणार्थ, नेमस्पेसमधील कोणतेही घटक किंवा विशेषता टाकून दिली जातील आणि एखाद्या घटकामध्ये मुले किंवा विशेषता असल्यास कोणतीही मजकूर सामग्री टाकून दिली जाईल. काहीवेळा, याने काही फरक पडत नाही, परंतु जर तुम्हाला सर्वकाही अॅरेमध्ये रूपांतरित करण्याची सवय लागली, तर ते तुम्हाला अखेरीस डंक देईल.
अर्थात, तुम्ही एक हुशार रूपांतरण लिहू शकता, ज्यामध्ये या मर्यादा नाहीत, परंतु त्या वेळी, तुम्हाला SimpleXML मधून अजिबात मूल्य मिळत नाही, आणि फक्त खालच्या स्तरावरील XML पार्सर फंक्शन्स, किंवा XMLReader क्लास, तुमची रचना तयार करण्यासाठी. तुम्हाला अजूनही SimpleXML ची अतिरिक्त सुविधा मिळणार नाही, परंतु ते तुमचे नुकसान आहे.
2 वर्षांपूर्वी
तुमच्या xml स्ट्रिंगमध्ये "0" आणि "1" सह एन्कोड केलेले बूलियन्स असल्यास, तुम्ही थेट बूलवर घटक कास्ट करता तेव्हा तुम्हाला समस्या येतील:
$xmlstr =<<
XML
$values = नवीन SimpleXMLElement($xmlstr);
$truevalue = (bool)$values->truevalue; // खरे
$falsevalue = (bool)$values->falsevalue; // देखील खरे!!!
त्याऐवजी तुम्हाला प्रथम स्ट्रिंग किंवा इंटवर कास्ट करणे आवश्यक आहे:
$truevalue = (bool)(int)$values->truevalue; // खरे
$falsevalue = (bool)(int)$values->falsevalue; // खोटे
9 वर्षांपूर्वी
तुम्हाला तुमच्या प्रतिसादात वैध xml आउटपुट करण्याची आवश्यकता असल्यास, asXML() चा परिणाम प्रतिध्वनी करण्याव्यतिरिक्त तुमचा शीर्षलेख सामग्री प्रकार xml वर सेट करण्यास विसरू नका:
$xml = simplexml_load_file("...");
...
... xml सामग्री
...
तुमच्या प्रतिसादात //आउटपुट xml:
शीर्षलेख ("सामग्री-प्रकार: मजकूर/xml");
echo $xml -> asXML();
?>
9 वर्षांपूर्वी
README फाइलमधून:
SimpleXML म्हणजे XML डेटा ऍक्सेस करण्याचा एक सोपा मार्ग आहे.
SimpleXML ऑब्जेक्ट चार मूलभूत नियमांचे पालन करतात:
1) गुणधर्म घटक पुनरावृत्ती दर्शवितात
२) संख्यात्मक निर्देशांक घटक दर्शवतात
३) संख्यात्मक नसलेले निर्देशांक गुणधर्म दर्शवतात
4) स्ट्रिंग रूपांतरण TEXT डेटामध्ये प्रवेश करण्यास अनुमती देते
गुणधर्म पुनरावृत्ती करताना विस्तार नेहमी पुनरावृत्ती होते
त्या घटकाच्या नावासह सर्व नोड्स. अशा प्रकारे मुले() पद्धत असणे आवश्यक आहे
सबनोड्सवर पुनरावृत्ती करण्यासाठी म्हणतात. परंतु पुढील गोष्टी देखील करा:
foreach ($obj->node_name $elem म्हणून) (
// $elem सह काहीतरी करा
}
नेहमी "node_name" घटकांच्या पुनरावृत्तीमध्ये परिणाम होतो. त्यामुळे पुढे नाही
त्या प्रकारच्या नोड्सची संख्या ओळखण्यासाठी तपासणी आवश्यक आहे.
मालमत्तेद्वारे घटक TEXT डेटामध्ये प्रवेश केला जात असताना
नंतर परिणामामध्ये सबलेमेंट्सचा TEXT डेटा समाविष्ट नाही.
माहित असलेल्या गोष्टी
============
इंजिनच्या समस्येमुळे सध्या प्रवेश करणे शक्य नाही
अनुक्रमणिका 0 द्वारे उपघटक: $ऑब्जेक्ट->प्रॉपर्टी.
8 वर्षांपूर्वी
"admin" नावाचा नोड आहे की नाही हे तपासण्यासाठी: is_object($xml->module->admin) सारखी सामग्री वापरणे, अपेक्षेप्रमाणे कार्य करत नाही असे दिसते, कारण simplexml नेहमी एखादी वस्तू परत करते- अशावेळी रिकामी - एक विशिष्ट नोड अस्तित्वात नसला तरीही.
माझ्यासाठी चांगले जुने रिक्त() फंक्शन अशा प्रकरणांमध्ये चांगले कार्य करते असे दिसते.
8 वर्षांपूर्वी
xpath क्वेरी आणि डीफॉल्ट नेमस्पेसेसवर एक द्रुत टिप. असे दिसते की SimpleXML च्या मागे असलेल्या XML-system मध्ये XML-system .NET वापरते प्रमाणे कार्य करते: जेव्हा एखाद्याला डीफॉल्ट नेमस्पेसमध्ये काहीतरी संबोधित करायचे असते, तेव्हा एखाद्याला registerXPathNamespace वापरून नेमस्पेस घोषित करावे लागेल आणि नंतर त्याचा उपसर्ग वापरावा लागेल. डीफॉल्ट नेमस्पेस जिवंत घटकामध्ये अन्यथा पत्ता द्या.
$string =<<
मला माहित आहे "हे उत्तर आहे -- पण प्रश्न काय आहे?
XML
$xml = simplexml_load_string ($string);
$xml -> registerXPathNamespace("def" , "http://www.w3.org/2005/Atom");
$nodes = $xml -> xpath("//def:document/def:title");
?>
9 वर्षांपूर्वी
SimpleXMLElement पुनरावृत्ती करण्यायोग्य असल्याचा दावा करत असताना, ते मानक इटरेटर इंटरफेस फंक्शन्स जसे की::next आणि::reset योग्यरित्या अंमलात आणत नाही. त्यामुळे foreach() काम करत असताना, next(), current(), किंवा each() सारखी फंक्शन्स तुमच्या अपेक्षेप्रमाणे काम करत नाहीत असे वाटत नाही -- पॉइंटर कधीही हलताना दिसत नाही किंवा रीसेट होत राहतो.
6 वर्षांपूर्वी
XML दस्तऐवजाचे एन्कोडिंग UTF-8 व्यतिरिक्त असल्यास, एन्कोडिंग घोषणा आवृत्ती="..." नंतर आणि स्टँडअलोन="..." च्या आधी येणे आवश्यक आहे. ही XML मानकाची आवश्यकता आहे.
एन्कोडिंग XML-दस्तऐवज UTF-8 पेक्षा वेगळे असल्यास. एन्कोडिंग घोषणा आवृत्ती = "..." नंतर आणि स्टँडअलोन = "..." च्या आधी लगेच फॉलो करावी. ही आवश्यकता मानक XML आहे.
ठीक आहे
गंभीर त्रुटी: न सापडलेला अपवाद "अपवाद" संदेशासह "स्ट्रिंग XML म्हणून पार्स केले जाऊ शकत नाही"...
एक्स्टेंसिबल मार्कअप लँग्वेज XML हा मशीन-वाचण्यायोग्य फॉर्ममध्ये दस्तऐवज एन्कोडिंगसाठी नियमांचा संच आहे. इंटरनेटवरील डेटाची देवाणघेवाण करण्यासाठी XML हे एक लोकप्रिय स्वरूप आहे. ज्या साइट वारंवार त्यांची सामग्री अपडेट करतात, जसे की बातम्या साइट्स किंवा ब्लॉग, अनेकदा एक XML फीड प्रदान करतात जेणेकरून बाह्य कार्यक्रमांना सामग्रीतील बदलांची जाणीव होते. नेटवर्क कनेक्शन असलेल्या ऍप्लिकेशन्ससाठी XML डेटा पाठवणे आणि पार्स करणे हे एक सामान्य कार्य आहे. हा धडा XML दस्तऐवज कसे पार्स करायचे आणि त्यांचा डेटा कसा वापरायचा हे स्पष्ट करतो.
पार्सर निवडत आहे
चॅनल विश्लेषण
फीड पार्स करण्याची पहिली पायरी म्हणजे तुम्हाला कोणत्या डेटा फील्डमध्ये स्वारस्य आहे हे ठरवणे. पार्सर दिलेली फील्ड काढतो आणि इतर सर्व गोष्टींकडे दुर्लक्ष करतो.
येथे चॅनेल स्निपेट आहे जे नमुना अनुप्रयोगामध्ये विश्लेषित केले जाईल. StackOverflow.com वरील प्रत्येक पोस्ट फीडमध्ये एंट्री टॅग म्हणून दिसते, ज्यामध्ये अनेक नेस्टेड टॅग असतात:
माझ्याकडे एक अनुप्रयोग आहे ज्यासाठी डेटा फाइल आवश्यक आहे...
नमुना अनुप्रयोग एंट्री टॅग आणि त्याचे सबटॅग शीर्षक, दुवा आणि सारांश मधून डेटा पुनर्प्राप्त करतो.
पार्सरचे उदाहरण तयार करणे
पुढील पायरी म्हणजे पार्सर इन्स्टंट करणे आणि पार्सिंग प्रक्रिया सुरू करणे. या स्निपेटमध्ये, नेमस्पेसेस न हाताळण्यासाठी आणि प्रदान केलेले इनपुटस्ट्रीम इनपुट म्हणून वापरण्यासाठी पार्सरला आरंभ केला जातो. नेक्स्टटॅग() ला कॉल करून आणि रीडफीड() पद्धतीला कॉल करून पार्सिंग प्रक्रिया सुरू केली जाते, जी ऍप्लिकेशनला स्वारस्य असलेल्या डेटाची पुनर्प्राप्ती आणि प्रक्रिया करते:
सार्वजनिक वर्ग StackOverflowXmlParser ( // आम्ही नेमस्पेस खाजगी स्थिर अंतिम स्ट्रिंग ns = null वापरत नाही; सार्वजनिक यादी पार्स(इनपुटस्ट्रीम इन) थ्रो XmlPullParserException, IOException ( प्रयत्न करा ( XmlPullParser पार्सर = Xml.newPullParser पार्सर = Xml.newPullParser पार्सर); , असत्य); parser.setInput(in, null); parser.nextTag(); रिटर्न readFeed(पार्सर); ) शेवटी ( in.close(); ) ) ... )
चॅनेल वजा करा
readFeed() पद्धत फीडवर प्रक्रिया करण्याचे प्रत्यक्ष काम करते. "एंट्री" टॅगसह चिन्हांकित केलेले घटक पुनरावृत्ती चॅनेल प्रक्रियेसाठी प्रारंभ बिंदू आहेत. पुढील टॅग एंट्री टॅग नसल्यास, तो वगळला जातो. संपूर्ण "फीड" वर वारंवार प्रक्रिया केल्यानंतर, readFeed() फीडमधून पुनर्प्राप्त केलेल्या नोंदी (नेस्टेड डेटा आयटमसह) असलेली यादी परत करते. ही यादी नंतर पार्सरद्वारे परत केली जाते.
खाजगी सूची readFeed(XmlPullParser पार्सर) ने XmlPullParserException, IOException ( यादी नोंदी = नवीन ArrayList (); parser.require(XmlPullParser.START_TAG, ns, "feed"); तर (parser.next() !=Xml () lPullParser () (parser.getEventType() != XmlPullParser.START_TAG) ( सुरू ठेवा; ) स्ट्रिंग नाव = parser.getName(); // एंट्री टॅग शोधून सुरू होते if (name.equals("entry")) ( entries.add( readEntry(पार्सर)); ) बाकी ( वगळा (पार्सर); ) ) रिटर्न एंट्री; )
XML पार्स करत आहे
XML फीडचे विश्लेषण करण्यासाठी पायऱ्या खालीलप्रमाणे आहेत:
हे स्निपेट पार्सर एंट्री, शीर्षक, लिंक आणि सारांश कसे पार्स करते हे दाखवते.
सार्वजनिक स्थिर वर्ग एंट्री ( सार्वजनिक अंतिम स्ट्रिंग शीर्षक; सार्वजनिक अंतिम स्ट्रिंग लिंक; सार्वजनिक अंतिम स्ट्रिंग सारांश; खाजगी प्रविष्टी (स्ट्रिंग शीर्षक, स्ट्रिंग सारांश, स्ट्रिंग लिंक) ( this.title = शीर्षक; this.summary = सारांश; this.link = दुवा ; ) ) // एंट्रीमधील सामग्रीचे विश्लेषण करते. शीर्षक, सारांश किंवा लिंक टॅग आढळल्यास, त्यांना प्रक्रिया करण्यासाठी त्यांच्या संबंधित "वाचन" पद्धतींकडे पाठवा. अन्यथा, टॅग वगळा. खाजगी एंट्री readEntry(XmlPullParser पार्सर) फेकते XmlPullParserException, IOException ( parser.require(XmlPullParser.START_TAG, ns, "entry"); स्ट्रिंग शीर्षक = नल; स्ट्रिंग सारांश = शून्य; स्ट्रिंग लिंक = शून्य; (tparne) असताना = XmlPullParser.END_TAG) ( if (parser.getEventType() != XmlPullParser.START_TAG) ( सुरू ठेवा; ) स्ट्रिंग नाव = parser.getName(); if (name.equals("title")) ( title = readTitle(parser) ; ) अन्यथा जर (name.equals("summary")) ( summary = readSummary(parser); ) else if (name.equals("link")) ( link = readLink(parser); ) else ( वगळा(पार्सर) ; ) ) नवीन एंट्री परत करा(शीर्षक, सारांश, लिंक); ) // फीडमधील शीर्षक टॅगवर प्रक्रिया करते. खाजगी स्ट्रिंग readTitle(XmlPullParser पार्सर) थ्रो IOException, XmlPullParserException ( parser.require(XmlPullParser.START_TAG, ns, "title"); स्ट्रिंग शीर्षक = readText(parser); parser.require(XmlPullParser), END_TAGSer; रिटर्न शीर्षक; ) // फीडमधील लिंक टॅगवर प्रक्रिया करते. खाजगी स्ट्रिंग रीडलिंक(XmlPullParser पार्सर) IOException, XmlPullParserException ( String link = ""; parser.require(XmlPullParser.START_TAG, ns, "लिंक"); स्ट्रिंग टॅग = parser.getName(); स्ट्रिंग rel-parser. , "rel"); if (tag.equals("link")) ( if (relType.equals("alternate"))( link = parser.getAttributeValue(null, "href"); parser.nextTag(); ) ) parser.require(XmlPullParser.END_TAG, ns, "लिंक"); रिटर्न लिंक; ) // फीडमधील सारांश टॅगवर प्रक्रिया करते. खाजगी स्ट्रिंग readSummary(XmlPullParser पार्सर) थ्रो IOException, XmlPullParserException ( parser.require(XmlPullParser.START_TAG, ns, "summary"); स्ट्रिंग सारांश = readText(parser); parser.require(Xmlarn,"END. रिटर्न सारांश; ) // टॅग शीर्षक आणि सारांशासाठी, त्यांची मजकूर मूल्ये काढते. खाजगी स्ट्रिंग readText(XmlPullParser पार्सर) IOException, XmlPullParserException ( स्ट्रिंग परिणाम = ""; जर (parser.next() == XmlPullParser.TEXT) (परिणाम = parser.getText(); parser.nextTag(; रिटर्न परिणाम (); ) ...)
तुम्हाला आवश्यक नसलेल्या वस्तू वगळा
वर वर्णन केलेल्या XML पार्सिंग चरणांपैकी एकामध्ये, पार्सर आम्हाला स्वारस्य नसलेले टॅग वगळतो. खाली स्किप() पद्धतीसाठी पार्सर कोड आहे:
प्रायव्हेट व्हॉइड स्किप(XmlPullParser पार्सर) XmlPullParserException, IOException ( if (parser.getEventType() != XmlPullParser.START_TAG) (नवीन IllegalStateException फेकणे) ; ) int depth = 1; (thparser) int depth = 1; (thparser) असताना पुढील()) ( केस XmlPullParser.END_TAG: depth--; break; case XmlPullParser.START_TAG: depth++; खंडित; ) )
ते कसे कार्य करते ते येथे आहे:
- वर्तमान इव्हेंट START_TAG नसल्यास पद्धत अपवाद दर्शवते.
- ते START_TAG आणि END_TAG पर्यंतचे सर्व कार्यक्रम वापरते.
- ते मूळ START_TAG नंतर आलेले पहिले टॅग नसून योग्य END_TAG वर थांबते याची खात्री करण्यासाठी, ते नेस्टिंगच्या खोलीचा मागोवा ठेवते.
अशा प्रकारे, वर्तमान घटकामध्ये नेस्टेड घटक असल्यास, जोपर्यंत पार्सरने मूळ START_TAG आणि त्याच्याशी संबंधित END_TAG मधील सर्व घटनांवर प्रक्रिया केली नाही तोपर्यंत खोली 0 होणार नाही. उदाहरणार्थ, पार्सर कसा वगळतो ते विचारात घ्या
- व्हेल लूपमधून पहिल्या पासवर, पार्सरचा पुढील टॅग नंतर येतो
यासाठी हे START_TAG आहे - व्हाईल लूपमधून दुसऱ्या पासवर, पार्सरचा पुढील टॅग END_TAG आहे
- व्हेल लूपमधून तिसऱ्या पासवर, पार्सरचा पुढील टॅग START_TAG आहे
. खोली मूल्य 2 पर्यंत वाढविले आहे. - व्हेल लूपमधून चौथ्या पासवर, पार्सरचा पुढील टॅग END_TAG आहे. खोलीचे मूल्य 1 पर्यंत कमी केले आहे.
- व्हेल लूपमधून पाचव्या आणि अंतिम पासवर, पार्सरचा पुढील टॅग END_TAG आहे. खोलीचे मूल्य 0 पर्यंत कमी होते, हे दर्शविते
घटक यशस्वीरित्या वगळला गेला.
XML डेटावर प्रक्रिया करत आहे
नमुना ऍप्लिकेशन AsyncTask मध्ये XML फीड प्राप्त करतो आणि पार्स करतो. प्रक्रिया मुख्य UI थ्रेडच्या बाहेर केली जाते. प्रक्रिया पूर्ण झाल्यावर, अनुप्रयोग मुख्य क्रियाकलाप (नेटवर्कअॅक्टिव्हिटी) मध्ये वापरकर्ता इंटरफेस अद्यतनित करतो.
खालील स्निपेटमध्ये, loadPage() पद्धत खालील गोष्टी करते:
- XML फीडकडे निर्देश करणार्‍या URL मूल्यासह स्ट्रिंग व्हेरिएबल सुरू करते.
- वापरकर्त्याच्या सेटिंग्ज आणि नेटवर्क कनेक्शनला परवानगी असल्यास नवीन DownloadXmlTask().execute(url) कॉल करते. हे नवीन DownloadXmlTask ऑब्जेक्ट (एक AsyncTask सबक्लास) तयार करते आणि त्याची execute() पद्धत कार्यान्वित करते, जी फीड डाउनलोड आणि पार्स करते आणि वापरकर्ता इंटरफेसमध्ये प्रदर्शित करण्यासाठी स्ट्रिंग परिणाम देते.
- doInBackground() loadXmlFromNetwork() पद्धत कार्यान्वित करते. हे पॅरामीटर म्हणून चॅनल URL पास करते. loadXmlFromNetwork() पद्धत चॅनेल प्राप्त करते आणि त्यावर प्रक्रिया करते. जेव्हा ते प्रक्रिया पूर्ण करते, तेव्हा ते परिणामी स्ट्रिंग परत पाठवते.
- onPostExecute() परत आलेली स्ट्रिंग घेते आणि ती वापरकर्ता इंटरफेसमध्ये प्रदर्शित करते.
खाली loadXmlFromNetwork() पद्धत आहे जी DownloadXmlTask वरून कॉल केली जाते. हे खालील गोष्टी करते:
- StackOverflowXmlParser चे उदाहरण तयार करते. हे त्या फील्डसाठी XML फीडमधून पुनर्प्राप्त केलेली मूल्ये संग्रहित करण्यासाठी सूची एंट्री ऑब्जेक्ट्स आणि शीर्षक , url आणि सारांश साठी व्हेरिएबल्स देखील तयार करते.
- downloadUrl() ला कॉल करते, जे फीड डाउनलोड करते आणि इनपुटस्ट्रीम म्हणून परत करते.
- InputStream पार्स करण्यासाठी StackOverflowXmlParser वापरते. StackOverflowXmlParser फीडमधील डेटासह सूची एंट्री भरतो.
- एंट्री लिस्टवर प्रक्रिया करते आणि HTML मार्कअपसह फीड डेटा एकत्र करते.
- onPostExecute() पद्धतीमध्ये मुख्य क्रियाकलाप, AsyncTask च्या वापरकर्ता इंटरफेसमध्ये प्रदर्शित होणारी HTML स्ट्रिंग परत करते.
" + getResources().getString(R.string.page_title) + "
"); htmlString.append(" " + getResources().getString(R.string.updated) + " " + formatter.format(rightNow.getTime()) + ""); प्रयत्न करा ( stream = downloadUrl(urlString); entries = stackOverflowXmlParser.parse(stream); // अॅप वापरणे पूर्ण झाल्यानंतर // Inputstream बंद आहे याची खात्री करा.) शेवटी ( if (stream != null) ( stream.close(); ) ) // StackOverflowXmlParser एंट्री ऑब्जेक्ट्सची एक सूची ("एंट्री" म्हणतात) परत करतो. // प्रत्येक एंट्री ऑब्जेक्ट XML फीडमध्ये एकच पोस्ट दर्शवते. // हा विभाग प्रत्येक एकत्र करण्यासाठी एंट्री सूचीवर प्रक्रिया करतो HTML मार्कअपसह एंट्री. // प्रत्येक एंट्री UI मध्ये एक लिंक म्हणून प्रदर्शित केली जाते ज्यामध्ये वैकल्पिकरित्या // मजकूर सारांश समाविष्ट असतो. साठी (एंट्री एंट्री: एंट्री) ( htmlString. append("" + entry.title + "
"); // वापरकर्त्याने सारांश मजकूर समाविष्ट करण्यासाठी प्राधान्य सेट केल्यास, // ते प्रदर्शनात जोडते. if (pref) ( htmlString.append(entry.summary); ) ) htmlString.toString(); ) // URL चे स्ट्रिंग प्रतिनिधित्व दिलेले, कनेक्शन सेट करते आणि // एक इनपुट स्ट्रीम मिळते. खाजगी इनपुटस्ट्रीम downloadUrl(String urlString) IOException ( URL url = new URL(urlString); HttpURLConnection conn = (HttpURLConnection) url.openConnection () ; conn.setReadTimeout(10000 /* मिलीसेकंद */); conn.setConnectTimeout(15000 /* मिलीसेकंद */); conn.setRequestMethod("GET"); conn.setDoInput(true); // क्वेरी सुरू करते conn.connect( परत करा conn.getInputStream(); )
