Jag har att göra med en tredje part PHP-bibliotek, som jag inte kan redigera och har fungerat bra i nästan ett år. Den använder simplexml_load_string för att svara från fjärrservern. Han har kvävts av stora svar på sistone. Detta är ett dataflöde för fastighetsobjekt och även formatet ser ut ungefär så här:
Jag laddade ner en exempelsvarsfil (ca 22MB), det var där jag hamnade med min felsökning och sunt förnuft. Båda servrarna kör PHP version 5.3.8, men notera de olika resultaten. Jag är ganska säker på att båda filerna är desamma (jag antar att olika typer filer, strlen och sista 50 tecknen kan förklaras med nya Windows linjer, som har en extra vagnretur-karaktär). Testscenario:
felrapportering(-1); ini_set("display_errors", 1); $file = "error-example.xml"; $xml = file_get_contents($file); echo "filesize: "; var_dump(filstorlek($fil)); echo "strlen: "; var_dump(strlen($xml)); echo "simplexml objekt?"; var_dump(is_object(simplexml_load_string($xml))); echo "Sista 50 tecken: "; var_dump(substr($xml, -50));
Utdata lokalt på Windows:
Filstorlek: int(21893604) strlen: int(21893604) simplexml-objekt? bool(true) Senaste 50 tecknen: string(50) "RD DR CT Watertown 203-555-5555 "
Utdata på fjärr UNIX-server:
Filstorlek: int(21884093) strlen: int(21884093) simplexml-objekt? Varning: simplexml_load_string(): Entitet: rad 9511: parserfel: internt fel i /path/to/test.php på rad 19 Varning: simplexml_load_string(): AULTED CEILING I FOAJÄR, BRICK FP I FR, NYTT GOLV I LR DR FR FOYER KITCHEN i /path/to/test.php på rad 19 Varning: simplexml_load_string(): ^i /path/to/test.php på rad 19 Varning: simplexml_load_string(): Entitet: rad 9511: parserfel: Extra innehåll på slutet av dokumentet i /path/to/test.php på rad 19 Varning: simplexml_load_string(): UPPTAKET TAK I FOAJÄR, BRICK FP I FR, NYTT GOLV I LR DR FR FOAJÄRSKÖK i /path/to/test.php på rad 19 Varning: simplexml_load_string(): ^i /path/to/test.php på rad 19 bool(false) Sista 50 tecknen: string(50) "ORD DR CT Watertown 203-555-5555 "
Några svar på kommentarer och ytterligare information:
Själva XML-en verkar vara giltig så vitt jag kan säga (och det gör arbeta på mitt system).
magic_quotes_runtime är definitivt avstängd.
Den fungerande servern har libxml version 2.7.7 och den andra är 2.7.6. Kan det verkligen göra skillnad? Jag kunde inte hitta libxml changelog, men det verkar osannolikt.
Detta händer bara om svaret/filen är över en viss storlek, och felet uppstår alltid på nästa rad.
Jag stöter inte på minnesproblem, testskriptet körs omedelbart.
Det finns skillnader i PHP-konfigurationer som jag kan lägga upp om jag visste vilka som var relevanta. Någon aning om vad problemet kan vara, eller vet om något annat som jag kan kolla?
Att analysera XML innebär i huvudsak att gå igenom ett XML-dokument och returnera motsvarande data. Och även om allt Mer webbtjänster returnerar data i JSON-format, men de flesta använder fortfarande XML, så det är viktigt att behärska XML-tolkning om du vill använda hela utbudet av tillgängliga API:er.
Använder tillägget SimpleXML i PHP, som lades till i PHP 5.0, är det mycket enkelt och enkelt att arbeta med XML. I den här artikeln kommer jag att visa dig hur du gör.
Låt oss börja med följande exempel languages.xml:
>
>
>
>
Detta XML-dokument innehåller en lista över programmeringsspråk med viss information om varje språk: året för dess implementering och namnet på dess skapare.
Det första steget är att ladda XML med hjälp av funktionerna antingen simplexml_load_file(), eller simplexml_load_string(). Som namnet på funktionerna antyder kommer den första att ladda XML från en fil och den andra kommer att ladda XML från en sträng.
Båda funktionerna läser in hela DOM-trädet i minnet och returnerar ett objekt EnkelXMLElement. I exemplet ovan lagras objektet i variabeln $languages. Du kan använda funktioner var_dump() eller print_r() för att få detaljerad information om det returnerade objektet, om du vill.
SimpleXMLElement-objekt
[lang] => Array
[ 0 ] => SimpleXMLElementObject
[@attribut] => Array
[namn] => C
[uppträdde] => 1972
[ skapare] => Dennis Ritchie
[ 1 ] => SimpleXMLElement-objekt
[@attribut] => Array
[namn] => PHP
[uppträdde] => 1995
[ skapare] => Rasmus Lerdorf
[ 2 ] => SimpleXMLElement Object
[@attribut] => Array
[namn] => Java
[uppträdde] => 1995
[ skapare] => James Gosling
)
)
Denna XML innehåller rotelementet språk, som innehåller tre element lang. Varje arrayelement motsvarar ett element språk i ett XML-dokument.
Du kan komma åt egenskaperna för ett objekt med operatorn -> . Till exempel kommer $languages->lang att returnera ett SimpleXMLElement-objekt som matchar det första elementet språk. Detta objekt innehåller två egenskaper: dök upp och skapare.
$languages -> lang [ 0 ] -> dök upp ;
$languages -> lang [ 0 ] -> skapare ;
Att visa en lista över språk och visa deras egenskaper är väldigt enkelt med en standardloop som t.ex för varje.
foreach ($languages-> lang as $lang ) (
printf (
""
,
$lang["namn"],
$lang -> dök upp,
$lang -> skapare
)
;
}
Lägg märke till hur jag fick åtkomst till lang-elementets attributnamn för att få namnet på språket. På så sätt kan du komma åt alla attribut för ett element som representeras som ett SimpleXMLElement-objekt.
När du arbetar med XML för olika webbtjänster kommer du ofta att stöta på elementnamnrymder. Låt oss ändra vår languages.xml för att visa ett exempel på användning av ett namnområde:
xmlns:dc =>
>
>
>
>
Nu element skapare placeras i namnutrymmet dc, som pekar på http://purl.org/dc/elements/1.1/. Om du försöker skriva ut språkskaparna med vår tidigare kod kommer det inte att fungera. För att läsa elementnamnrymder måste du använda en av följande metoder.
Det första tillvägagångssättet är att använda URI-namnen direkt i koden när man refererar till elementets namnområde. Följande exempel visar hur detta går till:
$dc = $languages-> lang [ 1 ] -> barn( "http://purl.org/dc/elements/1.1/")
;
echo $dc -> skapare ;
Metod barn() tar ett namnutrymme och returnerar underordnade element som börjar med ett prefix. Det krävs två argument, det första är XML-namnutrymmet och det andra är ett valfritt argument som är standard falsk. Om det andra argumentet är satt till TRUE kommer namnområdet att behandlas som ett prefix. Om FALSE kommer namnområdet att behandlas som URL-namnområdet.
Den andra metoden är att läsa URI-namnen från dokumentet och använda dem när du refererar till elementets namnområde. Detta är faktiskt det bästa sättet att komma åt element eftersom du inte behöver vara hårdkodad till en URI.
$namespaces = $languages-> getNamespaces (true ) ;
$dc = $languages-> lang [1] -> barn ($namespaces ["dc"]);
echo $dc -> skapare ;
Metod GetNamespaces() returnerar en uppsättning prefixnamn och deras associerade URI:er. Det krävs en extra parameter som är standard falsk. Om du installerar det som Sann, då returnerar den här metoden namnen som används i överordnade och underordnade noder. Annars hittar den namnutrymmen som endast används i den överordnade noden.
Nu kan du iterera genom listan över språk så här:
$languages = simplexml_load_file ("languages.xml" );
$ns = $languages-> getNamespaces (true) ;
foreach ($languages-> lang as $lang ) (
$dc = $lang -> barn ($ns [ "dc" ] );
printf (
"
%s dök upp i %d och skapades av %s .
" ,Låt oss titta på ett exempel som tar emot ett RSS-flöde från Youtube-kanal och visar länkar till alla videor från den. För att göra detta, vänligen kontakta följande adress:
http://gdata.youtube.com/feeds/api/users/xxx/uploads
URL:en returnerar en lista över de senaste videorna från den givna kanalen i XML-format. Vi kommer att analysera XML och få följande information för varje video:
Vi börjar med att söka och ladda XML:
$channel = "Kanalnamn" ;
$url = "http://gdata.youtube.com/feeds/api/users/". $kanal. "/uppladdningar" ;
$xml = file_get_contents ($url ) ;
$feed = simplexml_load_string ($xml ) ;
$ns = $feed -> getNameSpaces (true) ;
Om du tittar på XML-flödet kan du se att det finns flera element där. entitet, som var och en lagrar detaljerad information om en specifik video från kanalen. Men vi använder bara bildminiatyrer, videoadress och titel. Dessa tre element är barn till elementet grupp, som i sin tur är ett barn till inträde:
…
…
…
>
…
Vi ska bara gå igenom alla element inträde och extrahera nödvändig information för var och en av dem. anteckna det spelare, Miniatyr Och titel finns i medianamnutrymmet. Därför måste vi fortsätta som i föregående exempel. Vi hämtar namnen från dokumentet och använder namnutrymmet när vi hänvisar till elementen.
foreach ($feed -> post som $entry ) (
$group = $entry -> barn ($ns [ "media" ] );
$grupp = $grupp -> grupp ;
$thumbnail_attrs = $grupp -> miniatyrbild [1] -> attribut () ;
$image = $thumbnail_attrs [ "url" ] ;
$spelare = $grupp -> spelare -> attribut () ;
$länk = $spelare["url"];
$titel = $grupp -> titel ;
printf ( "
$player , $image , $title );
}
Nu när du vet hur du använder SimpleXML för att analysera XML-data kan du förbättra dina kunskaper genom att analysera olika XML-flöden med olika API:er. Men det är viktigt att komma ihåg att SimpleXML läser in hela DOM i minnet, så om du analyserar en stor datamängd kan du få slut på minne. Läs dokumentationen för att lära dig mer om SimpleXML.
Om du har några frågor, använd vår
Markup-bibliotek för XML-bearbetning med använder PHP
PHP version 5 introducerar SimpleXML, ett nytt applikationsprogrammeringsgränssnitt (API) för att läsa och skriva XML. SimpleXML-tillägg som
$doc->rss->kanal->objekt->titelvälj element från dokumentet. Så länge du har en god uppfattning om strukturen i ditt dokument är det lätt att skriva dessa uttryck. Men om du inte vet exakt var elementen av intresse visas (som är fallet med Docbook, HTML och liknande textdokument), SimpleXML kan använda XPath-uttryck för att hitta dessa element.
Föreställ dig vad du vill skapa PHP-sida, som konverterar RSS-flödet till HTML-kod. RSSär det huvudsakliga XML-formatet för att publicera innehåll från flera källor. Rotelementet i detta dokument är rss , som innehåller ett enda kanalelement. Kanalelementet innehåller metadata om innehållet, inklusive dess titel, språk och URL. Den innehåller också en mängd olika textelement kapslade i objektelement. Varje objektelement har ett länkelement som innehåller en URL eller titel eller beskrivning (vanligtvis båda) som innehåller läsbar text. Namnutrymmen används inte. Naturligtvis finns det mycket mer att säga om RSS, men för denna artikels syften räcker informationen. visar ett typiskt exempel med ett par informationsmeddelanden.
Låt oss skapa en PHP-sida som formaterar varje RSS-flöde som HTML. visar strukturen på den framtida sidan.
Det första steget är att analysera XML-dokumentet och lagra det i en variabel. Detta kräver att du bara skriver en rad kod som skickar URL:en till funktionen simplexml_load_file():
$rss = simplexml_load_file("http://partners.userland.com/nytRss/nytHomepage.xml");Schemat som används här är farligt långt ifrån optimalt. Jag borde verkligen inte ladda ner och analysera RSS-flödet varje gång sidan besöks. Detta saktar ner läsarna av sidan och är ett potentiellt denial of service för de RSS-flöden jag laddar ner, eftersom de flesta av dem ställer in sin maximala uppdateringshastighet till ungefär en gång i timmen. Den verkliga lösningen på detta problem är att cache eller skapa HTML-sidor, eller RSS-flöden, eller båda. Denna fråga står dock i strid med använder SimpleXML bibliotek, så jag förskönar lite här.
För det här exemplet tog jag en sida från Userland-kanalen New York Times på http://partners.userland.com/nytRss/nytHomepage.xml. Naturligtvis kan du använda vilken annan URL som helst för ett annat RSS-flöde istället.
Observera att trots namnet simplexml_load_ fil() , kommer den här funktionen att behöva analysera XML-dokumentet på fjärr-HTTP URL. Men det är inte den enda överraskningen i den här funktionen. Returvärdet för funktionen, som här lagras i variabeln $rss , pekar inte på hela dokumentet, som man kan förvänta sig av erfarenhet av andra API:er, som t.ex. Objektmodell dokument (DOM). Snarare pekar det på rotelementet i dokumentet. Innehållet som finns i dokumentets prolog och epilog är inte tillgängligt från SimpleXML.
Namnet på hela kanalen (i motsats till titlarna på de individuella textdelarna av den kanalen) finns i titelelementet under kanalelementet, som härstammar från rss-rotelementet. Du kan ladda denna rubrik som om XML-dokumentet bara var en serialiserad form av ett rss-objekt med ett fält kanal, som i sin tur skulle ha ett fält titel. Med hjälp av vanlig PHP-objektreferenssyntax hittar denna sats rubriken:
$title = $rss->kanal->titel;När du har hittat titeln måste du lägga till den i helgen HTML-data. Det är lätt att göra: upprepa $title-variabeln:
Den här raden matar ut elementets strängvärde, men inte hela elementet. Det vill säga att texten spelas in, men inte taggarna.
Du kan till och med utelämna mellanvariabeln $title helt:
Eftersom den här sidan återanvänder det här värdet på många ställen, tycker jag att det är bekvämare att lagra det som en variabel med beskrivande titel.
Men kanaler innehåller vanligtvis mer än ett element. Eller så kanske de inte ens existerar alls. Följaktligen returnerar denna sats en array, som du kan iterera med en slinga för varje:
foreach ($rss->channel->item som $item) ( echo "". $item->beskrivning."
"; }". $item->beskrivning."
"; } ?>Det är allt som krävs för att skriva ett enkelt program RSS-läsare i PHP - Flera HTML-strängar och några PHP-strängar. Exklusive mellanslag, totalt 20 rader. Naturligtvis är detta inte den mest funktionsrika, optimerade eller pålitliga utvecklingen. Låt oss se vad vi kan göra för att fixa detta.
Alla RSS-flöden är inte så välformade som de borde vara. XML-specifikationen kräver att processorer slutar bearbeta dokument så snart ett formellt fel upptäcks, och SimpleXML överensstämmer med XML-behandlingsprogrammet. Detta kommer dock inte att hjälpa dig mycket när ett fel upptäcks. Vanligtvis skriver programmet en varning till php-felfilen (men inget detaljerat felmeddelande) och funktionen simplexml-load-file() ger ett fel. Om du inte är säker på om filen du analyserar är välbyggd, kontrollera efter detta fel innan du använder filens data, som visas i .
Ett annat vanligt misstag inträffar när ett dokument är välformaterat men inte innehåller de element du förväntar dig där du förväntar dig att de ska vara. Vad händer till exempel med ett sådant uttryck $doc->rss->channel->item->title , när elementgruppen inte har en titel (som händer med minst ett av de hundra vanligaste RSS-flödena)? Det enklaste tillvägagångssättet är att alltid behandla returvärdet för en funktion som en array av data och slå in den i en loop. I det här fallet är du skyddad från att det finns fler eller färre element än du förväntade dig. Men om du vet att du vill ha det första elementet i dokumentet, även om det finns fler än ett, kan du fråga efter det via ett nollbaserat index. För att till exempel begära titeln på den första gruppen av element kan du skriva:
$doc->rss->kanal->objekt->titelOm den första gruppen av element saknas eller inte har något namn, behandlas den på samma sätt som alla andra grupper utöver etablerade ramar index, in PHP-array. Det vill säga resultatet är null, vilket förvandlas till en tom sträng när du försöker klistra in den i HTML-utdatakoden.
Att känna igen och avvisa oväntade format som du inte är beredd att arbeta med är vanligtvis domänen för en validerande XML-parser. SimpleXML kan dock inte valideras mot en DTD-mall (DTD) eller dataschema. Den kontrollerar endast för formell korrekthet.
Många sajter går idag från RSS till Atom. visar ett exempeldokument i Atom. Detta dokument är på många sätt identiskt med RSS-exemplet. Det finns dock mer metadata här, och rotelementet är feed istället för rss . Matningselementet har listor istället för element. Innehållselementet ersätter beskrivningselementet. Ännu viktigare är att ett Atom-dokument använder ett namnutrymme medan RSS inte gör det. Således kan ett Atom-dokument mata ut riktigt, oklippt Extensible HTML (XHTML)-innehåll.
Steve Palmer har lagt upp en betaversion av Vienna 2.1, en RSS/Atom-klient med öppen källkod för Mac OS X. Wien är den första läsaren jag "har funnit acceptabel för dagligt bruk; inte bra men bra nog. (Självklart mina standarder för "bra nog" är ganska höga.) 2.1 fokuserar på att förbättra användargränssnittet med en enhetlig layout som låter dig bläddra igenom flera artiklar, artikelfiltrering (t.ex. läs alla artiklar sedan den senaste uppdateringen), manuell omordning av mappar, ett nytt få informationsfönster och en förbättrad förtätad layout.
Matt Mullenweg har släppt Wordpress 2.0.4, en bloggmotor baserad på PHP och MySQL. 2.0.4 täpper till olika säkerhetshål, mestadels med plugins.
Även om elementnamnen har ändrats är den grundläggande metoden för att arbeta med SimpleXML i dokument i Atom densamma som med RSS. Den enda skillnaden är att du behöver ange namnutrymmet, dvs. Uniform Resource Identifier (URI) när du begär ett element med ett namn, precis som lokalt namn. Det är en process i två steg: först, fråga efter de underordnade elementen i givet utrymme namn genom att skicka URI-namnområdet till funktionen children(). Fråga sedan efter element med rätt lokala namn i det namnområdet. Föreställ dig att du först laddade Atom-flödet till variabeln $feed, så här:
$feed = simplexml_load_file("http://www.cafeconleche.org/today.atom");Dessa två rader hittar nu titelelementet:
$children = $feed->children("http://www.w3.org/2005/Atom"); $title = $children->title;Du kan kondensera den här koden till ett enda uttalande om du vill, även om strängen blir lite lång. Alla andra element i namnutrymmen ska hanteras på samma sätt. visar hel sida PHP som visar rubriker från ett namngivet Atom-rör.
Varför visade jag bara rubrikerna i det här exemplet? För i Atom kan innehållet i vilken lista som helst innehålla hela texten i fragmentet och inte bara själva texten utan också hela uppmärkningen. det här - berättande struktur: ord i rad är avsedda att läsas av människor. Som med de flesta data av detta slag finns det blandat innehåll här. XML är inte längre förenklat, så SimpleXML-metoden börjar vackla. Det kan inte fungera korrekt med blandat innehåll, och detta utelämnande av data utesluter användning i många fall.
Du kan göra en sak, men detta är bara en dellösning på problemet. Det fungerar bara eftersom innehållselementet innehåller riktig XHTML. Du kan kopiera denna XHTML som otolkad källa direkt till slutprodukten med funktionen asXML(), till exempel enligt följande:
eka"". $details->content->asXML(). "
";Resultatet blir något i stil med .
Nikolai Grigoriev har släppt SVGMath 0.3, en MathML-formaterare för presentation som producerar SVG skriven i ren Python och publicerad under en MIT-licens. Enligt Grigoriev, "Den nya versionen kan fungera med dokument med flera namnutrymmen (t.ex. ersätt alla MathML-underträd med SVG i ett XSL-FO- eller XHTML-dokument); konfigurationen görs mer flexibel och flera buggar är fixade. Det finns också en stilmall för att justera den vertikala positionen för den resulterande SVG-bilden i XSL-FO."
Det är inte ren XHTML. Innehållselementet hämtas från dokumentets Atom, och du är faktiskt bättre att inte ha det. Ännu värre, det går in i fel namnutrymme så att det inte kan kännas igen för vad det är. Lyckligtvis skadar inte detta extra element mycket i praktiken, eftersom webbläsare helt enkelt ignorerar alla taggar de inte känner igen. Det färdiga dokumentet är felaktigt, men det spelar egentligen ingen roll. Om det verkligen stör dig, annullera det med strängoperationer, så här:
$description = $details->content->asXML(); $tags = array("För att göra koden lite mer robust, använd ett reguljärt uttryck istället för att anta att starttaggen är exakt som visas ovan. Speciellt kan du beräkna många möjliga attribut:
// sluttaggen har en fast form så det är lätt att ersätta $description = str_replace("", "", $description); // ta bort starttaggen, inklusive attribut och blanksteg om möjligt $description = ereg_replace("Även med denna modifiering kan din kod ge kommentarer, beräkningskommandon och CDATA-bitar. Hur som helst, du klipper bort det, även om jag är rädd att det inte är så lätt längre. Blandat innehåll överskrider helt enkelt de gränser som SimpleXML designades för att fungera inom.
Uttryck som $rss->channel->item->title är bra bara om du vet exakt vilka element som finns i dokumentet och exakt var de är. Men du vet inte alltid detta. Till exempel i XHTML kan element i rubriken (h1 , h2 , h3 , etc.) vara barn till body , div , table och flera andra element. Dessutom kan div , table , blockquote och andra element kapslas flera gånger. För många mindre specifika användningsfall är det lättare att använda XPath-uttryck som //h1 eller //h1 . SimpleXML har denna uppsättning funktionalitet via xpath()-funktionen.
En sista varning: XPath i PHP är ganska långsam. Sidladdning kan ta allt från ett ögonblick till några sekunder när jag byter till detta XPath-uttryck, även på en olastad lokal server. Om du använder dessa knep måste du använda någon form av caching för att fungera intelligent. Dynamiskt generering av varje sida fungerar helt enkelt inte.
SimpleXML är ett användbart tillägg till PHP-utvecklarens verktygslåda, så länge du inte behöver arbeta med blandat innehåll. Det täcker Ett stort antal användningsfall. Detta fungerar särskilt bra med enkla data i form av poster. Så länge dokumentet inte är för djupt, för komplext och inte har blandat innehåll är SimpleXML mycket enklare än dess DOM-alternativ. Det hjälper också om du känner till strukturen i dokumentet i förväg, även om XPath kan underlätta detta krav mycket. Brist på validering och stöd för blandat innehåll är en olägenhet, inte alltid ett hinder. Många enkla format har inte blandat innehåll, och i många användningsfall används endast mycket förutsägbara dataformat. Om det är det som kännetecknar ditt arbete, testa gärna SimpleXML. Med lite uppmärksamhet på fel och lite cachejustering för att hålla prestandaproblem till ett minimum, kan SimpleXML vara ett robust, feltolerant XML-bearbetningsverktyg inom PHP.
SimpleXML är ett ganska enkelt och samtidigt ganska kraftfullt sätt att bearbeta xml-data. Kärnan i simpleXML är att all XML-kod konverteras till ett PHP-objekt, vilket gör det ganska enkelt att arbeta med det. När du arbetar med simpleXML måste all data vara i UTF-8-kodning.
Oftast utförs konverteringen till ett PHP-objekt med funktionen simplexml_load_file, nedan är exempel på hur du arbetar med det. Du kan också använda funktionen simplexml_load_string, skapa ett PHP-objekt från en XML-sträng
Låt oss skapa en xml-fil först
I följande exempel kommer endast priset på den andra bilen att visas.
För att visa hela xml-koden på en gång eller en enda nod, används metoden asXML().
simpleXML stöder även adressering med XPath-språket. Följande exempel kommer att välja alla "års"-noder och returnera en array av dem.
Att ersätta elementvärden görs genom att helt enkelt tilldela ett värde
Vid ersättning av noder som har barnnoder måste försiktighet iakttas eftersom alla barnnoder kommer att tas bort.
I de två föregående exemplen, xml-data som finns i random access minne, men de skrevs inte till disk. För att skriva över data i en fil, använd funktionen file_put_contents()
Det är också möjligt att integrera simpleXML och Dom med hjälp av Simplexml_import_dom()-funktionen
Det här exemplet visar hur man får värdet av elementattribut.
SimpleXMLElement->asXML
SimpleXMLElement->asXML -- Returnerar ett välformaterat XML-dokument
Beskrivning
Mixed SimpleXMLElement->asXML()
AsXML-metoden genererar data i XML version 1.0.
Parameterlista
filnamn
Om det anges kommer metoden att skriva data till den angivna filen.
Returvärden
Om ett filnamn anges kommer metoden att skriva XML-data till den angivna filen. Annars kommer metoden att returnera XML-data som en sträng.
Anmärkningar
Om källdokumentet angav kodningen av XML-dokumentet i rubrikerna med hjälp av kodningsparametern, kommer asXML-metoden att returnera XML-dokumentet i den angivna kodningen. Det är inte möjligt att ändra kodningen av ett XML-dokument med SIMPLEXML-tillägget.
Exempel
Exempel 1: Utdata XML
$string =<<
XML
echo $xml->asXML(); //
...?>
AsXML-metoden kan också fungera med XPath:
Exempel 2: Använda metoden asXML() med Xpath
// Fortsättning på exemplet ovan.
/* Sök
$result = $xml->xpath("/a/b/c");
while(list(, $node) = each($result)) (
echo $node->asXML(); //
}
?>
SimpleXMLElement->attribut
SimpleXMLElement->attributs -- Returnerar elementets attribut.
Beskrivning
SimpleXMLElement simplexml_element->attributes()
Denna funktion returnerar namnen och värdena för attributen för det valda xml-elementet. Obs: SimpleXML har en regel för att lägga till iterativa egenskaper till de flesta metoder. De kan inte inspekteras med var_dump() eller någon annan objektparser.
Exempel 1: Tolka en XML-sträng
$string =<<
XML
$xml = simplexml_load_string($string);
foreach($xml->users->attributes() som $a => $b) (
echo $a,"="",$b,"\"\n";
}
?>
Detta exempel kommer att mata ut:
Namn = "Evgen"
ålder="27
EnkelXMLElement->barn
SimpleXMLElement->children -- Returnerar de underordnade elementen för det givna elementet
Beskrivning
SimpleXMLElement simplexml_element->children()
Denna metod hittar de underordnade elementen för det givna elementet.
Obs: SimpleXML har en regel för att lägga till iterativa egenskaper till de flesta metoder. De kan inte inspekteras med var_dump() eller någon annan objektparser.
Exempel 1: Använda metoden children().
$xml = simplexml_load_string(
"
eka"
Detta exempel kommer att mata ut:
php-help.ru
links.php-help.ru
forum.php-help.ru
server.php-spravka.ruyandex.ru
money.yandex.ru
map.yandex.ru
market.yandex.ru
SimpleXMLElement->xpath
SimpleXMLElement->xpath -- Utför en Xpath-fråga på XML-data
Beskrivning
Array SimpleXMLElement->xpath (strängsökväg)
xpath-metoden söker efter underordnade element i SimpleXML-elementet vars sökväg anges i sökvägsparametern. Metoden returnerar en array av SimpleXMLElement-objekt.
Exempel 1. XPath
$string =<<
XML
$xml = simplexml_load_string($string);
/* Sök efter
$result = $xml->xpath("/a/b/c");
foreach ($result som $node) (
echo "/a/b/c: " . $nod. "
";
}
/* Relativa vägar fungerar också... */
$result = $xml->xpath("b/c");
foreach ($result som $node) (
eko "b/c: " . $nod. "
";
}
?>
Detta manus kommer att mata ut:
/a/b/c: text
/a/b/c:stuffb/c:textb/c:stuff
Två resultat in det här falletär samma.
simplexml_import_dom (PHP 5)
simplexml_import_dom -- Returnerar ett SimpleXMLElement-objekt skapat från ett DOM-objekt.
Beskrivning
SimpleXMLElement simplexml_import_dom(DOMNode node[, string class_name])
Denna funktion tar ett DOM-objekt och skapar ett SimpleXML-objekt baserat på det.
Detta nya objekt kan användas som ett vanligt SimpleXML-objekt.
Om fel uppstod under objektskapandet kommer metoden att returnera false.
Exempel 1 Importera DOM
$dom = nytt domDocument;
$dom->loadXML("
om (!$dom) (
echo "Fel vid analys av dokument!";
utgång;
}
$s = simplexml_import_dom($dom);
echo $s->site->url; // php-help.ru
?>
simplexml_load_file (PHP 5)
simplexml_load_file -- Tolkar en XML-fil till ett objekt
Beskrivning
Objekt simplexml_load_file(sträng filnamn[, sträng klassnamn[, int alternativ]])
Den här funktionen tolkar filnamnet med välformade XML-data till ett SimpleXMLElement-objekt. Om det finns fel i XML-data kommer funktionen att returnera FALSE.
Du kan använda den valfria parametern class_name i funktionen simplexml_load_file() för att få funktionen att returnera ett objekt av den angivna klassen. I det här fallet måste klassen vara en förlängning av klassen SimpleXMLElement.
Sedan PHP 5.1.0 och Libxml 2.6.0 kan du använda parametern optional options, vars specifikation beskrivs i ytterligare Libxml-parametrar.
Obs: Libxml 2 konverterar URL:en till rätt form. De där. om du vill ställa in a till b&c i URL-strängen behöver du inte göra:
Simplexml_load_file(rawurlencode("http://example.com/?a=" . urlencode("b&c"))).
Sedan PHP 5.1.0 görs detta automatiskt.
Exempel 1: Tolka ett XML-dokument
// Test.xml-filen innehåller ett XML-dokument med ett rotelement
// och kapslade titelelement //title.if (file_exists("test.xml")) (
$xml = simplexml_load_file("test.xml");
Var_dump($xml);
) annat (
exit("Fel vid öppnandet av test.xml.");
}
?>
Detta exempel kommer att mata ut följande: SimpleXMLElement Object(
=> Testhuvud
...
)
I detta exempel du kan komma åt titelelementet så här: $xml->title.
simplexml_load_string(PHP 5)
simplexml_load_string -- Tolkar en XML-sträng till ett objekt
Beskrivning
Objekt simplexml_load_string(strängdata[, sträng klassnamn[, int alternativ]])
Denna funktion tar det "rätta" XML-dokumentet i datasträngen och returnerar ett objekt av klassen SimpleXMLElement som har egenskaper som är lika med innehållet i xml-dokumentet. Om XML-dokumentet har fel kommer funktionen att returnera FALSE.
Du kan använda den valfria parametern class_name för att få funktionen simplexml_load_string() att returnera ett objekt av den givna klassen. Den här klassen måste utöka klassen SimpleXMLElement.
Från och med PHP 5.1.0 och Libxml 2.6.0 kan du också använda parametern valfria alternativ vars innehåll definieras i ytterligare Libxml-parametrar.
Exempel 1: Transformera en XML-sträng
$string =<<
XML
$xml = simplexml_load_string($string);
var_dump($xml);
?>
Detta exempel kommer att mata ut: SimpleXMLElement Object(
=> Fyrtio Vad?
=> Joe
=> Jane
=>
Jag vet att det är svaret, men vad är frågan?
)
I det här exemplet kan du också använda $xml->kroppskonstruktionerna, etc.
