Zharoznizhuvalny bērniem ir atzīts par pediatru. Esot radušās neērtas palīdzības situācijas sievietēm ar drudzi, ja bērniem nevainīgi jādod. Todi tētis pārņem drudzi mazinošo zāļu daudzpusību un aizcietējumus. Kā jūs varat dot bērniem krūtis? Kā pārspēt vecāku bērnu temperatūru? Kādi ir labākie?
Noteikti iekļaujiet XML rindu. Tā vietā, lai to atkārtotu ādas dibenā, ielieciet failā veselu rindu, kas ir iekļauta ādas dibenā. Rinda ir iestatīta uz aizskarošu muca. Visbeidzot, jūs varat atvērt XML dokumentu un lasīt to ar tā funkcionalitāti simplexml_load_file ().
Lietojumprogramma Nr. 1 Fails example.php ar XML rindu
$ xmlstr =<<
tse skriptu mova? Viss tiek atvērts veselā dokumentālā filmā,
līdzīga filmai zhakhiv.
XML;
?>
SimpleXML ir vienkāršāks! Mēģiniet ierakstīt vairākas rindas no pamatā esošā XML dokumenta.
Butt # 2 Otrimannya dokumenta daļa
iekļaut "example.php";
echo $ filmas -> filma [0] -> sižets;
?>
Otzhe, tse mova. Tse all one Mova programuvannya. Chi tse skripts mova? Viss atklāsies veselā dokumentālā filmā, līdzīgi kā filmā Žakhivs.
PHP var atjaunot piekļuvi kādam elementam XML dokumentos, lai varētu izmantot nepieņemamos simbolus (piemēram, defisi), novietojot doto elementu pie arkām un apostrofiem.
Muca # 3 Otrimannya rinda
iekļaut "example.php";
atbalss $ filmas -> filma -> ("lieliskās līnijas") -> līnija;
?>
Vikonannya tsyogo muca rezultāts:
PHP parāda visas manas problēmas internetā
Lietojumprogramma Nr. 4 Piekļuve neunikāliem SimpleXML elementiem
Kamēr vienā Batkiv elementā ir neliels meitas elementu kopiju skaits, ir jāizmanto standarta iterācijas metodes.
iekļaut "example.php";
$ filmas = jauns SimpleXMLElement ($ xmlstr);
/ * Ādas mezglam
foreach ($ filmas -> filma -> varoņi -> varonis kā $ varonis) (
echo $ raksturs -> vārds, "graє", $ raksturs -> aktieris, PHP_EOL;
}
?>
Vikonannya tsyogo muca rezultāts:
Jaunkundze. Kodētājs Graє Onlivia Actora Mr. Kodētājs graє El ActÓr
Cieņa:
Jauda ( $ filmas-> filma priekšējā dibenā) nevis є pēc masīviem. Tse ob'єkt, scho іterєatsya, pie viglyadі masīva.
Muca # 5 Vikoristannya atribūti
Dossi mi lishe tika doti elementu nozīmes nosaukums. SimpleXML var arī nodrošināt piekļuvi elementu atribūtiem. Jūs varat apgriezt piekļuvi elementa atribūtam tādā pašā veidā kā pirms elementiem masīvā ( masīvs).
iekļaut "example.php";
$ filmas = jauns SimpleXMLElement ($ xmlstr);
/ * Piekļuve augstskolai
* Tātad atdzīvojas pati vērtējumu skala. * /
foreach ($ filmas -> filma [0] -> novērtējums kā $ vērtējums) (
slēdzis ((string) $ vērtējums ["tips"]) ( // Indeksa elementa Otrimannya atribūti
gadījums "īkšķi":
echo $ reitings, "īkšķi uz augšu";
pārtraukums;
gadījums "zvaigznes":
atbalss $ reitings, "zvaigznes";
pārtraukums;
}
}
?>
Vikonannya tsyogo muca rezultāts:
7 īkšķi — 5 zvaigznes
Butt # 6 Elementu un atribūtu labošana ar tekstu
Lai pielāgotu elementu, vai nu atribūtu pēc kārtas, vai pārsūtītu uz funkciju, piemēram, tekstu, tas ir jāpārvieto uz rindu, (virkne)... Šajā vipad PHP apskatīs jaka objektu.
iekļaut "example.php";
$ filmas = jauns SimpleXMLElement ($ xmlstr);
if ((string) $ filmas -> filma -> nosaukums == "PHP: parādās parsētājs") {
drukāt "Manas mīlestības filmas".;
}
echo htmlentities ((string) $ filmas -> filma -> nosaukums);
?>
Vikonannya tsyogo muca rezultāts:
Mana mīlas filma. PHP: parsētājs izskats
Stock # 7 Porivnyannya divi elementi
Divi elementi SimpleXMLElements vvazayutsya atšķiras, navit ja smaka vazuyut par to pašu objektu, salabo ar PHP 5.2.0.
iekļaut "example.php";
$ filmas1 = jauns SimpleXMLElement ($ xmlstr);
$ filmas2 = jauns SimpleXMLElement ($ xmlstr);
var_dump ($ filmas1 == $ filmas2); // false ar PHP 5.2.0
?>
Vikonannya tsyogo muca rezultāts:
Muca # 8 Vikoristannya XPath
SimpleXML ietver XPath logrīku. Poshuk usih elementi
iekļaut "example.php";
$ filmas = jauns SimpleXMLElement ($ xmlstr);
foreach ($ filmas -> xpath ("// rakstzīme") kā $ rakstzīme) (
echo $ raksturs -> vārds, "graє", $ raksturs -> aktieris, PHP_EOL;
}
?>
"// pasniedz jaku rakstu. Absolūtam maršrutam izlaidiet vienu no sānu rīsiem.
Vikonannya tsyogo muca rezultāts:
Jaunkundze. Kodētājs Graє Onlivia Actora Mr. Kodētājs graє no El ActÓr
Butt # 9 Iestatīt vērtību
SimpleXML nodevas ne vienmēr ir vainīgas, taču tā nav. Ob'єkt ļauj manipulēt ar visiem elementiem.
iekļaut "example.php";
$ filmas = jauns SimpleXMLElement ($ xmlstr);
$ filmas -> filma [0] -> varoņi -> varonis [0] -> nosaukums = "Miss Coder";
echo $ filmas -> asXML ();
?>
Vikonannya tsyogo muca rezultāts:
Butt # 10 Elementu un atribūtu pievienošana
Izlabojams ar PHP 5.1.3, SimpleXML var viegli pievienot meitas elementus un atribūtus.
iekļaut "example.php";
$ filmas = jauns SimpleXMLElement ($ xmlstr);
$ raksturs = $ filmas -> filma [0] -> rakstzīmes -> addChild ("rakstzīme");
$ rakstzīme -> addChild ("vārds", "Mr. Parser");
$ raksturs -> addChild ("aktieris", "Džons Doe");
$ vērtējums = $ filmas -> filma [0] -> addChild ("vērtējums", "PG");
$ vērtējums -> addAttribute ("tips", "mpaa");
echo $ filmas -> asXML ();
?>
Vikonannya tsyogo muca rezultāts:
Butt # 11 Vzaєmodiya s DOM
PHP var konvertēt XML no SimpleXML uz DOM un Navpacks. Ļaujiet man jums parādīt, kā jūs varat mainīt DOM elementu no SimpleXML.
$ dom = jauns DOMDocument;
$ dom -> loadXML ( "
if (! $ dom) (
atbalss "Atvainojiet, kārtojot dokumentu";
Izeja;
}
$ grāmatas = simplexml_import_dom ($ dom);
echo $ grāmatas -> grāmata [0] -> nosaukums;
?>
Vikonannya tsyogo muca rezultāts:
pirms 4 gadiem
Tse ir spilgts "triks", kas ir savienojums, lai pārrakstītu SimpleXML objektu masīvā, izmantojot json_encode () un json_decode (). Es vēlētos paskaidrot, kāpēc tā ir slikta ideja.
Vienkāršāk, jo SimpleXML galvenais mērķis ir būt vieglāk lietojamam un jaudīgākam nekā vienkāršam masīvam. Piemēram, varat rediģētbar -> baz ["bing"]?> un tas nozīmē to pašu, kobārs [0] -> baz [0] ["bing"]? un ja tu rakstibar [0] -> baz [0]?> Varat izdrukāt visu šī mezgla virknes saturu, ieskaitot CDATA sadaļas, neatkarīgi no tā, vai tajā ir arī pakārtotie elementi vai atribūti. Varat arī nodrošināt piekļuvi nosaukumvietas informācijai, tieši rediģēt XML un doties uz "importēt" DOM objektā, lai veiktu papildu darbu. Tas pats objekts masīvā, nevis lasīšana, lai saprastu šīs lapas piemērus.
Dodatkovo, tāpēc tas nav sadalīts nevienam nolūkam, pārveidojot uz JSON un atpakaļ, informācija tiks izmantota dažos veidos. Papildinājumam, vai tas būtu elements vai apzīmējumi nosaukumu telpā, būs sutta, bet tas tiks publicēts, un vai tas būtu teksts, tas būs redzams kā elements, kāds tas var šķist bērniem vai atribūtiem. Dienas stunda, tse būs mater, ale, redzi, pa vidu visu pārvērš, apēd, turpini, kamēr aizies.
Kursa gaitā jūs varat paātrināt viedāku konvertēšanu, apstiprinot apmaiņu, bet, ja SimpleXML nemaz neinstalējat, funkcijām ir jāizmanto uzlabotā XML struktūra, piemēram, XMLReader vai savs XMLReader. struktūra. SimpleXML nevajadzīgās funkcionalitātes dēļ neliels zaudējums.
Pirms 2 gadiem
Tā kā jūsu xml virknē ir ietverti būla signāli no "0" un "1", jūs radīsit problēmas, ja elementu apraidīsit tieši uz bool:
$ xmlstr =<<
XML;
$ vērtības = jauns SimpleXMLElement ($ xmlstr);
$ truevalue = (bool) $ vērtības-> truevalue; // taisnība
$ falsevalue = (bool) $ vērtības-> falsevalue; // arī taisnība!
Tā vietā vispirms ir jāveic apraide uz virkni vai int:
$ truevalue = (bool) (int) $ vērtības-> truevalue; // taisnība
$ falsevalue = (bool) (int) $ vērtības-> falsevalue; // viltus
9 rockiv uz to
Ja vēlaties rediģēt savam skatam pareizo xml, jūs nevarat rediģēt savu profilu, nevis xml pievienojumprogrammā pirms asXML () rezultāta ievadīšanas:
$ xml = simplexml_load_file ("...");
...
... xml sīkumi
...
// izvadiet xml savā atbildē:
galvene ("Satura veids: teksts / xml");
echo $ xml -> asXML ();
?>
9 rockiv uz to
No README faila:
SimpleXML ir metode, lai rediģētu piekļuvi XML datiem.
SimpleXML objekti ievēro četrus pamatnoteikumus:
1) īpašības apzīmē elementu iteratorus
2) ciparu indeksi apzīmē elementus
3) neskaitliskie indeksi apzīmē atribūtus
4) virknes konvertēšana ļauj piekļūt TEKSTA datiem
Tiklīdz ir spēks, tā smirdoņa turpinās un vēl vairāk
visi mezgli ar šo elementa nosaukumu. Tādējādi metode bērniem () jābūt
izsaukts iterācijai pa apakšmezgliem. Ale arī baidās no cenas:
foreach ($ obj-> node_name jaks $ elem) (
// dariet kaut ko ar $ elem
}
visi rada elementu "node_name" iterāciju. Tātad tālāk nav
pārbaude ir nepieciešama, lai atšķirtu šāda veida mezglu skaitu.
Kad elementam TEXT datiem tiek piekļūts, izmantojot īpašumu
Rezultāti neietver apakšelementu TEXT datus.
Zināmas problēmas
============
Motora problēmu dēļ pašlaik nav iespējams piekļūt
apakšelements pēc indeksa 0: $ objekts-> rekvizīts.
8 rockyv that
Vikoristovuyuchi sāk novērtēt: is_object ($ xml-> module-> admin) konvertēšanai, ja є ar numuru "admin", jūs nevarat veikt darbu, kā paredzēts, jo simplexml var arī atjaunināt, ja tas ir tukšs - pat ja konkrēts mezgls nav іsnuє.
Man šķiet, ka vecā tukšā () funkcija šādos gadījumos ir lieliski piemērota robotiem.
8 rockyv that
Ātrs padoms par xpath vaicājumiem un noklusējuma nosaukumvietām. Šķiet, ka XML sistēmai aiz SimpleXML ir tāda pati darbība, kādu, manuprāt, izmanto XML sistēma .NET: ja ir jārisina kaut kas noklusējuma nosaukumvietā, nosaukumvieta būs jādeklarē, izmantojot registerXPathNamespace, un pēc tam jāadresē tā pēc noklusējuma. vārda telpas dzīvais elements.
$ virkne =<<
Es zinu, ka tā ir atbilde - ale kāds ir jautājums?
XML;
$ xml = simplexml_load_string ($ virkne);
$ xml -> registerXPathNamespace ("def", "http://www.w3.org/2005/Atom");
$ mezgli = $ xml -> xpath ("// def: document / def: title");
?>
9 rockiv uz to
Tā kā SimpleXMLElement tiek apgalvots, ka tas ir iterējams, jūs nevarat ieviest standarta iteratora saskarnes funkcijas, piemēram, :: next un :: pareizi atiestatīt. Ņemiet vērā: ja roboti darbotos (), funkcijas, piemēram, nākamais (), pašreizējais () vai visas (), piemēram, nākamais (), pašreizējais () vai visi (), piemēram, robots, tāpat kā jūs sagaidīt - tad, ja sistēma nav droša, jūs pārvietosities vai atiestatīsit.
6 rockiv uz to
Kad XML dokuments ir kodēts, tas tiek renderēts UTF-8, bet, ja kods nav kodēts, ierakstiet versija = "..." un pirms standalone = "...". Tse vimoga uz XML standartu.
Man saka, ka XML dokuments atšķiras no UTF-8. Parādīts reizēm vainīgs prodovzhuvatisya reiz rakstiska versija = "..." un līdz standalone = "...". Tsey vimoga є XML standarts.
Labi
Apžēlošanas trūkums: Necienīgs visnovok "Izņēmums" ar ziņojumu "...
XML parsēšana pēc būtības nozīmē XML dokumenta izpēti un datu apvēršanu. Es gribu visu vairāk numuru Tīmekļa pakalpojumi rotē datus JSON formātā, bet arvien vairāk XML, ir svarīgi iemācīties parsēt XML, ja vēlaties uzzināt visu pieejamo API saskarņu klāstu.
Vikoristovuchi paplašināšana SimpleXML Izmantojot PHP, kā tas tika pievienots PHP 5.0, XML apstrāde ir tikpat vienkārša, cik vien iespējams. Raksta augšdaļā es jums parādīšu, kā tas darbojas.
vikorystannya pamati
Ņemsim ātri dumpu valodas.xml:
>
>
>
>
Tsei XML-dokuments, lai uzskaitītu programmas programmu sarakstu ar deyako informāciju par ādas tulkojumu: rik її realizatsії un іm'ya її veidotājs.
Pirmā Croc polyagaє bloķētajā XML ar uzvarošajām funkcijām abo simplexml_load_file (), abo simplexml_load_string ()... Varat redzēt funkcijas nosaukumu, failam var pievienot XML, bet otrs ir pievienot failam XML.
Nobīdes funkcijas Izlasiet visu DOM koku, lai uzminētu, un pagrieziet objektu SimpleXMLElement... Pie smailā skata objekts tiek ņemts vērā $ valodās. Jūs varat vikoristovuvati funkcijas var_dump () abo print_r (), vienkārši uztaisi atskaiti par informāciju par objekta pagriezieniem, ja vēlies.
SimpleXMLElement objekts
[lang] => Masīvs
[0] => SimpleXMLElement objekts
[@attributes] => Masīvs
[vārds] => C
[parādījās] => 1972. gads
[radītājs] => Deniss Ričijs
[1] => SimpleXMLElement objekts
[@attributes] => Masīvs
[vārds] => PHP
[parādījās] => 1995. gads
[radītājs] => Rasmuss Lerdorfs
[2] => SimpleXMLElement objekts
[@attributes] => Masīvs
[vārds] => Java
[parādījās] => 1995. gads
[radītājs] => Džeimss Goslings
)
)
Tsey XML atriebties saknes elementam valodas, kura vidū ir trīs elementi lang.Ādas elements dažādiem skatiem lang XML dokumentiem.
Jūs varat nodrošināt piekļuvi objekta iestādei operatora palīdzībai -> ... Piemēram, $ languages-> lang liks jums SimpleXMLElement objektu, kas parādīs pirmo elementu lang... Tsey ob'єkt atriebties abām iestādēm: parādījās un radītājs.
$ valodas -> lang [0] -> parādījās;
$ valodas -> lang [0] -> veidotājs;
Movu saraksta parādīšana un to jaudas parādīšana ekrānā var būt daudz vienkāršāka, izmantojot standarta ciklu, piemēram, katram.
foreach ($ valodas -> lang kā $ lang) (
printf (
""
,
$lang ["vārds"],
$lang -> parādījās,
$ lang -> veidotājs
)
;
}
Cieņas zvērs, tā kā esmu noņēmis piekļuvi elementa lang atribūtam imeni, es to saukšu par movi. Izmantojot šo rangu, varat rediģēt piekļuvi jebkuram elementa atribūtam, kas attēlots SimpleXMLElement objekta skatā.
Robots imen plašumos
Tā ir robotikas stunda no jaunāko tīmekļa pakalpojumu XML, un jūs atkārtoti apmeklēsit elementu plašumu. Ņemsim mūsu valodas.xml, parādiet vikoristanjas dibenu vārda plašumam:
xmlns: dc =>
>
>
>
>
Tagad elements radītājs atriebties vīriešu plašumos dc Es to rezervēšu vietnē http://purl.org/dc/elements/1.1/. Tiklīdz jūs mēģināt atšifrēt gājiena veidotājus, mūsu pirmais kods ir uzvarošs, tas nav pareizi. Lai izlasītu elementu plašumu, jums jāizvēlas viena no nākamajām darbībām.
Pirmā pidhid polyagaє pie URI Viktorijas nosaukuma neatrodas vidū pie koda, ja dzīvnieks ir līdz elementa nosaukuma plašumam. Uzbrūkošajā dibenā tiek parādīts, kā mērķēt:
$ dc = $ valodas -> lang [1] -> bērni ( "http://purl.org/dc/elements/1.1/")
;
atbalss $ dc -> veidotājs;
Metode bērni () paņemiet vārda vietu un pagrieziet meitas elementus, kas tiek laboti no prefiksa. Es pieņemu divus argumentus, kas ir pirmie XML nosaukumu plašajā, un vēl vienu neobligātu argumentu, piemēram, ceļu nosaukumiem viltus... Cits arguments ir iestatīts kā TRUE, vārda atstarpe tiek parādīta kā prefikss. FALSE, vārdu telpa tiks parādīta kā vietrāža URL nosaukumi.
Vēl viena lauka zīme ir URI nosaukumu nolasīšana no dokumenta, kas ir elementu nosaukumu reģistrācija. Lai iegūtu labāko veidu, kā piekļūt vienumiem, jūs neesat vainīgs, ka esat saistīts ar URI.
$ namespaces = $ valodas -> getNamespaces (true);
$ dc = $ valodas -> lang [1] -> bērni ($ nosaukumvietas ["dc"]);
atbalss $ dc -> veidotājs;
Metode GetNamespaces () pagrieziet prefiksu nosaukumu masīvu un piešķiriet tiem URI. Win ir papildu parametrs, kas paredzēts izmantotajiem ceļiem viltus... Yaksho vi piecelties jogo jaks taisnība, tad visa metode, kā apgriezt nosaukumu, kā kļūt par uzvarētāju Batkivas un meitas augstskolās. Jo іnshomu vypadku, es zinu plašumu vīriešiem, jo vikoristovyutsya atņemšanu Batkiv universitātē.
Tagad jūs varat pārlūkot movu sarakstu ar šādu rangu:
$ valodas = simplexml_load_file ("languages.xml");
$ ns = $ valodas -> getNamespaces (true);
foreach ($ valodas -> lang kā $ lang) (
$ dc = $ lang -> bērni ($ ns ["dc"]);
printf (
"
% s ir parādījies % d un % s ir to izslēdzis.
" ,$lang ["vārds"],
$lang -> parādījās,
$ dc -> veidotājs
) ;
}
Praktisks dibens — video kanāla parsēšana no YouTube
Apskatīsim apakšējo daļu, kurā tiks parādīta RSS plūsma no YouTube kanāla, kurā tiks parādīti visi videoklipi. Visiem ir jāgriežas pēc aizskarošās adreses:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
URL pagrieza atlikušo video kanālu sarakstu XML formātā. Varēšu tvaicēt XML un pieņemt informāciju skina video:
- Video iespēja
- Miniatūra
- Vārds
Joka pēc XML ir bojāts:
$ kanāls = "ime_channel";
$ url = "http://gdata.youtube.com/feeds/api/users/"... $ kanāls. "/ augšupielādes";
$ xml = file_get_contents ($ url);
$ padeve = simplexml_load_string ($ xml);
$ ns = $ plūsma -> getNameSpaces (true);
Yaksho vi apbrīnojiet XML plūsmu, jūs varat malkot, tur ir daži elementi entītija, ziņošu par konkrētu video no kanāla. Ale mi vikoristovuєmo atņem miniatūru attēlu, nosaukšu video adresi. Trīs elementi є elementu vietas grupai, piemēram, pie sava velna, є meita par ierakstu:
…
…
…
>
…
Mēs vienkārši izstaigājam visus elementus ierakstu, un informācija no viņiem ir ļoti svarīga. Brutalizēt cieņu, scho spēlētājs, sīktēlsі virsraksts atrasties plašsaziņas līdzekļu atklātā telpā. Tādā rangā, mi maєmo dyati, jaks pie priekšējā muca. Mēs varam atpazīt dokumenta nosaukumu un nosaukuma apburto vietu, kad tas tiek pārvērsts par elementiem.
foreach ($ feed -> ieraksts kā $ ieraksts) (
$ grupa = $ ieraksts -> bērni ($ ns ["media"]);
$ grupa = $ grupa -> grupa;
$ thumbnail_attrs = $ grupa -> sīktēls [1] -> atribūti ();
$ attēls = $ thumbnail_attrs ["url"];
$ spēlētājs = $ grupa -> spēlētājs -> atribūti ();
$ saite = $ atskaņotājs ["url"];
$ virsraksts = $ grupa -> nosaukums;
printf ( "
$ atskaņotājs, $ attēls, $ virsraksts);
}
Višnovoka
Tagad, ja jūs zināt, jaku vikoristovuvati SimpleXML Lai analizētu XML datus, varat pielāgot savus pielāgojumus, analizējot XML plūsmas ar dažādām API. Ir svarīgi zināt, ka SimpleXML nolasa visu DOM atmiņā, ja jūs parsējat lielu datu kopu, varat pazust atmiņā. Lai uzzinātu vairāk par SimpleXML, izlasiet dokumentus.
Ja ietur maltīti, ieteicams steigties pie mums
Jūs varat inficēties ar XML robotu. XML ir tse formāts datu apmaiņai starp vietnēm. Tas ir pat līdzīgs HTML, tikai XML ir atļauti savi tagi un atribūti.
Vai parsēšanai nepieciešams XML? Inodі buvaє tātad, kāda vietne, kas prasa skopumu, ir API, ar kuras palīdzību var apstrādāt bazhanus, īpaši nestresot. Tas ir uzreiz priecīgs - pirms komandas, kā parsēt vietni, mainiet to, kas trūkst API.
Kas ir API? Ir vairākas funkcijas, ar kuru papildu palīdzību jūs varat piegādāt strāvu visai vietnei un noņemt pieprasījumu no saraksta. Visticamāk, ass atbilst XML formātam. Turpināsim ar to pirms grūtniecības iestāšanās.
PHP XML robots
Iegūstiet to XML formātā. To var atrast pēc kārtas, to var saglabāt no faila, vai arī to var skatīt saglabātā URL.
Ļaujiet XML atgriezties malā. Lai iegūtu plašu rindu klāstu, jums ir jāatver objekts, lai saņemtu palīdzību Jauns SimpleXMLElement:
$ str = "
Infekcija ir pie mums $ xml Iegūstiet XML failu no rosibranim. Zvertayuchis līdz iestādēm visa objekta, jūs varat rediģēt piekļuvi XML tagus vietā. Jak sama - paņem troču zemāk.
Kā XML var saglabāt no faila vai tas izskatās kā URL (kas ir visizplatītākais), kam seko funkcija simplexml_load_file jaku, lai aplaupītu to pašu objektu $ xml:
$ xml = simplexml_load_file (dodieties uz failu abo url);
Priyomi roboti
Zemāk esošajās daļās mūsu XML tiek saglabāts failā vai URL.
Nāc, ņemot vērā aizskarošo XML:
Atņemsim brigadieru algu:
$ xml = simplexml_load_file (dodieties uz failu abo url); echo $ xml-> nosaukums; // vivede "Kolya" echo $ xml-> vecums; // sieva 25 echo $ xml-> alga; // Vivede 1000
Yak vi bachite, ob'єkt $ xml maє vlastivostі, scho displeja tagus.
Var brutalizēt uvagu, u tag
$ xml = simplexml_load_file (dodieties uz failu abo url); echo $ xml-> nosaukums; // vivede "Kolya" echo $ xml-> vecums; // sieva 25 echo $ xml-> alga; // Vivede 1000
XML var būt tikai viens saknes tags, tāpēc tas ir kā tags stilīgā HTML.
Modificēsim savu XML trīs reizes:
Mums ir daudz vipadku mums ir lantsyuzhok zvērs:
$ xml = simplexml_load_file (dodieties uz failu abo url); echo $ xml-> darbinieks-> vārds; // vivede "Kolya" echo $ xml-> strādnieks-> vecums; // vivede 25 echo $ xml-> strādnieks-> alga; // Vivede 1000
Robots ar atribūtiem
Neuztraucieties par to, ka dati tiek saglabāti atribūtos:
$ xml = simplexml_load_file (dodieties uz failu abo url); echo $ xml-> darbinieks ["vārds"]; // vivede "Kolya" echo $ xml-> darbinieks ["vecums"]; // sieva 25 echo $ xml-> strādnieks ["alga"]; // Vivede 1000 echo $ xml-> darbinieks; // sieva "Numurs 1"
Definētie tagi
XML atļāva tagus (kas atribūti) ar defisi. Dienas beigās šādas atzīmes tiek parādītas šādi:
$ xml = simplexml_load_file (dodieties uz failu abo url); echo $ xml-> darbinieks -> (vārds); // vivede "Kolya" echo $ xml-> darbinieks -> (uzvārds); // Vivede "Ivanovs"
Pārmērīgs cikls
Tagad mums ir ne tikai viens robots, bet arī mazs. Mēs to varam izdarīt, novietojot objektu aiz papildu foreach cilpas:
$ xml = simplexml_load_file (dodieties uz failu abo url); foreach ($ xml kā $ darbinieks) (echo $ worker-> name; // vivede "Kolya", "Vasya", "Petya")
Z ob'єkta uz parasto masīvu
Ja jūs nezināt, kā to izdarīt ar objektu, varat to pārveidot par parastu PHP masīvu, izmantojot aizskarošu viltīgu triku:
$ xml = simplexml_load_file (dodieties uz failu abo url); var_dump (json_decode (json_encode ($ xml), true));
Vairāk informācijas
Parsēšana, pamatojoties uz sitemap.xml
Visbiežāk vietnē ir fails sitemap.xml. Visi faili tiek ņemti vērā visās vietnes pusēs, lai nodrošinātu skaņu sistēmu indeksēšanas efektivitāti (indeksēšana - vienlaikus un vietnes parsēšana, ko veic Yandex un Google).
Mēs neesam vainīgi hvilyuvati, lielāko daļu laika viņi izmanto failu, smuku, esmu pārliecināts, ka viss ir kārtībā - jūs nevarat kāpt pa vietnes malām, izmantojot dažas viltīgas metodes, bet vienkārši paātrināt failu.
Kā saskaņot šī faila izskatu: vai mēs neparsējam vietni site.ru, lai atgrieztos pārlūkprogrammā līdz vietnei site.ru/sitemap.xml - ja vēlaties to iedurt, tas nozīmē, ka tas ir tur, bet, ja jūs nedari to, tad žēl.
Kā vietnes karte - tad jaunajā būs atbilde uz visiem vietnes aspektiem XML formātā. Spooky paņemiet XML, parsējiet to, skatiet to, kas jums nepieciešams, lai tas būtu jums ērtā veidā (piemēram, analizējot URL, piemēram, Pavuk metodes aprakstu).
Rezultātos jūs izveidosit parsēšanas instrukciju sarakstu, jums būs jādodas uz tiem un jāizveido nepieciešamais saturs.
Izlasiet pārskatu par sitemap.xml pievienošanu vietnes kartē.
Kas jums ir dots:
Labojiet problēmas risināšanu nākamajam solim: strādājiet pirms nodarbības.
Ja visu izdarīsi, dodies uz jaunajiem.
XML formatējuma izstrāde є noteikumu kopums dokumentu kodēšanai mašīnlasāmās formās. XML ir populārs formāts datu apmaiņai internetā. Vietnes, kas bieži atjaunina savu saturu, piemēram, jaunas vietnes un emuāri, bieži izveido XML kanālu, tāpēc tās izsauc programmas, kuru saturs tiek mainīts. XML-atzinību uzraudzība un izplatīšana sociālajiem darbiniekiem programmām ar izgriezumiem. Es paskaidrošu šo nodarbību, kā viconati rozbіr XML dokumentus un vicoristovuvati їkh danі.
Sintakses analizatora vibrācija
Kanālu analīze
Pirmais krokuss pie uztveršanas kanālam є lēmums par tiem, kas atrodas datu laukos. Iepriekš iestatīto lauku analizators un ignorē visu.
Ass ir kanāla fragments, ko programmas var paņemt no dibena. Neliels ieraksts vietnē StackOverflow.com ir kanālā kā ieraksta atzīme, kas ir paredzēta, lai atriebtos par ligzdotajiem tagiem:
Man ir lietojumprogramma, kurai nepieciešams datu fails...
Lietojumprogrammas vityaguє dati no ievades taga vienā un tajā pašā ligzdoto tagu virsraksta, saites un kopsavilkuma.
Sintakses analizatora gadījums
Soli pa solim є sintakses analizatora instances stumbrs un analīzes procesa palaišana. Daudzos fragmentos analizatoram jāsāk to darīt, lai nesabojātu nosaukumu vietu, kā arī uztvertu InputStream ziņojumus kā ievades datus. Analīzes process tiek palaists pēc nextTag () un readFeed () metodes, kas tiek izmantota datu apstrādei, šādās saitēs:
Publiskā klase StackOverflowXmlParser (// Mēs neizmantojam nosaukumvietas privāto statisko galīgo String ns = null; publiskā saraksta parsēšana (InputStream in) izmet XmlPullParserException, IOException (mēģiniet (XmlPullParser parser = Xml.newPullParser ()), false), parser.setInput (in, null);parser.nextTag ();atgriezt readFeed (parsētājs);
Vidnimati kanāls
ReadFeed () metode, lai aplaupītu faktisko robotu no kanāla apstrādes. Vienumi, kas apzīmēti ar tagu "Entry" є kanāla rekursīvas apstrādes augšējais punkts. Tiklīdz nākamais tags neievada tagu, tas tiek izlaists. Turklāt, tā kā visa "rinda" ir rekursīvi šķeldota, readFeed () pagriež sarakstu, kas atklāj ierakstus (tostarp elementu ieguldījumu), tiem ejot caur kanālu. Laika sarakstu var pārvērst analizators.
Privātā saraksta readFeed (XmlPullParser parsētājs) izmet XmlPullParserException, IOException (saraksta ieraksti = jauns ArrayList (); parser.require (XmlPullParser.START_TAG, ns, "feed"); while (parser.next ()! = Xml (parser.EventTAG) ! = XmlPullParser.START_TAG) (turpināt;) Virknes nosaukums = parser.getName (); readEntry (parsētājs));) else (izlaist (parsētājs);)) atgriež ierakstus;
Rozbir XML
Kroki XML kanāla parsēšanai:
Es jums parādīšu fragmentu, piemēram, analizatoru, lai analizētu ierakstu, nosaukumu, saiti un kopsavilkumu.
Publiskā statiskā klase Ieraksts (publisks galīgais Virknes nosaukums; publiska gala virknes saite; publiska gala virknes kopsavilkums; privāts ieraksts (virknes nosaukums, virknes kopsavilkums, virknes saite) (;)) // Parsē ieraksta saturu. Tas attiecas tikai uz visiem ierakstiem, kopsavilkums vai saites tags, nodod tos // savām lasīšanas metodēm šim procesam. Іншіwise, izlaiž atzīmi. privātā ieraksta lasīšanas ieraksts (XmlPullParser parsētājs) izmet XmlPullParserException, IOException (parser.require (XmlPullParser.START_TAG, ns, "entry"); Virknes nosaukums = null; Virknes kopsavilkums = null; Virknes saite = null; while = XmlPullParser) (if.END_TAG) (parser.getEventType ()! = XmlPullParser.START_TAG) (turpināt;) Virknes nosaukums = parser.getName (); if (name.equals ("nosaukums")) (nosaukums = readTitle (parsētājs);) else if (nosaukums. vienāds ("kopsavilkums")) (kopsavilkums = readSummary (parsētājs);) else if (nosaukums.vienāds ("saite")) (saite = readLink (parser);) else (izlaist (parsētājs);)) return new Entry ( virsraksts, kopsavilkums, saite); ) // Apstrādā virsrakstu tagus plūsmā. Privātā virkne readTitle (XmlPullParser parsētājs) izmet IOException, XmlPullParserException (parser.require (XmlPullParser.START_TAG, ns, "title"); String title = readText (parser); parser.require (XmlPullParser.END_TAG) atgriež saiti virsraksta tagus. barībā. privātā String readLink (XmlPullParser parsētājs) izmet IOException, XmlPullParserException (String saite = ""; parser.require (XmlPullParser.START_TAG, ns, "link"); String tag = parser.getName (); String relType = parser.getAttribu, " rel "); ) parser.require (XmlPullParser.END_TAG, ns, "saite"); atgriešanas saite; ) // Apstrādā kopsavilkuma tagus plūsmā. private String readSummary (XmlPullParser parser) izmet IOException, XmlPullParserException (parser.require (XmlPullParser.START_TAG, ns, "summary"); String summary = readText (parser); parser.require (XmlPullParser; atgriež kopsavilkuma nosaukumu un kopsavilkumu); , izvelk to teksta vērtības.private String readText (XmlPullParser parser) izmet IOException, XmlPullParserException (String rezultāts = ""; if (parser.next () == XmlPullParser.TEXT) (rezultāts = parser.getText (); parser. nextTag () ;)) atgriezt rezultātu;) ...)
Nevajadzīgo elementu pārsūtīšana
Viens no aprakstītās vishche XML analīzes krokiem, sintaktiskais analizators izlaiž tagus, kas nav norādīti. Tālāk ir norādīts sintakses analizatora izlaišanas () metodes kods:
Privātā saite (XmlPullParser parsētājs) izmet XmlPullParserException, IOException (if (parser.getEventType ()! = XmlPullParser.START_TAG) (izmet jaunu IllegalStateException ();) int dziļums = 1; while (novecojis nextParser. case- Xml_ENDTAG); dziļums- Xml_ENDTAG; case XmlPullParser.START_TAG: dziļums ++; pārtraukums;)))
Ass jaks tse pratsyuє:
- Vinješu ģenerēšanas metode, ja process nav START_TAG.
- Vins ir apmierināts ar START_TAG un visiem iesniegtajiem materiāliem līdz pat END_TAG.
- Apgrozot, jums vajadzētu būt iespējai izmantot pareizo END_TAG, nevis oriģinālā START_TAG pirmo vizuālo tagu, kas parādīs ieguldījuma summu.
Šādā rangā, jo pašreizējam elementam nav nozīmes, dziļuma vērtība nebūs 0, kamēr analizators nebūs apstrādājis visus apakšsadaļas ar sākotnējo START_TAG un to pašu END_TAG. Piemēram, ir iespējams redzēt caurlaides analizatoru
- Pirmajā izejā caur while cilpu nākamais tags, kas ir instrumenta analizators
tse START_TAG priekš - Otrai cilpai cauri ir sākuma tags, kas ir analizators, un END_TAG
- Trešajā izejā caur while cilpu aizskarošais tags, kas ir analizators, START_TAG
... Dziļuma vērtību var palielināt līdz 2. - Ceturtdaļas iet caur while cilpu, aizskarošu tagu, kas ir analizators, END_TAG... Dziļuma vērtība samazinās līdz 1.
- Procesa beigās tiek veikta pēdējā cilpa while, aizskarošais tags, kas ir analizators, END_TAG... Dziļuma vērtība tiek samazināta līdz 0, kas norāda tos, kuri
elements buv veiksmīgi garām.
XML apstrāde Danih
Lietojumprogramma ieprogrammēs AsyncTask XML kanāla apstrādi un analīzi. Pozas apstrāde ir galvenā plūsma uz koristuvach saskarni. Ja apstrāde ir pabeigta, programma atjauninās galvenās darbības (NetworkActivity) taustiņsitiena saskarni.
Fragmentam, kas atrodas zemāk, ir metode loadPage (), lai pārtrauktu darbību:
- Ievadiet virkni ar URL vērtībām un pēc tam norādiet uz XML plūsmu.
- Kā iestatīt koristuvacha un izveidot savienojumu ar atļauto modeli, wiklickє New DownloadXmlTask (). Izpildīt (url). Jauns DownloadXmlTask objekts (AsyncTask pidclass) un viconious execute () metode, kas bloķēs un analizēs kanālu un pagriezīs rindas rezultātu, kas tiks parādīts lietotāja saskarnē.
- doInBackground () visonє metode loadXmlFromNetwork (). Win ir kanāla URL kā parametrs. Metode loadXmlFromNetwork () atmet apstrādāto kanālu. Ja pabeigšu apstrādi, iegūto rindu pārsūtīšu atpakaļ.
- onPostExecute () pieņem rindas rotāciju un atveido to rindas saskarnē.
Zemāk ir novietota kursora metode loadXmlFromNetwork (), kuru var savienot no DownloadXmlTask. Uzvarēt aplaupīšanu šādi:
- Es pametu StackOverflowXmlParser gadījumu. Win arī atvērt izmaiņas saraksta ierakstu objektiem (ierakstiem), nosaukumam, URL un kopsavilkumam, lai saglabātu vērtību, ko izmanto XML kanālā, vairākiem laukiem.
- Viklikaє downloadUrl (), kas bloķēs kanālu un pagriezīs InputStream.
- Vikoristovє StackOverflowXmlParser, lai parsētu InputStream. StackOverflowXmlParser saglabās saraksta ierakstus ar kanāla datiem.
- Ierakstu saraksta rediģēšana un pievienošana kanālam ar HTML formatējumu.
- Pagriež HTML rindu, kas tiek parādīta galvassāpju saskarnē, AsyncTask ar onPostExecute () metodi.
"+ getResources (). getString (R.string.page_title) +"
"); htmlString.append (" + getResources (). getString (R.string.updated) + "" + formatter.format (rightNow.getTime ()) + ""); (stream.close ();)) // StackOverflowXmlParser atgriež ierakstu objektu sarakstu (saukti par" ierakstiem "). // Katrs ieraksta objekts XML plūsmā attēlo vienu ziņu. // Ieviests ar HTML tagiem."+ ieraksts.nosaukums +"
"); // Ja lietotājs iestatījis preferenci iekļaut kopsavilkuma tekstu, // pievieno to displejam. If (pref) (htmlString.append (entry.summary);)) atgriež htmlString.toString ();) // Ja ir norādīta URL virkne, izveidojiet savienojumu un // iegūstiet ievadi stream.conn.setReadTimeout (10000 / * milisekundes * /); conn.setConnectTimeout (15000 / * milisekundes * /); conn.setRequestMethod ("GET") ; conn .setDoInput (true); // Sāk vaicājumu conn.connect (); atgriezties conn.getInputStream ();Statūtu publicēšanai atļauts atņemt atļauju statti autora vietnei
Uz ts_y statty es tēmēšu uz dibena, jo es izveidošu lielisku XML failu. Ja serveris (hostings) nav rūdīts ilgāk par stundu skripta robotiem, tad XML failu vari kārtot pats, ja gribi gigabaitus, pats vari uzņemt tikai 450 megabaitus ozona.
Parsējot lieliskus XML failus, rodas divas problēmas:
1. Laulības atmiņa.
2. Redzētās stundas trūkums robota skriptam.
Vēl viena problēma var tikt pārkāpta stundas laikā, jo serveris nav nocietināts.
Un vīrusa atmiņas problēmas ass ir viegli orientējama, ja runa ir par jūsu serveri, tad 500 megabaitu failu pagriešana nav tik vienkārša, un pat hostingā un VDS atmiņu vienkārši nevar saglabāt. .
PHP ir neliels skaits XML apstrādes iespēju - SimpleXML, DOM, SAX.
Visas iespējas ir aprakstītas rakstos ar dibeniem, bet robotam var demonstrēt ar XML dokumentu.
Pirmā ass no pielikuma, mēs to varam atpazīt no XML faila
Tagad jūs varat atbrīvoties no objekta, ALE ...
Kā redzat, viss XML fails tiek nolasīts mīklai, pēc tam viss tiek sakārtots objektā.
Tātad visas dejas izmanto atmiņa, un, ja ar redzēto atmiņu nepietiek, tad scenārijs apstāsies.
Lai apstrādātu lieliskus failus, šāda iespēja nenāk, ir jālasa fails pēc kārtas un jāapstrādā dati atbilstoši savām vajadzībām.
Tajā pašā laikā datu apstrādes pasaulē pārveide uz derīgumu ir tik laba, ka ir nepieciešama iespēja parādīt, piemēram, lai redzētu visus datubāzē ievadītos datus no nederīga XML faila vai lasīt divi fragmenti caur failu obrob danikh.
Axis teorētiskais pielietojums liela XML faila analīzei.
Viss skripts no faila nolasa vienu rakstzīmi, paņem datus pirms blokiem un pārsūta, pirms tiek parsēts XML.
Šāda veida iemesls radīs atmiņas problēmu, nevis darba izpildes problēmu, bet gan stundu problēmu. Jaku sprobuvati virishiti problēma stundu, lasiet zemāk.
Funkcija webi_xml ($ fails)
{
########
### roboti darbojas ar datiem
{
drukāt $ datus;
}
############################################
{
drukāt $ nosaukumu;
print_r ($ attrs);
}
izliekto tagu funkcija
funkcija endElement ($ parsētājs, $ nosaukums)
{
drukāt $ nosaukumu;
}
############################################
($ xml_parser, "dati");
// atver failu
$ fp = fopen ($ fails, "r");
$ perviy_vxod = 1; $ dati = "";
{
$ simvol = fgetc ($ fp); $ dati. = $ simvol;
if ($ simvol! = ">") (turpināt;)
atbalss"
pārtraukums;
}
$ dati = "";
}
fclose ($ fp);
Webi_xml ("1.xml");
?>
Pašā apakšā visu redzu vienā funkcijā webi_xml () un pašā apakšā її wiklik.
Pats skripts sastāv no trim galvenajām funkcijām:
1. Funkcija, kā noķert startElement () tagu displeju
2. Funkcija, kā noķert endElement () taga noslēgumu
3. Pirmā datu noraidīšanas funkcija ir dati ().
Domājams, 1.xml faila vietā kā recepte
<
title
>Prosty hlib
<
ingredient amount
=
"3"
unit
=
"стакан"
>Boroshno
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>Дріжі
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>Silts ūdens
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>Sil
<
instructions
>
<
step
>
Zmіshati visi Ingredієnti un retelno zamіsiti.
<
step
>
Aizveriet to ar drānu un uzpildiet vienu gadu siltā vidē.
<
step
>
Mainiet vairākas reizes,
uzliek uz loksnes un liek cepeškrāsnī.
<
step
>
Ievadiet vietni
Labojiet visu, sākot no wiki līdz funkcijai webi_xml ("1.xml");
Dalі funkcijā sāciet atlasītāju un visus tagu nosaukumus pārejā augšējais reģistrs, schob usi tags mali tas pats reģistrs.
$ xml_parser = xml_parser_create ();
xml_parser_set_option ($ xml_parser, XML_OPTION_CASE_FOLDING, true);
Tagad vkazuєmo yaki funkcijas noderēs atzīmes parādīšanai
xml_set_element_handler ($ xml_parser, "startElement", "endElement");
xml_set_character_data_handler($ xml_parser, "dati");
Izejiet caur failu, apskatiet failu pa vienai rakstzīmei, un ādas simbols nevarēs sasniegt ziemas doku rindu. >
.
Ja fails ir labāks par failu, tad noteikti viss būs redzams, ja aizņemsimies failu uz vālītes, viss maksās līdz Šis tags pats tiek izmantots XML lasīšanai.
Uz priekšu rjadkova tiek nomainīta uz zberi suņu rindā
І rediģēt її pirms atlases
xml_parse ($ xml_parser, $ dati, feof ($ fp));
Kad veltījums tika savākts pa rindu, izmaiņas tika izlaistas un bija jālabo jauna rinda.
By-tertє
Zvērs, ko cienīt, bet stīgu maiņa jāveido gatavajam tagam >
un nav obligāti jānosūta ziņa izstrādātājam ar ziņu un ziņu.
Šim izlases veidotājam ir svarīgi izvilkt tsil, nevis salauzto tagu, es gribu, lai kāds to redzētu, bet gan nākamās taga croc, vai tieši pie 1000 faila rindām, tas nav svarīgi, izsmērējiet tagu nav kniedēts, piemēram
le> Prosty hlib
Tātad nav iespējams nosūtīt atbildi obrobnik;
Varat izdomāt savu metodi paraugā esošo datu uzraudzībai, piemēram, paņemt 1 megabaitu datu un nosūtīt tos uz paraugu plūsmas reklamēšanai, vienkārši sekojiet līdzi, tagi vienmēr tiek aizpildīti, un datus var izņemt
Šādā secībā pa daļām, kā vēlaties, varat nosūtīt lielisku failu uz kopiju.
Tagad ir skaidrs, kā tsі danі obroblyayutsya un kā іх apdare.
tagu funkcionalitātes labošana, startElement ($ parsētājs, $ nosaukums, $ attrs)
Ir pieņemami, ka obrobka devās uz rindu
<
ingredient amount
=
"3"
unit
=
"стакан"
>Boroshno
Todi visas vidējās funkcijas mainīt $ nosaukums dorivnyuvatime sastāvdaļaŠis ir atvērtā taga nosaukums (līdz labās puses taga aizvēršanai tas vēl nedarbojās).
Šajā vipad būs arī atribūtu masīvs $ attrs tagam, kurā tas būs daudzums = "3" i vienība = "pudele".
Pēc dotā taga apstrādes pārgāja uz funkciju dati ($ parsētājs, $ dati)
Zminniy $ datos būs viss, kas atrodams zem taga, tas ir, mūsu vipad, teksts Milti
Es pabeidzu mūsu rindas apstrādi ar funkciju endElement ($ parsētājs, $ nosaukums)
Slēgtā taga Qia nosaukums mūsu nolaižamajā sarakstā $ nosaukums sastāvdaļa
Un tad atkal viss gāja uz kolas.
Mērķēšanas muca nedemonstrē XML apstrādes principu, bet tā reālā glabāšana ir jāapstrādā tālāk.
Lūdzu, izvēlieties lielisko XML, kas jāienes datu bāzē, un no pareizas datu apstrādes. Mayuchi šo informāciju var pareizi pārmeklēt failu bez problēmām.
Kopumā ir jāievada vairākas globālas izmaiņas, piemēram, jāapkopo informācija par displeja tagiem, ieguldījumiem un datiem.
Es mērķēju uz dibena, kas, starp citu, var būt uzvarošs
Funkcija webi_xml ($ fails)
{
globālais $ webi_depth; // dozators, iemaksas veikšanai
$ webi_depth = 0;
globālais $ webi_tag_open; // atriebība par ziņojumu masīvu
$ webi_tag_open = masīvs ();
globālā $ webi_data_temp; // viss datu masīvs no viena taga
####################################################
### roboti darbojas ar datiem
funkciju dati ($ parsētājs, $ dati)
{
globālais $ webi_depth;
globālais $ webi_tag_open;
globālā $ webi_data_temp;
// dodaamo dan masīvā no ieguldījuma vērtībām un danny taga
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]. = $ dati;
}
############################################
####################################################
### funkciju displeja tagi
funkcija startElement ($ parsētājs, $ nosaukums, $ attrs)
{
globālais $ webi_depth;
globālais $ webi_tag_open;
globālā $ webi_data_temp;
// ja ieguldījuma vērtība nav nulle, ir arī viens addcrit tags
// un dotie dati jau ir masīvā, tos ir iespējams apstrādāt
ja ($ webi_depth)
{
"
;
drukāt "
"
;
print_r ($ webi_tag_open); // displeja tagu masīvs
drukāt "
" ;
// par piemiņas dāvanu pārskatīšanu
atiestatīts ($ GLOBALS ["webi_data_temp"] [$ webi_depth]);
}
// Tagad aizskarošā atzīme ir parādīta, un process tiks parādīts aizskarošajā galā
$ webi_depth ++; // liels ieguldījums
$ webi_tag_open [$ webi_depth] = $ nosaukums; // dod ziņu tagam informācijas masīvā
$ webi_data_temp [$ webi_depth] [$ name] ["attrs"] = $ attrs; // tagad dodєmo tagu atribūti
}
###############################################
#################################################
izliekto tagu funkcija
funkcija endElement ($ parsētājs, $ nosaukums) (
globālais $ webi_depth;
globālais $ webi_tag_open;
globālā $ webi_data_temp;
// Šeit cieņas apstrādi var salabot, piemēram, pievienojot bāzei, saglabājot failu utt.
// $ webi_tag_open, lai atriebtu lantsyuzhok par kritiskajām atzīmēm par līdzvērtīgu ieguldījumu
// piemēram $ webi_tag_open [$ webi_depth] atriebties atvērtā taga nosaukumam.
// $ webi_depth taga pielikuma vērtība
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"] tagu atribūtu masīvs
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] taga dati
Drukāt "dana". $ 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"]);
drukāt "
"
;
print_r ($ webi_tag_open);
drukāt "
" ;
Atiestatīts ($ GLOBALS ["webi_data_temp"]); // pēc datu pārskatīšanas masīva redzeslokā ar datiem fonā, fragmenti tiks pievienoti aizvērtajam tagam
atiestatīts ($ GLOBALS ["webi_tag_open"] [$ webi_depth]); // vidalyaєmo informācija par atbildes tagu ...
$ webi_depth -; // mainīt ieguldījumu
}
############################################
$ xml_parser = xml_parser_create ();
xml_parser_set_option ($ xml_parser, XML_OPTION_CASE_FOLDING, true);
// vkazuєmo yaki funktsii pratsyuvatimut pіd stundu parādīšanas un atzīmju aizvēršanas
xml_set_element_handler ($ xml_parser, "startElement", "endElement");
// vkazuєo funkcija līdz robotiem ar datiem
xml_set_character_data_handler($ xml_parser, "dati");
// atver failu
$ fp = fopen ($ fails, "r");
$ perviy_vxod = 1; // Prapor pirmās ievades konvertēšanai failā
$ dati = ""; // šeit jūs varat atlasīt datu daļas no faila un nosūtīt to uz xml direktoriju
// nav zināms, ka cilpa pabeidz failu
kamēr (! feof ($ fp) un $ fp)
{
$ simvol = fgetc ($ fp); // nolasa vienu rakstzīmi no faila
$ dati. = $ simvol; // Pievienojiet rakstzīmi atjauninājuma veltījumam
// ja rakstzīme nebeidz tagu, tad mēs pievēršamies vālītei uz cilpu un pēc tam vienu rakstzīmi uz nākamo, un tā tālāk, līdz tags tiek atrasts, kamēr tags nav atrasts.
if ($ simvol! = ">") (turpināt;)
// ja ir zināms nolādēšanas tags, ir pareizi atlasīt datus apstrādē
// Reverss, ja fails ir ievadīts, tad viss ir redzams pirms taga// lai varētu izveidot smittya uz XML cob (rupjais redaktors vai fails ar skriptu no servera)
if ($ perviy_vxod) ($ data = strstr ($ dati, "
// tagad kidaimo dana xml sarakstā
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (
// šeit ir iespējams izteikt tādu piedošanu par valenci ...
// nu sāc mazliet piedod, atver vaļā
atbalss"
XML kļūda: ". Xml_error_string (xml_get_error_code ($ xml_parser));
atbalss "pie līnijas". xml_get_current_line_number ($ xml_parser);
pārtraukums;
}
// Pislya uz skidamo atlases datu analīzi aizskarošajam kroka ciklam.
$ dati = "";
}
fclose ($ fp);
xml_parser_free ($ xml_parser);
// Skats uz globālajām izmaiņām
atiestatīts ($ GLOBALS ["webi_depth"]);
atiestatīts ($ GLOBALS ["webi_tag_open"]);
atiestatīts ($ GLOBALS ["webi_data_temp"]);
Webi_xml ("1.xml");
?>
Viss dibens ir suprovodzhuvav komentāri, tagad pārbaudi un eksperimentē.
Lai brutalizētu cieņu, robota funkcijas ar datiem datu masīvā netiek vienkārši ievietotas, bet gan tiek pievienotas, lai palīdzētu. .="
Tātad, ja daniju var atrast ne visā viglyadā, un ja tā ir vienkārši piesavināta, tad dažos gadījumos jūs varēsiet ņemt danny ar shmatki.
Nu, ass un viss, tagad, apstrādājot failu, vai tas būtu atmiņas lielums, un robota skripta stundu asi var mainīt vairākos veidos.
Skripta ausī ielīmējiet funkciju
set_time_limit (6000);
abo
ini_set ("maksimālais_izpildes_laiks", "6000");
Vai arī ievadiet tekstu .htaccess failā
php_value max_execution_time 6000
Pievienojiet stundu robota skripta 6000 sekundēm.
Tādā veidā ir iespējams ietaupīt stundu nedegšanas režīmā.
Ja jums ir piekļuve php.ini rediģēšanai, palīdzības saņemšanai varat veltīt stundu
maksimālais_izpildes_laiks = 6000
Piemēram, statistikas rakstīšanas laikā skripts stundu tiek rūdīts uz hostinga meisterhost, nebrīnieties par atklāšanu bezcepšanas režīms, ja esi pro, meisterhostā vari izveidot savu php, bet ne statistikā.
