XML ma'lumotlarini tahlil qilish. XML ma'lumotlarini tahlil qilish Tahrirlovchini yaratish
Muallif: Arseniy Kapulkin
Nashr qilingan sana: 2012 yil 21 sentyabr
Tarjimasi: A. Panin
Tarjima sanasi: 2013 yil 10 noyabr
Kirish
XML standartlashtirilgan belgilash tili bo'lib, u ierarxik tuzilgan hujjatlarni inson o'qishi mumkin bo'lgan tarzda kodlash uchun qoidalar to'plamiga ega. matn formati. XML standarti keng tarqaldi va juda ixcham oddiy hujjatlarni (masalan, SOAP so'rovlari) va murakkab ma'lumotlarga bog'liqlik (COLLADA) bilan ko'p gigabaytli hujjatlarni (OpenStreetMap loyihasi tomonidan qo'llaniladi) yaratish uchun ishlatiladi. XML hujjatlarini qayta ishlash uchun foydalanuvchilar odatda maxsus kutubxonaga ehtiyoj sezadilar: u hujjatni matnli hujjatdan ichki tasvirga aylantiruvchi XML hujjat tahlilchisini amalga oshirishi kerak. XML standarti tahlil qilish tezligi, foydalanuvchi tomonidan o'qilishi va tahlil qilish uchun kodning murakkabligi nuqtai nazaridan o'zaro kelishuvdir - shuning uchun XML hujjatlarini tahlil qilish uchun tezkor tizimga ega bo'lish dastur ma'lumotlarini saqlash formati sifatida afzal ko'rilgan XML tanloviga ta'sir qilishi mumkin.
Ushbu bobda tavsiflangan tahlil qilish tizimining ishlashini yaxshilashga qaratilgan va muallifga C++ dasturlash tili: pugixml yordamida o'ta samarali tahlil tizimini ishlab chiqish imkonini beradigan turli usullar tasvirlangan. Ushbu usullar XML hujjatlarini tahlil qilish tizimi uchun ishlatilgan bo'lsa-da, ularning aksariyati boshqa formatdagi hujjatlarni tahlil qilish tizimlarida yoki hatto mutlaqo bog'liq bo'lmagan dasturiy komponentlarda ham qo'llanilishi mumkin (masalan, xotirani boshqarish algoritmlari bog'liq bo'lmagan tahlil tizimlarida keng qo'llaniladi. matnli hujjatlar hududlar).
XML hujjatlarini tahlil qilishda bir-biridan farq qiluvchi bir nechta yondashuvlar mavjudligi va tahlil qilish tizimi hatto XML hujjatlari bilan tajribaga ega bo'lganlar ham bilmagan qo'shimcha qadamlarni bajarishi kerakligi sababli, amalga oshirish tafsilotlari haqida batafsil ma'lumot berishdan oldin, avvalo, vazifani tavsiflash muhimdir.
XML tahlil tizimlarining modellari
Har biri turli modellar XML hujjatlarini tahlil qilish tizimlari ma'lum vaziyatlarda optimal hisoblanadi va bu modellarning har biri o'ziga xos ishlash va xotira iste'mol parametrlariga ega. Quyidagi modellar eng keng tarqalgan:
- SAX-ga asoslangan tahlil qilish tizimlaridan (XML uchun oddiy API) foydalanganda, foydalanuvchi o'z joyida qabul qiladi dasturiy ta'minot komponenti, bu kirish sifatida hujjat ma'lumotlar oqimini kutadi va "ochiq teg", "yopish teg", "teg ichidagi belgi" kabi bir nechta qayta qo'ng'iroq funksiyalarini ta'minlaydi. Tahlil qilish tizimi hujjat ma'lumotlarini qayta ishlashda qayta qo'ng'iroq qilish funktsiyalaridan foydalanadi. Tahlil qilish uchun zarur bo'lgan kontekst joriy element daraxtining chuqurligi bilan cheklangan, bu esa xotira talablarini sezilarli darajada kamaytirishni nazarda tutadi. Ushbu turdagi tahlil qilish tizimi bir vaqtning o'zida hujjatning faqat bir qismi mavjud bo'lganda oqimli hujjatlarni qayta ishlash uchun ishlatilishi mumkin.
- Pull tahlil qilish jarayonning o'zi bo'yicha SAX-ga asoslangan tahlilga o'xshaydi - bir vaqtning o'zida bitta hujjat elementi qayta ishlanadi, lekin tahlil qilish jarayonini boshqarish usuli o'zgartiriladi: SAX-ga asoslangan tahlil qilish tizimida tahlil qilish jarayoni tomonidan boshqariladi. tizimning o'zi qayta qo'ng'iroq qilish funksiyalaridan foydalangan holda, tortishish tahlili paytida foydalanuvchi iteratorga o'xshash ob'ekt yordamida tahlil qilish jarayonini boshqaradi.
- DOM-ga asoslangan tahlil qilish tizimlaridan (Hujjat ob'ekt modeli) foydalanganda, foydalanuvchi tahlil qilish tizimiga bufer yoki matnli ma'lumotlar oqimi ko'rinishida to'liq hujjatni uzatadi, buning asosida tahlil qilish tizimi xotirada butun ob'ektning tasvirini yaratadi. Hujjat elementlari daraxti, har bir muayyan element uchun alohida ob'ektlardan foydalangan holda yoki XML atributi, shuningdek, joriy operatsiyalar to'plami (masalan, "hammasini oling bolalar elementlari bu tugun"). Pugxml kutubxonasi ushbu modeldan foydalanadi.
Tahlil qilish tizimining modelini tanlash odatda hujjat hajmiga va uning tuzilishiga bog'liq. Pugixml DOM asosida tahlil qilinganligi sababli, u quyidagi hujjatlar uchun samarali bo'ladi:
- hajmi shunchalik kichikki, ular xotiraga to'liq sig'ishi mumkin,
- kesib o'tilishi kerak bo'lgan tugunlar orasidagi bog'lanishlar bilan murakkab tuzilishga ega yoki
- murakkab hujjatlarni o'zgartirishni talab qiladi.
Pugixml ichida arxitektura yechimlari
Pugixml kutubxonasini ishlab chiqishda asosiy e'tibor DOM taqdimotini yaratish muammosiga qaratildi, chunki tez va engil SAX-ga asoslangan tahlil qilish tizimlari (masalan, Expat) mavjud bo'lsa-da, barcha DOM-ga asoslangan XML tahlil tizimlari ishlab chiqarish uchun mavjud edi. pugixml yaratilgan vaqtda foydalanish (2006) juda engil emas yoki juda tez emas edi. Bunga asoslanib, puixml ishlab chiqish jarayonining asosiy maqsadi XML hujjatlarini DOM asosidagi manipulyatsiyani amalga oshirish uchun juda tez, engil kutubxona yaratishdir.
ushbu maqolani nashr etishga faqat maqola muallifining veb-saytiga havola bilan ruxsat beriladi
Ushbu maqolada men katta XML faylini tahlil qilish misolini ko'rsataman. Agar sizning serveringiz (xosting) skriptning ishlash vaqtini oshirishni taqiqlamasa, siz kamida gigabayt og'irlikdagi XML faylini tahlil qilishingiz mumkin; Men shaxsan faqat 450 megabayt og'irlikdagi ozon fayllarini tahlil qildim.
Katta XML fayllarni tahlil qilishda ikkita muammo yuzaga keladi:
1. Xotira yetarli emas.
2. Skriptni ishga tushirish uchun ajratilgan vaqt yetarli emas.
Vaqt bilan bog'liq ikkinchi muammo, agar server buni taqiqlamasa, hal qilinishi mumkin.
Ammo xotira bilan bog'liq muammoni hal qilish qiyin, hatto biz o'z serveringiz haqida gapiradigan bo'lsak ham, 500 megabaytlik fayllarni ko'chirish unchalik oson emas va hosting va VDS-da xotirani ko'paytirish shunchaki mumkin emas.
PHP-da bir nechta o'rnatilgan XML ishlov berish variantlari mavjud - SimpleXML, DOM, SAX.
Ushbu variantlarning barchasi ko'plab maqolalarda misollar bilan batafsil tavsiflangan, ammo barcha misollar to'liq XML hujjati bilan ishlashni ko'rsatadi.
Mana bir misol, biz ob'ektni olamiz XML fayli
Endi siz ushbu ob'ektni qayta ishlashingiz mumkin, LEKIN...
Ko'rib turganingizdek, butun XML fayli xotiraga o'qiladi, keyin hamma narsa ob'ektga ajratiladi.
Ya'ni, barcha ma'lumotlar xotiraga tushadi va agar ajratilgan xotira etarli bo'lmasa, skript to'xtaydi.
Ushbu parametr katta hajmdagi fayllarni qayta ishlash uchun mos emas, siz faylni satr bilan o'qib chiqishingiz va ushbu ma'lumotlarni birma-bir qayta ishlashingiz kerak.
Bunday holda, haqiqiyligini tekshirish ma'lumotlar qayta ishlanayotganda ham amalga oshiriladi, shuning uchun siz orqaga qaytarishingiz kerak, masalan, noto'g'ri XML fayli bo'lsa, ma'lumotlar bazasiga kiritilgan barcha ma'lumotlarni o'chirib tashlashingiz yoki ikkita o'tishni amalga oshirishingiz kerak. fayl orqali avval amal qilish uchun o'qing, keyin ma'lumotlarni qayta ishlash uchun o'qing.
Bu erda katta XML faylini tahlil qilishning nazariy misoli.
Ushbu skript fayldan bir vaqtning o'zida bitta belgini o'qiydi, bu ma'lumotlarni bloklarga to'playdi va XML tahlilchisiga yuboradi.
Ushbu yondashuv xotira muammosini to'liq hal qiladi va yukni keltirib chiqarmaydi, lekin vaqt o'tishi bilan muammoni yanada kuchaytiradi. Vaqt o'tishi bilan muammoni qanday hal qilishga harakat qilish kerak, quyida o'qing.
webi_xml funksiyasi ($file)
{
########
### maʼlumotlar funksiyasi
{
$data ni chop etish;
}
############################################
{
$name ni chop etish;
print_r($attr);
}
## yopish tegi funksiyasi
funktsiya endElement ($parser, $name)
{
$name ni chop etish;
}
############################################
($xml_parser, "ma'lumotlar");
// faylni oching
$fp = fopen($fayl, "r");
$perviy_vxod = 1 ; $data = "" ;
{
$simvol = fgetc ($fp); $data .= $simvol ;
if($simvol != ">" ) (davom etish;)
aks-sado "
sindirish;
}
$data = "" ;
}
fclose($fp);
Webi_xml("1.xml");
?>
Ushbu misolda men hamma narsani webi_xml() funktsiyasiga joylashtirdim va eng pastki qismida siz uning chaqiruvini ko'rishingiz mumkin.
Skriptning o'zi uchta asosiy funktsiyadan iborat:
1. startElement() tegining ochilishini ushlaydigan funksiya
2. Yopuvchi endElement() tegini ushlaydigan funksiya
3. Va ma'lumotlarni qabul qiluvchi funktsiya data() .
Faraz qilaylik, 1.xml faylining mazmuni retseptdir
<
title
>Oddiy non
<
ingredient amount
=
"3"
unit
=
"стакан"
>Un
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>Xamirturush
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>Iliq suv
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>tuz
<
instructions
>
<
step
>
Barcha ingredientlarni aralashtiring va yaxshilab yoğurun.
<
step
>
Ro'mol bilan yoping va issiq xonada bir soatga qoldiring..
<
step
>
Yana yoğurun,
pishirish varag'iga qo'ying va pechga qo'ying.
<
step
>
Sayt saytiga tashrif buyuring
Biz hamma narsani webi_xml ("1.xml") umumiy funksiyasini chaqirish orqali boshlaymiz;
Keyinchalik, tahlilchi ushbu funktsiyada boshlanadi va barcha teglar bir xil registrga ega bo'lishi uchun barcha teg nomlarini bosh harfga o'zgartiradi.
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, rost);
Endi biz tegni ochish, yopish va ma'lumotlarni qayta ishlash uchun qaysi funktsiyalar ishlashini ko'rsatamiz
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "ma'lumotlar");
Keyinchalik kashfiyot keladi belgilangan fayl, fayl bo'ylab bir vaqtning o'zida bitta belgini takrorlaydi va har bir belgi belgi topilmaguncha satr o'zgaruvchisiga qo'shiladi >
.
Agar bu faylga birinchi kirish bo'lsa, u holda fayl boshida keraksiz bo'lgan barcha narsalar o'chiriladi, oldin kelgan hamma narsa o'chiriladi. , bu XML bilan boshlanishi kerak bo'lgan teg.
Birinchi marta satr o'zgaruvchisi qatorni o'z ichiga oladi
Va uni demontajchiga yuboring
xml_parse ($xml_parser, $ma'lumotlar, feof ($fp));
Ma'lumotlarni qayta ishlagandan so'ng, satr o'zgaruvchisi qayta o'rnatiladi va ma'lumotlarni satrga yig'ish yana boshlanadi va satr ikkinchi marta hosil bo'ladi.
Uchinchisida
Yodda tutingki, satr o'zgaruvchisi har doim tugallangan tegdan hosil bo'ladi >
va o'g'riga, masalan, ma'lumotlar bilan ochiq va yopiq tegni yuborish kerak emas
Bu ishlov beruvchi uchun butun buzilmagan tegni, kamida bitta ochiq tegni, keyingi bosqichda esa yopiq tegni olishi yoki faylning 1000 qatorini darhol qabul qilishi muhim, muhim emas, asosiysi teg buzilmaydi, masalan
le>Oddiy non
Shunday qilib, ishlov beruvchiga ma'lumot yuborish mumkin emas, chunki teg yirtilgan.
Siz ishlov beruvchiga ma'lumot yuborishning o'z usulini topishingiz mumkin, masalan, 1 megabayt ma'lumot to'plang va tezlikni oshirish uchun ishlov beruvchiga yuboring, shunchaki teglar har doim to'ldirilganligiga va ma'lumotlar yirtilib ketishiga ishonch hosil qiling.
Shunday qilib, siz xohlaganingizcha qismlarga yuborishingiz mumkin katta fayl ishlov beruvchiga.
Keling, ushbu ma'lumotlar qanday qayta ishlanishi va uni qanday olish kerakligini ko'rib chiqaylik.
Ochilish teglari funksiyasidan boshlaylik startElement ($parser, $name, $attrs)
Aytaylik, ishlov berish chiziqqa yetdi
<
ingredient amount
=
"3"
unit
=
"стакан"
>Un
Keyin funktsiya ichida $name o'zgaruvchisi teng bo'ladi ingredient ya'ni ochiq tegning nomi (u tegni yopishga hali kelmagan).
Bundan tashqari, bu holda, $attrs tegining atributlari qatori mavjud bo'ladi, ular ma'lumotlarni o'z ichiga oladi. miqdor = "3" va birlik = "shisha".
Shundan so'ng, ochiq tegning ma'lumotlari funktsiya tomonidan qayta ishlandi ma'lumotlar ($parser, $data)
$data o'zgaruvchisi ochilish va yopish teglari orasidagi hamma narsani o'z ichiga oladi, bizning holatlarimizda bu Muka matni
Va bizning satrimizni funktsiya tomonidan qayta ishlash tugaydi endElement ($parser, $name)
Bu yopiq tegning nomi, bizning holatlarimizda $name ga teng bo'ladi ingredient
Va shundan keyin hamma narsa yana aylanaga aylandi.
Yuqoridagi misol faqat XML-ni qayta ishlash tamoyilini ko'rsatadi, lekin haqiqiy qo'llash uchun uni o'zgartirish kerak.
Odatda, ma'lumotlar bazasiga ma'lumotlarni kiritish uchun katta XML-ni tahlil qilishingiz kerak va ma'lumotlarni to'g'ri qayta ishlash uchun siz ma'lumotlar qaysi ochiq tegga tegishli ekanligini, teglarni joylashtirishning qaysi darajasi va yuqoridagi ierarxiyada qaysi teglar ochiqligini bilishingiz kerak. Ushbu ma'lumotlar bilan siz faylni hech qanday muammosiz to'g'ri qayta ishlashingiz mumkin.
Buning uchun siz ochiq teglar, joylashtirish va ma'lumotlar haqida ma'lumot to'playdigan bir nechta global o'zgaruvchilarni kiritishingiz kerak.
Bu erda siz foydalanishingiz mumkin bo'lgan misol
webi_xml funksiyasi ($file)
{
global $webi_depth ; // joylashtirish chuqurligini kuzatish uchun hisoblagich
$webi_depth = 0 ;
global $webi_tag_open ; // ochiq in qatorini o'z ichiga oladi bu daqiqa teglar
$webi_tag_open = massiv();
global $webi_data_temp ; // bu massiv bitta teg ma'lumotlarini o'z ichiga oladi
####################################################
### maʼlumotlar funksiyasi
funktsiya ma'lumotlari ($parser, $data)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// massivga joylashtirish va hozirda ochiq tegni ko'rsatuvchi ma'lumotlarni qo'shing
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "ma'lumotlar" ].= $data ;
}
############################################
####################################################
### tegni ochish funksiyasi
startElement funktsiyasi ($parser, $name, $attrs)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// agar joylashtirish darajasi endi nolga teng bo'lmasa, unda bitta teg allaqachon ochiq
// va undan olingan ma'lumotlar allaqachon massivda, siz uni qayta ishlashingiz mumkin
agar ($webi_depth)
{
"
;
chop etish "
"
;
print_r($webi_tag_open); // ochiq teglar massivi
chop etish "
" ;
// ma'lumotlarni qayta ishlagandan so'ng, xotirani bo'shatish uchun uni o'chiring
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}
// endi keyingi teg ochildi va keyingi bosqichda keyingi ishlov beriladi
$webi_depth++; // uyani ko'paytirish
$webi_tag_open [ $webi_depth ]= $name ; // ma'lumotlar massiviga ochiq teg qo'shing
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // endi teg atributlarini qo'shing
}
###############################################
#################################################
## yopish tegi funksiyasi
funktsiya endElement ($parser, $name) (
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// ma'lumotlarni qayta ishlash shu erda boshlanadi, masalan, ma'lumotlar bazasiga qo'shish, faylga saqlash va hokazo.
// $webi_tag_open joylashtirish darajasi bo'yicha ochiq teglar zanjirini o'z ichiga oladi
// masalan, $webi_tag_open[$webi_depth] maʼlumotlari hozirda qayta ishlanayotgan ochiq teg nomini oʻz ichiga oladi.
// $webi_depth teg joylashtirish darajasi
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] teg atributlari massivi
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] teg maʼlumotlari
"Ma'lumotlar" ni chop eting. $webi_tag_open [ $webi_depth ]. "--" .($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "ma'lumotlar" ]). "
"
;
print_r ($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "attrs" ]);
chop etish "
"
;
print_r($webi_tag_open);
chop etish "
" ;
Unset($GLOBALS [ "webi_data_temp" ]); // Ma'lumotlarni qayta ishlagandan so'ng, teg yopilganligi sababli, biz butun massivni ma'lumotlar bilan o'chirib tashlaymiz
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // bu ochiq teg haqidagi ma'lumotlarni o'chirish... yopilganidan beri
$webi_depth --; // uy qurishni qisqartirish
}
############################################
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, rost);
// teglarni ochish va yopishda qaysi funksiyalar ishlashini bildiring
xml_set_element_handler($xml_parser, "startElement", "endElement");
// ma'lumotlar bilan ishlash funksiyasini belgilang
xml_set_character_data_handler($xml_parser, "ma'lumotlar");
// faylni oching
$fp = fopen($fayl, "r");
$perviy_vxod = 1 ; // faylga birinchi yozuvni tekshirish uchun bayroq
$ma'lumotlar = "" ; // bu erda biz fayldan ma'lumotlarni qismlarga bo'lib yig'amiz va uni xml tahlilchisiga yuboramiz
// faylning oxiri topilguncha tsikl
esa (! feof ($fp ) va $fp )
{
$simvol = fgetc ($fp); // fayldan bitta belgini o'qing
$data .= $simvol ; // yuboriladigan ma'lumotlarga ushbu belgini qo'shing
// agar belgi yakuniy teg bo'lmasa, u holda tsiklning boshiga qayting va ma'lumotlarga boshqa belgi qo'shing va yakuniy teg topilguncha davom eting.
if($simvol != ">" ) (davom etish;)
// agar yopish yorlig'i topilgan bo'lsa, endi biz ushbu to'plangan ma'lumotlarni qayta ishlash uchun yuboramiz
// bu faylga birinchi kirish yoki yo'qligini tekshiring, keyin teg oldidagi hamma narsani o'chirib tashlaymiz// chunki ba'zida siz XML boshlanishidan oldin axlatga duch kelishingiz mumkin (noto'g'ri tahrirlovchilar yoki fayl boshqa serverdan skript tomonidan qabul qilingan)
if($perviy_vxod ) ( $data = strstr ($data , "
// endi ma'lumotlarni xml tahlilchisiga tashlang
agar (! xml_parse ($xml_parser, $data, feof ($fp)))) (
// bu yerda siz haqiqiylik xatolarini qayta ishlashingiz va qabul qilishingiz mumkin...
// xatolik yuz berishi bilanoq tahlil qilish to'xtaydi
aks-sado "
XML xatosi: " . xml_error_string(xml_get_error_code($xml_parser));
echo "satrda". xml_get_current_line_number ($xml_parser);
sindirish;
}
// tahlil qilgandan so'ng, to'plangan ma'lumotlarni tsiklning keyingi bosqichi uchun tashlang.
$ma'lumotlar = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// global o'zgaruvchilarni olib tashlash
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);
Webi_xml("1.xml");
?>
Butun misol sharhlar bilan birga keladi, endi sinov va tajriba.
E'tibor bering, ma'lumotlar bilan ishlash funktsiyasida ma'lumotlar oddiygina massivga kiritilmaydi, balki "" yordamida qo'shiladi. .="
chunki ma'lumotlar to'liq kelmasligi mumkin va agar siz shunchaki topshiriq qilsangiz, vaqti-vaqti bilan siz ma'lumotlarni qismlarga bo'lib olasiz.
Xo'sh, hammasi shu, endi istalgan o'lchamdagi faylni qayta ishlashda etarli xotira mavjud, ammo skriptning ishlash muddatini bir necha usul bilan oshirish mumkin.
Skript boshida funktsiyani kiriting
belgilangan_vaqt_chegarasi(6000);
yoki
ini_set ("maksimal_bajarish_vaqti" , "6000" );
Yoki .htaccess fayliga matn qo'shing
php_value max_execution_time 6000
Ushbu misollar skriptning ishlash vaqtini 6000 soniyagacha oshiradi.
Faqat xavfsiz rejim o'chirilganda vaqtni shu tarzda oshirishingiz mumkin.
Agar sizda php.ini tahrirlash imkoniyati mavjud bo'lsa, undan foydalanish vaqtini oshirishingiz mumkin
maksimal_bajarish_vaqti = 6000
Masalan, Masterhost xostingida, ushbu maqolani yozish paytida, skript vaqtini ko'paytirish taqiqlanadi, garchi xavfsiz rejim, lekin agar siz professional bo'lsangiz, masterhost-da o'zingizning PHP-ni yaratishingiz mumkin, ammo bu maqolada emas.
XML tahlili asosan XML hujjati bo'ylab yurish va tegishli ma'lumotlarni qaytarishni anglatadi. Va veb-xizmatlarning soni ortib borayotgan bo'lsa-da, ma'lumotlarni qaytaradi JSON formati lekin ko'pchilik hali ham XML dan foydalanadi, shuning uchun to'liq diapazondan foydalanmoqchi bo'lsangiz, XML tahlilini o'zlashtirish muhimdir mavjud interfeyslar API.
Kengaytmadan foydalanish SimpleXML PHP 5.0 da qo'shilgan PHP da XML bilan ishlash juda oson va sodda. Ushbu maqolada men buni qanday qilishni sizga ko'rsataman.
Foydalanish asoslari
Keling, quyidagi misoldan boshlaylik tillar.xml:
>
>
>
>
Ushbu XML hujjati har bir til haqida ba'zi ma'lumotlarga ega bo'lgan dasturlash tillari ro'yxatini o'z ichiga oladi: u kiritilgan yil va uni yaratuvchisining nomi.
Birinchi qadam funksiyalar yordamida XMLni yuklashdir simplexml_load_file(), yoki simplexml_load_string(). Funktsiyalar nomidan ko'rinib turibdiki, birinchisi fayldan XMLni yuklaydi, ikkinchisi esa satrdan XMLni yuklaydi.
Ikkala funktsiya ham butun DOM daraxtini xotiraga o'qiydi va ob'ektni qaytaradi SimpleXMLElement. Yuqoridagi misolda ob'ekt $languages o'zgaruvchisida saqlanadi. Funktsiyalardan foydalanishingiz mumkin var_dump() yoki print_r() Agar xohlasangiz, qaytarilgan ob'ekt haqida ma'lumot olish uchun.
SimpleXMLElement obyekti
[lang] => Massiv
[ 0 ] => SimpleXMLElement obyekti
[@atributlar] => Massiv
[ism] => C
[paydo bo'ldi] => 1972
[yaratuvchi] => Dennis Ritchie
[ 1 ] => SimpleXMLElement obyekti
[@atributlar] => Massiv
[ism] => PHP
[paydo bo'ldi] => 1995 yil
[yaratuvchi] => Rasmus Lerdorf
[ 2 ] => SimpleXMLElement obyekti
[@atributlar] => Massiv
[ism] => Java
[paydo bo'ldi] => 1995 yil
[yaratuvchi] => Jeyms Gosling
)
)
Ushbu XML ildiz elementini o'z ichiga oladi tillar, uning ichida uchta element mavjud lang. Har bir massiv elementi elementga mos keladi lang XML hujjatida.
Operator yordamida obyektning xususiyatlariga kirishingiz mumkin -> . Masalan, $languages->lang sizga birinchi elementga mos keladigan SimpleXMLElement obyektini qaytaradi lang. Ushbu ob'ekt ikkita xususiyatni o'z ichiga oladi: paydo bo'lgan va yaratuvchi.
$languages -> lang [ 0 ] -> paydo bo'ldi;
$languages -> lang [ 0 ] -> yaratuvchi ;
Tillar ro'yxatini ko'rsatish va ularning xususiyatlarini ko'rsatish kabi standart tsikl yordamida juda oson bajarilishi mumkin har biriga.
foreach ($languages -> lang $lang sifatida) (
printf(
""
,
$lang [ "ism" ] ,
$lang -> paydo bo'ldi,
$lang -> yaratuvchisi
)
;
}
Til nomini olish uchun elementning lang atribut nomiga qanday kirganimga e'tibor bering. Shu tarzda siz SimpleXMLElement obyekti sifatida taqdim etilgan elementning istalgan atributiga kirishingiz mumkin.
Namespaces bilan ishlash
Turli xil veb-xizmatlarning XML bilan ishlashda siz elementlarning nom maydonlariga bir necha marta duch kelasiz. Keling, o'zimizni o'zgartiraylik tillar.xml nom maydonidan foydalanish misolini ko'rsatish uchun:
xmlns:dc =>
>
>
>
>
Endi element yaratuvchi nom maydoniga mos keladi DC bu http://purl.org/dc/elements/1.1/ ga ishora qiladi. Agar siz bizning oldingi kodimiz yordamida til yaratuvchilarni chop etishga harakat qilsangiz, u ishlamaydi. Element nomlari bo'shliqlarini o'qish uchun siz quyidagi yondashuvlardan birini qo'llashingiz kerak.
Birinchi yondashuv element nom maydoniga kirishda URI nomlarini to'g'ridan-to'g'ri kodda ishlatishdir. Quyidagi misol bu qanday amalga oshirilganligini ko'rsatadi:
$dc = $languages -> lang [ 1 ] -> bolalar( "http://purl.org/dc/elements/1.1/")
;
echo $dc -> yaratuvchisi ;
Usul bolalar() nom maydonini oladi va prefiks bilan boshlanadigan asosiy elementlarni qaytaradi. Bu ikkita argumentni oladi, birinchisi XML nom maydoni, ikkinchisi esa sukut bo'yicha ixtiyoriy argumentdir. yolg'on. Agar ikkinchi argument TRUE ga o'rnatilgan bo'lsa, nom maydoni prefiks sifatida ko'rib chiqiladi. Agar FALSE bo'lsa, nom maydoni URL nom maydoni sifatida ko'rib chiqiladi.
Ikkinchi yondashuv - hujjatdan URI nomlarini o'qish va elementlar nom maydoniga kirishda ulardan foydalanish. Bu aslida elementlarga kirishning eng yaxshi usuli, chunki siz URI ga qattiq kodlangan bo'lishingiz shart emas.
$namespaces = $languages -> getNamespaces (to'g'ri);
$dc = $languages -> lang [ 1 ] -> bolalar (($namespaces [ "dc" ] );
echo $dc -> yaratuvchisi ;
Usul GetNamespaces() prefiks nomlari va ular bilan bog'liq URIlar qatorini qaytaradi. U standart bo'lgan qo'shimcha parametrni qabul qiladi yolg'on. Agar shunday o'rnatsangiz rost, keyin bu usul ota-ona va bola tugunlarida ishlatiladigan nomlarni qaytaradi. Aks holda, u faqat ota-ona tugunida ishlatiladigan nom maydonlarini topadi.
Endi siz quyidagi tillar ro'yxatini takrorlashingiz mumkin:
$languages = simplexml_load_file ("languages.xml" );
$ns = $languages -> getNamespaces (to'g'ri);
foreach ($languages -> lang $lang sifatida) (
$dc = $lang -> bolalar ($ns [ "dc" ] );
printf(
"
%s %d da paydo boʻldi va %s tomonidan yaratilgan.
" ,$lang [ "ism" ] ,
$lang -> paydo bo'ldi,
$dc -> yaratuvchisi
) ;
}
Amaliy misol - YouTube'dan video kanalni tahlil qilish
Keling, YouTube kanalidan RSS tasmasini oladigan va undagi barcha videolarga havolalarni ko'rsatadigan misolni ko'rib chiqaylik. Buning uchun quyidagi manzilga murojaat qiling:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
URL ma'lum bir kanaldan XML formatidagi so'nggi videolar ro'yxatini qaytaradi. Biz XMLni tahlil qilamiz va har bir video uchun quyidagi ma'lumotlarni olamiz:
- Videoga havola
- Miniatyura
- Ism
XMLni qidirish va yuklashdan boshlaymiz:
$channel = "Kanal_nomi" ;
$url = "http://gdata.youtube.com/feeds/api/users/". $kanal. "/yuklashlar";
$xml = file_get_contents($url);
$feed = simplexml_load_string ($xml);
$ns = $feed -> getNameSpaces ( rost );
Agar siz XML tasmasiga qarasangiz, u erda bir nechta elementlar mavjudligini ko'rishingiz mumkin tashkilot, ularning har biri saqlanadi batafsil ma'lumot kanaldan ma'lum bir video haqida. Lekin biz faqat rasm eskizlari, video URL manzili va sarlavhasidan foydalanamiz. Bu uch element elementning avlodlaridir guruh, bu esa, o'z navbatida, farzandidir kirish:
…
…
…
>
…
Biz faqat barcha elementlarni ko'rib chiqamiz kirish, va ularning har biri uchun biz kerakli ma'lumotlarni chiqaramiz. shu esta tutilsinki futbolchi eskiz Va sarlavha media nomlar maydonida. Shunday qilib, biz oldingi misolda bo'lgani kabi davom etishimiz kerak. Biz hujjatdan nomlarni olamiz va elementlarga kirishda nomlar maydonidan foydalanamiz.
foreach ($feed -> entry $entry sifatida) (
$group = $entry -> bolalar ($ns [ "media" ] );
$group = $group -> group ;
$thumbnail_attrs = $group -> eskiz [ 1 ] -> atributlar () ;
$image = $thumbnail_attrs [ "url" ] ;
$player = $group -> player -> atributlar () ;
$link = $player [ "url" ] ;
$title = $group -> sarlavha;
printf( "
$player, $tasvir, $title);
}
Xulosa
Endi siz qanday foydalanishni bilasiz SimpleXML XML ma'lumotlarini tahlil qilish uchun siz turli xil API-lar bilan turli XML tasmalarini tahlil qilish orqali o'z mahoratingizni oshirishingiz mumkin. Ammo shuni hisobga olish kerakki, SimpleXML butun DOMni xotiraga o'qiydi, shuning uchun agar siz katta ma'lumotlar to'plamini tahlil qilsangiz, xotirangiz tugashi mumkin. SimpleXML haqida ko'proq ma'lumot olish uchun hujjatlarni o'qing.
Agar sizda biron bir savol bo'lsa, bizdan foydalanishni tavsiya etamiz
