Kaya, sa mga bahagi ayon sa gusto mo, maaari kang magpadala ng isang malaking file sa processor.

Ngayon tingnan natin kung paano pinoproseso ang data na ito at kung paano ito makukuha.

Magsimula tayo sa pambungad na tag function startElement ($parser, $name, $attrs)
Ipagpalagay natin na ang pagpoproseso ay umabot na sa linya
< ingredient amount = "3" unit = "стакан" >harina
Pagkatapos sa loob ng function ang variable na $name ay magiging katumbas ng sangkap ibig sabihin, ang pangalan ng bukas na tag (hindi pa ito sumasara sa tag).
Gayundin sa kasong ito, isang hanay ng mga katangian ng tag na ito na $attrs ay magiging available, na maglalaman ng data halaga = "3" at unit = "salamin".

Pagkatapos nito, ang data ng bukas na tag ay naproseso ng function data ($parser, $data)
Ang variable na $data ay maglalaman ng lahat ng nasa pagitan ng pambungad at pagsasara ng mga tag, sa aming kaso ito ang tekstong Muka

At ang pagproseso ng aming string sa pamamagitan ng function ay nagtatapos endElement ($parser, $name)
Ito ang pangalan ng closed tag, sa aming kaso $name ay magiging katumbas ng sangkap

At pagkatapos noon ang lahat ay naglibot muli.

Ang halimbawa sa itaas ay nagpapakita lamang ng prinsipyo ng pagpoproseso ng XML, ngunit para sa tunay na aplikasyon kailangan itong baguhin.
Karaniwan, kailangan mong i-parse ang malaking XML upang maipasok ang data sa database, at para maayos na maproseso ang data na kailangan mong malaman kung aling bukas na tag ang data kabilang, kung anong antas ng tag nesting, at kung aling mga tag ang bukas sa hierarchy sa itaas. Gamit ang impormasyong ito, maaari mong iproseso nang tama ang file nang walang anumang mga problema.
Para magawa ito, kailangan mong magpakilala ng ilang pandaigdigang variable na mangongolekta ng impormasyon tungkol sa mga bukas na tag, nesting at data.
Narito ang isang halimbawa na maaari mong gamitin

Function na webi_xml ($file)
{
global $webi_depth ; // counter para subaybayan ang lalim ng nesting
$webi_depth = 0 ;
pandaigdigang $webi_tag_open ; // ay maglalaman ng hanay ng mga kasalukuyang bukas na tag
$webi_tag_open = array();
pandaigdigang $webi_data_temp ; // ang array na ito ay maglalaman ng data ng isang tag

####################################################
### function ng data
data ng function ($parser, $data)
{
global $webi_depth ;
pandaigdigang $webi_tag_open ;
pandaigdigang $webi_data_temp ;
// magdagdag ng data sa array na nagpapahiwatig ng nesting at kasalukuyang bukas na tag
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################

####################################################
### opening tag function
function startElement ($parser, $name, $attrs)
{
global $webi_depth ;
pandaigdigang $webi_tag_open ;
pandaigdigang $webi_data_temp ;

// kung hindi na zero ang nesting level, bukas na ang isang tag
// at ang data mula dito ay nasa array na, maaari mo itong iproseso
kung ($webi_depth)
{

" ;

print"
" ;
print_r($webi_tag_open); // hanay ng mga bukas na tag
print"

// pagkatapos iproseso ang data, tanggalin ito upang magbakante ng memorya
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}

// ngayon ang susunod na tag ay binuksan at ang karagdagang pagproseso ay magaganap sa susunod na hakbang
$webi_depth++; // dagdagan ang pugad

$webi_tag_open [ $webi_depth ]= $name ; // magdagdag ng bukas na tag sa hanay ng impormasyon
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // ngayon magdagdag ng mga katangian ng tag

}
###############################################

#################################################
## closing tag function
function endElement ($parser, $name) (
global $webi_depth ;
pandaigdigang $webi_tag_open ;
pandaigdigang $webi_data_temp ;

// Nagsisimula ang pagproseso ng data dito, halimbawa pagdaragdag sa database, pag-save sa isang file, atbp.
// Ang $webi_tag_open ay naglalaman ng isang hanay ng mga bukas na tag ayon sa antas ng nesting
// halimbawa $webi_tag_open[$webi_depth] ay naglalaman ng pangalan ng bukas na tag na ang impormasyon ay kasalukuyang pinoproseso
// $webi_depth tag nesting level
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] hanay ng mga attribute ng tag
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] data ng tag

I-print ang "data" . $webi_tag_open [ $webi_depth ]. "--" .($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ]). "
" ;
print_r ($webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "attrs" ]);
print"
" ;
print_r($webi_tag_open);
print"

Unset($GLOBALS [ "webi_data_temp" ]); // pagkatapos iproseso ang data, tatanggalin namin ang buong array na may data, dahil sarado ang tag
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // tanggalin ang impormasyon tungkol sa bukas na tag na ito... mula noong nagsara ito

$webi_depth --; // bawasan ang nesting
}
############################################

$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);

// ipahiwatig kung aling mga function ang gagana kapag binubuksan at isinasara ang mga tag
xml_set_element_handler($xml_parser, "startElement", "endElement");

// tukuyin ang isang function para sa pagtatrabaho sa data
xml_set_character_data_handler($xml_parser, "data");

// buksan ang file
$fp = fopen($file, "r");

$perviy_vxod = 1 ; // flag para suriin ang unang entry sa file
$data = "" ; // dito kinokolekta namin ang data mula sa file sa mga bahagi at ipadala ito sa xml parser

// loop hanggang sa dulo ng file ay matagpuan
habang (! feof ($fp ) at $fp )
{
$simvol = fgetc ($fp); // basahin ang isang character mula sa file
$data .= $simvol ; // idagdag ang character na ito sa data na ipapadala

// kung ang character ay hindi isang end tag, pagkatapos ay bumalik sa simula ng loop at magdagdag ng isa pang character sa data, at iba pa hanggang sa makita ang end tag
if($simvol != ">") ( continue;)
// kung natagpuan ang pansarang tag, ngayon ay ipapadala namin ang nakolektang data na ito para sa pagproseso

// suriin kung ito ang unang entry sa file, pagkatapos ay tatanggalin namin ang lahat na bago ang tag// dahil kung minsan ay maaaring may basura bago ang simula ng XML (mga clumsy na editor, o ang file ay natanggap ng isang script mula sa ibang server)
if($perviy_vxod ) ($data = strstr ($data , "

// ngayon itapon ang data sa xml parser
kung (! xml_parse ($xml_parser, $data, feof ($fp))) (

// dito maaari kang magproseso at makatanggap ng mga error sa validity...
// sa sandaling magkaroon ng error, hihinto ang pag-parse
echo"
XML Error: " . xml_error_string(xml_get_error_code($xml_parser));
echo "sa linya" . xml_get_current_line_number ($xml_parser);
masira;
}

// pagkatapos ng pag-parse, itapon ang nakolektang data para sa susunod na hakbang ng cycle.
$data = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// pag-alis ng mga pandaigdigang variable
unset($GLOBALS [ "webi_depth" ]);
unset($GLOBALS [ "webi_tag_open" ]);
unset($GLOBALS [ "webi_data_temp" ]);

Webi_xml("1.xml");

?>

Ang buong halimbawa ay sinamahan ng mga komento, ngayon ay pagsubok at eksperimento.
Mangyaring tandaan na sa pag-andar ng pagtatrabaho sa data, ang data ay hindi lamang ipinasok sa isang array, ngunit sa halip ay idinagdag gamit ang " .=" dahil ang data ay maaaring hindi dumating sa kabuuan nito, at kung gagawa ka lamang ng isang takdang-aralin, pagkatapos ay pana-panahong matatanggap mo ang data sa mga tipak.

Well, iyon lang, ngayon ay may sapat na memorya kapag nagpoproseso ng isang file ng anumang laki, ngunit ang oras ng pagpapatakbo ng script ay maaaring tumaas sa maraming paraan.
Magpasok ng isang function sa simula ng script
set_time_limit(6000);
o
ini_set ("max_execution_time" , "6000" );

O magdagdag ng text sa .htaccess file
php_value max_execution_time 6000

Ang mga halimbawang ito ay magpapataas sa oras ng pagpapatakbo ng script sa 6000 segundo.
Maaari mong dagdagan ang oras sa ganitong paraan lamang kapag naka-off ang safe mode.

Kung mayroon kang access upang i-edit ang php.ini maaari mong dagdagan ang oras sa paggamit
max_execution_time = 6000

Halimbawa, sa Masterhost hosting, sa oras ng pagsulat ng artikulong ito, ang pagtaas ng oras ng script ay ipinagbabawal, sa kabila ng safe mode na naka-off, ngunit kung ikaw ay isang pro, maaari kang gumawa ng iyong sariling PHP build sa Masterhost, ngunit iyon ay hindi ang paksa ng artikulong ito.

Noong isang araw, sinimulan kong i-rework ang aking panloob na sistema ng pag-uulat para sa kumpanya, ang pangkalahatang istraktura kung saan isinulat ko hindi pa matagal na ang nakalipas. Nang walang prevarication, sasabihin ko na lumaki ako sa itaas ng aking sarili sa mga tuntunin ng PHP, at, bilang resulta, natanto ko na ang algorithm ng system ay sapat na baluktot para sa akin upang muling isulat ito.

Bago ito, ang XML na dokumento ay na-parse gamit ang mga function na hiniram mula sa PHP bersyon 4. Gayunpaman, binigyan ng PHP5 ang mundo ng isang napaka-maginhawang bagay na tinatawag na SimpleXML. Ngayon ay pag-uusapan natin kung paano ito gagawin.

Ito ay nagkakahalaga ng pagsisimula sa katotohanan na ang SimpleXML ay isang hiwalay na plug-in module, at samakatuwid dapat itong paganahin nang maaga sa server na iyong ginagamit.

Ngayon ay maaari na tayong magtrabaho!

Upang maproseso ang dokumento, ginagamit namin ang function na simplexml_load_file(). Bilang parameter, ipinapasa nito ang address ng file sa format na Extended Markup Language (XML - Your K.O.).

Ang kagandahan ng function na ito ay madali mong mailipat ang isang file mula sa anumang server. Kaya, mayroon kaming pagkakataon na iproseso ang mga panlabas na xml upload (halimbawa, Yandex-XML o mga third-party na RSS feed).

Ang function ay naglalabas ng array. Ang pitfall na naranasan ko ay ang XML ay maaaring magkaroon ng clumsy na istraktura, at samakatuwid ay ipinapayo ko sa iyo na magsagawa muna ng matalinghagang bakas at mag-output ng array upang maunawaan kung paano ito pinoproseso ng function. Pagkatapos nito, maaari mong simulan ang pagproseso ng natanggap na data.

Halimbawa, kukuha ako ng isang simpleng disenyo mula dito:

>
>
> PHP: Ang paglitaw ng Parser >
>
>
> MS. Coder >
> Onlivia Actora >
>
>
> si Mr. Coder >
> El Aktor >
>
> > si Mr. Parser > > John Doe > > >
>
Kaya ito ay isang wika. Ito ay isang programming language pa rin. O kaya
scripting language ba ito? Ang lahat ng ito ay inihayag sa dokumentaryo na ito,
parang horror movie.
>
>
> Niresolba ng PHP ang lahat ng problema ko sa web >
>
7>
5>
PG > >
>

Hayaan itong maging export.xml file, na nasa ugat ng aking server kasama ang script na nagpoproseso nito.
Ang array ay binuo alinsunod sa istruktura ng mga elemento ng DOM sa XML na dokumento. Ang pagproseso ay nagsisimula sa ugat. Upang makuha ang pangalang Ms. Coder, dapat nating buuin ang sumusunod na landas: $xml->movies->movie->character->character->name.
Pakitandaan na pumipili kami ng partikular na halaga. Dito nagmumula ang ganitong uri ng notasyon ng character - huwag kalimutan na nagtatrabaho kami sa isang array!

Tulad ng anumang array, ang aming data ay maaaring iproseso gamit ang isang foreach loop. Ang code ay magiging ganito:

$xml = simplexml_load_file ("export.xml" ); //na-upload na file
$ttl = $xml -> mga pelikula -> pelikula -> pamagat ; //nakuha ang pamagat. mayroon lamang, kaya hindi na kailangang magtakda ng isa pang halaga

foreach ($xml -> mga pelikula -> pelikula -> mga karakter bilang $crc ) // ngayon ay magtrabaho tayo sa dynamics
{
//ipakita ang mga pangalan ng mga bayani
$name = $crc -> caracter -> name ;
echo(" $pangalan
" ) ;
}

Ang code na ito ay maglalagay ng text na "PHP: Parser Appears" sa $ttl variable, at pagkatapos ay ipapakita ang mga pangalan ng mga bayani sa bawat linya sa screen
MS. Coder, Mr. Coder, Mr. Parser.

Xml parser ay isang program na kumukuha ng data mula sa isang source xml file at ini-save ito o ginagamit ito para sa mga susunod na aksyon.

Bakit kailangan ang mga xml parser?

Una sa lahat, dahil ang xml format mismo ay sikat sa mga pamantayan ng computer. Ang XML file ay ganito ang hitsura:

mga. mahalagang may mga tag, may ilang mga panuntunan kung saan dapat sundin ng mga tag ang isa't isa.

Ang dahilan para sa katanyagan ng mga xml file ay ang mga ito ay lubos na nababasa ng mga tao. At ang katotohanan na ito ay medyo madaling iproseso sa mga programa.

Mga disadvantages ng xml file.

Ang downside ay, una sa lahat, ang malaking halaga ng espasyo sa disk na kinukuha ng data na ito. Dahil sa katotohanan na ang mga tag na patuloy na paulit-ulit, na may malalaking volume ng data, ay kumukuha ng medyo maraming megabytes, na kailangan lang i-download mula sa pinagmulan, at pagkatapos ay iproseso. Mayroon bang anumang mga alternatibo? Mayroong, siyempre, ngunit gayon pa man, ang mga xml parser at xml ngayon ay isa sa pinakasimple at pinaka-maaasahan at popular sa teknolohiyang mga format.

Paano isinusulat ang mga XML parser?

Ang mga parser ay nakasulat sa mga programming language. Tulad ng sinasabi nila, ang mga ito ay nakasulat sa lahat, ngunit hindi higit pa. Dapat itong maunawaan na may mga programming language na mayroon nang built-in na mga aklatan para sa pag-parse ng mga xml file. Ngunit sa anumang kaso, kahit na walang library, maaari kang palaging makahanap ng angkop na library para sa bagay na ito at gamitin ito upang kunin ang data mula sa isang file.

Sa buong mundo, mayroong 2 magkakaibang diskarte sa pag-parse ng mga xml file.

Ang una ay ang ganap na i-load ang xml file sa memorya at pagkatapos ay gawin ang mga manipulasyon upang kunin ang data.

Ang pangalawa ay ang opsyon sa streaming. Sa kasong ito, tinutukoy ng programming language ang ilang partikular na tag kung saan kailangang mag-react ang mga function ng nilikhang xml parser, at ang programmer mismo ang magpapasya kung ano ang kailangang gawin kung may nakitang partikular na tag.

Ang bentahe ng unang diskarte ay bilis. Na-download ko ang file nang sabay-sabay, pagkatapos ay mabilis na tumakbo sa aking memorya at nakita kung ano ang kailangan at, higit sa lahat, madaling i-program. ngunit mayroong isang minus at isang napakahalaga - ito

isang malaking halaga ng memorya ang kinakailangan para sa operasyon. Minsan, sasabihin ko pa nga na madalas mangyari na imposibleng iproseso at i-parse ang isang xml file, i.e. lumikha ng isang xml parser upang ang unang paraan ay gumana nang tama. Bakit ganito? Buweno, halimbawa, ang limitasyon para sa 32-bit na mga application sa ilalim ng Windows ay nagpapahintulot sa programa na sakupin ang maximum na 2 gigabytes ng memorya - hindi na ito posible.

Gayunpaman, mahirap ang programming na nakabatay sa thread. Ang pagiging kumplikado ng isang medyo seryosong pagkuha ay tumataas nang malaki, na naaayon ay nakakaapekto sa parehong time frame at ang badyet.

Ang bisa ng mga xml file at parser.

Magiging maayos ang lahat sa mga xml file at xml parser, ngunit may problema. Dahil sa ang katunayan na ang "anumang mag-aaral" ay maaaring lumikha ng isang xml na file, at sa katotohanan ito ang kaso (dahil maraming code ang isinulat ng mga mag-aaral), lumilitaw ang mga hindi wastong file, ibig sabihin, ano ang ibig sabihin nito at kung ano ito sa? Ang pinakamalaking problema , ito ay kung minsan ay imposibleng mai-parse nang tama ang isang di-wastong file , halimbawa, gumagawa ka ng parser sa .net, pagkatapos ay maaari kang lumikha ng tinatawag na wrappers , at ang pinaka-nakakainis na bagay ay gumawa ka ng ganoong wrapper, at pagkatapos ay gamitin ito upang basahin ang file na ginawa ng "schoolboy". , ngunit ang file ay hindi wasto at imposibleng basahin Samakatuwid, kailangan mong alisin ito at gumamit ng napaka, hindi sikat na mga opsyon para sa pag-parse ng mga naturang file = dahil maraming tao ang gumagawa ng mga xml na file nang hindi gumagamit ng mga karaniwang aklatan at may kumpletong pag-iwas sa lahat xml file standards Mahirap ipaliwanag ito sa mga customer Naghihintay sila ng resulta - isang xml parser na nagko-convert ng data mula sa orihinal na file sa ibang format.

Paano lumikha ng mga xml parser (unang pagpipilian)

Mayroong wika ng query para sa XML data na tinatawag na Xpath. Ang wikang ito ay may dalawang edisyon; Ang isang mas mahusay na ideya ng wikang ito ay ipapakita sa pamamagitan ng mga halimbawa kung paano ito gamitin upang kunin ang data. Halimbawa.

//div[@class="supcat guru"]/a

ano ang ginagawa ng kahilingang ito. Kinakailangan ang lahat ng mga tag na mayroon akong ref na naglalaman ng text catalog.xml?hid= at ang tag na ito ay dapat na isang div child na ang klase ay katumbas ng supcat guru.

Oo, maaaring hindi ito masyadong malinaw sa unang pagkakataon, ngunit maaari mo pa ring malaman kung gusto mo. Ang panimulang punto para sa akin ay http://ru.wikipedia.org/wiki/XPath at pinapayuhan kita.

Dumating na ang tag-araw at lumipad na ang unang linggo ng Hulyo. Sa loob ng dalawang linggo kailangan kong ipagtanggol ang aking thesis, at isa sa mga bahagi nito ay XML parser. Pero sayang wala sa PHP. Well, hindi bale, aabutin natin sa isang minuto

Nakakita na ako ng maraming xml parser, ngunit hindi ko pa nahawakan ang web programming. Ngayon gusto kong malaman at matutunan kasama mo kung paano gumawa ng simple xml parser sa php.

Bakit? Kailangan!

Hindi, mabuti, talaga: ang mga xml file ay isang napaka-kapaki-pakinabang na bagay. At ang sinumang propesyonal ay dapat... hindi, hindi dapat, ngunit dapat alam kung paano makipagtulungan sa kanila. Gusto nating maging propesyonal, tama ba? Kung ikaw ay nasa aking blog, kung gayon mayroon kang ganoong pagnanais.

Ipinapalagay namin na alam namin kung ano ang XML at hindi ito ilalarawan dito. Well, kung hindi natin alam, madali nating malalaman dito: http://ru.wikipedia.org/wiki/XML

Habang naghahanap ng mga paraan upang mai-parse ang XML sa PHP, natuklasan ko ang isang simpleng hanay ng mga function sa PHP para sa pagtatrabaho sa mga XML file na tinatawag na " Mga Pag-andar ng XML Parser" Nagsisimula ang pag-parse sa pamamagitan ng pagsisimula ng parser sa pamamagitan ng pagtawag sa xml_parser_create function:

$xml_parser = xml_parser_create();

Pagkatapos ay kailangan nating sabihin sa parser kung aling mga function ang magpoproseso ng mga xml tag at impormasyon ng teksto na nakatagpo nito sa panahon ng proseso ng pag-parse. Yung. kailangan mong mag-install ng ilang mga handler:

xml_set_element_handler($xml_parser, “startElement”, “endElement”);

Ang function na ito ay responsable para sa pagtatakda ng simula ng elemento at pagtatapos ng mga humahawak ng elemento. Halimbawa, kung may makikitang kumbinasyon sa text ng isang xml file, gagana ang startElement function kapag nahanap ng parser ang elemento, at gagana ang endElement function kapag nahanap na ito.

Ang startElement at endElement function mismo ay kumukuha ng ilang mga parameter ayon sa dokumentasyon ng php:

// (dahil maaari tayong gumamit ng ilang mga parser)

// $attrs - hanay ng mga katangian ng nakitang elemento
)function endElement($parser, $name) (
// $parser - natatanging identifier ng parser
// $name - pangalan ng nakitang elemento
}
?>

Ngunit paano magbasa ng data mula sa isang file? Wala pa kaming nakikitang isang parameter para dito sa alinman sa mga function! At higit pa dito sa ibang pagkakataon: ang pagbabasa ng file ay nakasalalay sa mga balikat ng programmer, i.e. dapat tayong gumamit ng mga karaniwang function para sa pagtatrabaho sa mga file:

Binuksan ang file. Ngayon ay kailangan mong basahin ito ng linya sa pamamagitan ng linya at i-feed ang read lines sa xml_parse function:

Dito natin napapansin ang dalawang napakahalagang bagay. Ang una ay ang xml_parse function ay kailangang maipasa ang huling line reading flag sa ikatlong parameter (true - kung ang linya ang huli, false - kung hindi). Ang pangalawang bagay ay, tulad ng sa anumang negosyo, dapat nating bantayan ang mga pagkakamali dito. Ang mga function na xml_get_error_code at xml_error_string ay responsable para dito. Ang unang function ay tumatanggap ng error code, at ang pangalawa, batay sa natanggap na code, ay nagbabalik ng isang text na paglalarawan ng error. Kung ano ang mangyayari bilang resulta ng isang error ay tatalakayin sa ibang pagkakataon. Sasabihin sa amin ng isang parehong kapaki-pakinabang na function na xml_get_current_line_number ang numero ng kasalukuyang linyang pinoproseso sa file.

At gaya ng dati, dapat nating palayain ang mga mapagkukunang inookupahan ng sistema. Para sa XML parsing, ito ang xml_parser_free function:

xml_parser_free($xml_parser);

Narito kami ay tumingin sa mga pangunahing pag-andar. Oras na para makita sila sa pagkilos. Para dito nakabuo ako ng isang xml file na may napakasimpleng istraktura:

Tawagan natin itong file na data.xml at subukang i-parse ito gamit ang sumusunod na code:

function startElement($parser, $name, $attrs) (
global $depth;echo str_repeat(" ", $depth * 3); // indentation
echo" Elemento: $name
"; // pangalan ng elemento

$depth++; // dagdagan ang lalim upang ang browser ay magpakita ng indentation

xml_set_element_handler($xml_parser, "startElement", "endElement");

kung (!($fp = fopen($file, "r"))) (
die("hindi mabuksan ang XML input");
}

habang ($data = fgets ($fp)) (
kung (!xml_parse ($xml_parser, $data, feof ($fp))) (
echo"
XML Error: ";
echo xml_error_string(xml_get_error_code($xml_parser));
echo " sa linya ".xml_get_current_line_number ($xml_parser);
masira;
}
}

xml_parser_free($xml_parser);
?>

Bilang resulta ng pinakasimpleng script na aming binuo, ipinakita ng browser ang sumusunod na impormasyon sa window nito:

Element: ROOT Element: INFO Attribute: WHO = my Element: ADDRESS Attribute: ULICA = my street!!

Katangian: KVARTIRA = 12 Katangian: DOM = 15 Elemento: TELEPONO Subukan nating sirain ang XML file sa pamamagitan ng pagpapalit ng tag Naka-on

, at iiwan ang pansarang tag na pareho:

Element: ROOT Element: INFO Attribute: WHO = my Element: ADDRESS Attribute: ULICA = my street!!

Katangian: KVARTIRA = 12 Katangian: DOM = 15 Elemento: TELEPHONE

XML Error: Hindi tugmang tag sa linya 5

Wow! Gumagana ang mga mensahe ng error! At medyo nagbibigay-kaalaman.

Eh, isa pa nakalimutan ko... Hindi namin ipinakita ang text na nakapaloob sa loob ng address at mga tag ng telepono. Itinatama namin ang aming pagkukulang - magdagdag ng text handler gamit ang xml_set_character_data_handler function:

xml_set_character_data_handler($xml_parser, 'stringElement');

At idagdag ang mismong handler function sa code:

Ngayon tingnan natin ang output:

Element: ROOT Element: INFO Attribute: WHO = my Element: ADDRESS Attribute: ULICA = my street!!

Attribute: KVARTIRA = 12 Attribute: DOM = 15 String: 123 Element: PHONE String: +71234567890

TUNGKOL SA! Ngayon ang lahat ay inilabas!

Siyanga pala, may nakapansin ba na ang tag at mga pangalan ng katangian ay nakasulat lahat sa malalaking titik? Kakaiba... ang mga ito ay ipinahiwatig sa maliliit na titik sa aming xml file. Tila ang ilang mga setting ay nakatakda sa isang lugar upang gawin ang malalaking titik...

Ahh, nahanap na! Lumalabas na mayroon ding function na xml_parser_set_option:

Sa artikulong ito, tiningnan namin ang pinakasimpleng, ngunit para sa karamihan ng mga gawain, sapat na paraan para sa pagkuha ng impormasyon mula sa mga XML file. Narinig ko rin ang tungkol sa ilang iba pang mas makapangyarihang mga pamamaraan, ngunit isasaalang-alang ko ang mga ito kapag nag-aaral ako ng kaunti sa aking sarili

nika, kailangan mong magsingit ng tawag
xml_set_character_data_handler($xml_parser, 'stringElement');
pagkatapos
xml_set_element_handler($xml_parser, “startElement”, “endElement”);

Sa pangkalahatan, para sa tamang pagpapakita kailangan mong obserbahan ang mga sumusunod:
1. ang xml file ay dapat nasa UTF-8 encoding
2. sa xml file ang unang linya ay dapat na ganito:
< ?xml version="1.0" encoding="UTF-8"?>
3. kailangan mong simulan ang parser tulad nito:
xml_parser_create("UTF-8?);
4. Bago i-output ang mga nilalaman ng xml file sa browser, kailangan mong i-configure ang huli sa UTF-8 encoding:
header(“Uri ng Nilalaman: text/html; charset=utf-8?);

Upang ipakita ang teksto sa Russian ginagamit namin
iconv("UTF-8?,"windows-1251?, $attr), kung saan ang $attr ang kailangang maging output.

Mayroong dalawang kawili-wiling klase sa karaniwang PHP5 library - DOMDocument() at XSLTProcesor() na ginamit ko sa medyo malalaking proyekto - hindi ako nagrereklamo =)

Sa pangkalahatan, ang PHP ay may isa pang library para sa pag-parse ng XML gamit ang prinsipyo ng SAX - tinatawag na XMLReader.

Mga ginoo, paano ako makakapag-output ng mga hindi karaniwang tag mula sa xml gamit ang simplexml, halimbawa?
Ang isang variable tulad ng $text = $item->yandex:full-text ay hindi gumagana.

Ang lahat ay OK, bigyang-pansin lamang ang pagkakaroon ng sumusunod na parameter,

function na cdata($parser, $cdata)
{
var_dump($parser, $cdata);
}

xml_set_character_data_handler($this->parser, “cdata”);

Kung wala ito, ayaw niyang i-parse ang XML sa CDATA.... 1.5 metro ang laki

2Nika, Gumagana lang ang function ng header() kung walang na-output bago ito, ibig sabihin, ito ay ginawa muna, dahil nagpapadala kami ng mga header sa page na ito na nagsasabi sa amin na kailangang i-convert ang text sa UTF-8 encoding. Batay sa iyong error, mayroon kang mga nawawalang linya, kaya gawin itong ganito:

Value == row sequence number
header("Uri ng Nilalaman: text/html; charset=utf-8?); == 2

Ang lahat ay mas simple sa katotohanan
yurban.ru/development/php_xml_parser