XML-tolkning. Analysera XML-data C arbetar med XML-exempel

Således, i delar som du vill, kan du skicka en stor fil till processorn.

Låt oss nu titta på hur denna data behandlas och hur man skaffar den.

Låt oss börja med öppningstaggarfunktionen startElement ($parser, $name, $attrs)
Låt oss anta att bearbetningen har nått gränsen
< ingredient amount = "3" unit = "стакан" >Mjöl
Sedan inuti funktionen kommer variabeln $name att vara lika med ingrediens det vill säga namnet på den öppna taggen (det har inte kommit till att stänga taggen än).
Även i det här fallet kommer en rad attribut för denna tagg $attrs att vara tillgängliga, som kommer att innehålla data mängd = "3" och enhet = "glas".

Efter detta bearbetades data för den öppna taggen av funktionen data ($parser, $data)
Variabeln $data kommer att innehålla allt som finns mellan öppnings- och stängningstaggar, i vårt fall är detta texten Muka

Och bearbetningen av vår sträng av funktionen avslutas endElement ($parser, $name)
Detta är namnet på den stängda taggen, i vårt fall kommer $name att vara lika med ingrediens

Och efter det gick allt i cirklar igen.

Ovanstående exempel visar bara principen för XML-bearbetning, men för verklig tillämpning måste den modifieras.
Vanligtvis måste du analysera stor XML för att mata in data i databasen, och för att korrekt bearbeta data behöver du veta vilken öppen tagg data tillhör, vilken nivå av taggkapsling och vilka taggar som är öppna i hierarkin ovan. Med denna information kan du bearbeta filen korrekt utan problem.
För att göra detta måste du introducera flera globala variabler som samlar in information om öppna taggar, kapsling och data.
Här är ett exempel som du kan använda

Funktion webi_xml ($file)
{
global $webi_depth ; // motverka till spår häckningsdjup
$webi_depth = 0 ;
global $webi_tag_open ; // kommer att innehålla en array av för närvarande öppna taggar
$webi_tag_open = array();
global $webi_data_temp ; // denna array kommer att innehålla data för en tagg

####################################################
### datafunktion
funktionsdata ($parser, $data)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;
// lägg till data till arrayen som indikerar kapsling och för närvarande öppen tagg
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################

####################################################
### öppningstaggfunktion
funktion startElement ($parser, $name, $attrs)
{
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;

// om kapslingsnivån inte längre är noll, är en tagg redan öppen
// och data från den redan finns i arrayen kan du bearbeta den
if ($webi_depth)
{

" ;

skriv ut "
" ;
print_r($webi_tag_open); // rad öppna taggar
skriv ut "

// efter bearbetning av data, radera den för att frigöra minne
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}

// nu öppnas nästa tagg och ytterligare bearbetning kommer att ske i nästa steg
$webi_depth++; // öka häckningen

$webi_tag_open [ $webi_depth ]= $namn ; // lägg till en öppen tagg till informationsmatrisen
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // lägg nu till taggattribut

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

#################################################
## avslutande taggfunktion
function endElement ($parser, $name) (
global $webi_depth ;
global $webi_tag_open ;
global $webi_data_temp ;

// databehandling börjar här, till exempel lägga till i databasen, spara till en fil, etc.
// $webi_tag_open innehåller en kedja av öppna taggar efter kapslingsnivå
// till exempel $webi_tag_open[$webi_depth] innehåller namnet på den öppna taggen vars information för närvarande bearbetas
// $webi_depth tagg kapslingsnivå
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] rad med taggattribut
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["data"] taggdata

Skriv ut "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" ]);
skriv ut "
" ;
print_r($webi_tag_open);
skriv ut "

Unset($GLOBALS ["webi_data_temp"]); // efter att ha bearbetat data, tar vi bort hela arrayen med data, eftersom taggen stängdes
unset($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // radera information om denna öppna tag... sedan den stängdes

$webi_depth --; // minska häckningen
}
############################################

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

// indikerar vilka funktioner som kommer att fungera när taggar öppnas och stängs
xml_set_element_handler($xml_parser, "startElement", "endElement");

// ange en funktion för att arbeta med data
xml_set_character_data_handler($xml_parser, "data");

// öppna filen
$fp = fopen($fil, "r");

$perviy_vxod = 1 ; // flagga för att kontrollera den första posten i filen
$data = "" ; // här samlar vi in ​​data från filen i delar och skickar den till xml-parsern

// loop tills slutet av filen hittas
while (! feof ($fp ) och $fp )
{
$simvol = fgetc ($fp); // läs ett tecken från filen
$data .= $simvol ; // lägg till detta tecken till data som ska skickas

// om tecknet inte är sluttaggen, gå tillbaka till början av loopen och lägg till ytterligare ett tecken till data, och så vidare tills sluttaggen hittas
if($simvol != ">" ) (fortsätt;)
// om den avslutande taggen hittades kommer vi nu att skicka denna insamlade data för bearbetning

// kontrollera om detta är den första posten i filen, så raderar vi allt som finns före taggen// eftersom du ibland kan stöta på skräp före början av XML (klumpiga redigerare, eller filen togs emot av ett skript från en annan server)
if($perviy_vxod ) ( $data = strstr ($data , "

// Kasta nu data i xml-parsern
if (! xml_parse ($xml_parser, $data, feof ($fp))) (

// här kan du bearbeta och ta emot giltighetsfel...
// så snart ett fel påträffas, slutar tolkningen
eka"
XML-fel: " . xml_error_string(xml_get_error_code($xml_parser));
eko "vid linjen". xml_get_current_line_number ($xml_parser);
ha sönder;
}

// efter analys, kassera insamlade data för nästa steg i cykeln.
$data = "" ;
}
fclose($fp);
xml_parser_free($xml_parser);
// tar bort globala variabler
unset($GLOBALS ["webi_depth"]);
unset($GLOBALS ["webi_tag_open"]);
unset($GLOBALS ["webi_data_temp"]);

Webi_xml("1.xml");

?>

Hela exemplet åtföljs av kommentarer, nu testa och experimentera.
Observera att i funktionen att arbeta med data infogas data inte bara i en array, utan läggs till med " .=" eftersom datan kanske inte kommer fram i sin helhet, och om du bara gör en uppgift, då kommer du då och då att få informationen i bitar.

Tja, det är allt, nu finns det tillräckligt med minne när du bearbetar en fil av vilken storlek som helst, men skriptets körtid kan ökas på flera sätt.
Infoga en funktion i början av skriptet
set_time_limit(6000);
eller
ini_set ("max_exekveringstid" , "6000" );

Eller lägg till text i .htaccess-filen
php_value max_execution_time 6000

Dessa exempel kommer att öka skriptets körtid till 6000 sekunder.
Du kan bara öka tiden på detta sätt när säkert läge är avstängt.

Om du har tillgång till edit php.ini kan du öka tiden med att använda
max_execution_time = 6000

Till exempel, på Masterhost-hosting, när denna artikel skrivs, är det förbjudet att öka manustiden, trots säkert läge, men om du är ett proffs kan du skapa ditt eget php-bygge på masterhost, men det står inte i den här artikeln.

Några exempel i denna handledning inkluderar en XML-sträng. Istället för att upprepa det i varje exempel, lägg den här raden i en fil som du inkluderar i varje exempel. Denna linje visas i följande exempel. Dessutom kan du skapa ett XML-dokument och läsa det med funktionen simplexml_load_file().

Exempel #1 Exempel.php-fil med XML-sträng

$xmlstr =<<





Fröken. Kodare
Onlivia Actora


Herr. Kodare
El skådespelare


Så det är ett språk. Det är fortfarande ett programmeringsspråk. Eller
är detta ett skriptspråk? Allt avslöjas i den här dokumentären,
som en skräckfilm.




7
5


XML;
?>

SimpleXML är mycket lätt att använda! Försök att hämta en sträng eller ett nummer från det underliggande XML-dokumentet.

Exempel #2 Hämta en del av ett dokument

inkludera "exempel.php" ;

echo $movies -> film [ 0 ]-> plot ;
?>

Så det är ett språk. Det är fortfarande ett programmeringsspråk. Eller är det ett skriptspråk? Allt avslöjas i denna skräckfilmsliknande dokumentär.

I PHP kan du komma åt ett element i ett XML-dokument som innehåller otillåtna tecken (som ett bindestreck) i sitt namn genom att omsluta elementnamnet i klammerparenteser och apostrofer.

Exempel #3 Att få ett snöre

inkludera "exempel.php" ;

echo $movies -> movie ->( "great-lines" )-> line ;
?>

Resultatet av att köra detta exempel:

PHP löser alla mina webbproblem

Exempel #4 Åtkomst till icke-unika element i SimpleXML

Om det finns flera instanser av underordnade element inom samma överordnade element, måste standard iterationsmetoder användas.

inkludera "exempel.php" ;

$movies = nytt SimpleXMLElement ($xmlstr );

/* För varje nod , kommer vi att visa namnet separat . */
foreach ($movies -> film -> karaktärer -> karaktär som $character ) (
echo $karaktär -> namn, "spelar", $karaktär -> skådespelare, PHP_EOL;
}

?>

Resultatet av att köra detta exempel:

Fröken. Coder spelar Onlivia Actora Mr. Coder spelar El Actor

Kommentar:

Egenskaper ( $movies->film i föregående exempel) är inte arrayer. Detta är ett itererbart objekt i form av en array.

Exempel #5 Använda attribut

Hittills har vi bara hämtat namn och värden på elementen. SimpleXML kan också komma åt elementattribut. Du kan komma åt ett elements attribut på samma sätt som arrayelement ( array).

inkludera "exempel.php" ;

$movies = nytt SimpleXMLElement ($xmlstr );

/* Åtkomstnod första filmen.
* Vi kommer också att visa en betygsskala. */
foreach ($movies -> film [ 0 ]-> betyg som $rating ) (
switch((sträng) $rating [ "typ" ]) ( // Hämta elementattribut efter index
case "tummen" :
echo $rating , "tummen upp" ;
ha sönder;
fallet "stjärnor":
echo $rating, "stjärnor";
ha sönder;
}
}
?>

Resultatet av att köra detta exempel:

7 tummen upp5 stjärnor

Exempel #6 Jämföra element och attribut med text

För att jämföra ett element eller attribut med en sträng, eller för att skicka det till en funktion som text, måste du casta det till en sträng med (sträng). Annars kommer PHP att behandla elementet som ett objekt.

inkludera "exempel.php" ;

$movies = nytt SimpleXMLElement ($xmlstr );

if ((sträng) $movies -> movie -> title == "PHP: The emergence of the Parser") {
skriva ut "Min favoritfilm.";
}

echo htmlentities ((sträng) $movies -> movie -> title );
?>

Resultatet av att köra detta exempel:

Min favoritfilm.PHP: Emergence of the Parser

Exempel #7 Att jämföra två element

Två SimpleXMLElement anses olika även om de pekar på samma objekt som i PHP 5.2.0.

inkludera "exempel.php" ;

$movies1 = nytt SimpleXMLElement ($xmlstr );
$movies2 = nytt SimpleXMLElement ($xmlstr );
var_dump($movies1 == $movies2); // false sedan PHP 5.2.0
?>

Resultatet av att köra detta exempel:

Exempel #8 Använda XPath

SimpleXML inkluderar inbyggt XPath-stöd. Sök igenom alla element :

inkludera "exempel.php" ;

$movies = nytt SimpleXMLElement ($xmlstr );

foreach ($movies -> xpath ("//character") som $character ) (
echo $karaktär -> namn, "spelar", $karaktär -> skådespelare, PHP_EOL;
}
?>

"// " fungerar som ett jokertecken. För att ange en absolut sökväg, utelämna ett av snedstrecket.

Resultatet av att köra detta exempel:

Fröken. Coder spelar Onlivia Actora Mr. Coder spelar av El Actor

Exempel #9 Inställningsvärden

Data i SimpleXML behöver inte vara oföränderlig. Objektet låter dig manipulera alla element.

inkludera "exempel.php" ;
$movies = nytt SimpleXMLElement ($xmlstr );

$movies -> film [ 0 ]-> tecken -> karaktär [ 0 ]-> name = "Fröken Coder" ;

echo $movies -> asXML();
?>

Resultatet av att köra detta exempel:

Fröken Coder Onlivia Actora Herr. Kodare El skådespelare 7 5

Exempel #10 Lägga till element och attribut

Sedan PHP 5.1.3 har SimpleXML möjligheten att enkelt lägga till underordnade element och attribut.

inkludera "exempel.php" ;
$movies = nytt SimpleXMLElement ($xmlstr );

$character = $movies -> film [ 0 ]-> karaktärer -> addChild ("karaktär" );
$character -> addChild ("namn", "Mr. Parser" );
$character -> addChild ("skådespelare" , "John Doe" );

$rating = $movies -> film [ 0 ]-> addChild ( "rating", "PG" );
$rating -> addAttribute ("typ", "mpaa" );

echo $movies -> asXML();
?>

Resultatet av att köra detta exempel:

Fröken. Kodare Onlivia Actora Herr. Kodare El skådespelare Herr. ParserJohn Doe Så det är ett språk. Det är fortfarande ett programmeringsspråk. Eller är det ett skriptspråk? Allt avslöjas i denna skräckfilmsliknande dokumentär. PHP löser alla mina webbproblem 7 5 PG

Exempel #11 Interagera med DOM

PHP kan konvertera XML-noder från SimpleXML till DOM-format och vice versa. Det här exemplet visar hur du kan ändra ett DOM-element i SimpleXML.

$dom = nytt DOMDocument ;
$dom -> loadXML ( "" );
om (! $dom ) (
eko "Fel vid analys av dokument";
utgång;
}

$books = simplexml_import_dom($dom);

echo $books -> bok [ 0 ]-> titel ;
?>

Resultatet av att köra detta exempel:

4 år sedan

Det finns ett vanligt "trick" som ofta föreslagits för att konvertera ett SimpleXML-objekt till en array, genom att köra det genom json_encode() och sedan json_decode(). Jag skulle vilja förklara varför detta är en dålig idé.

Helt enkelt för att hela poängen med SimpleXML är att vara enklare att använda och kraftfullare än en vanlig array. Du kan till exempel skrivabar -> baz [ "bing" ] ?> och det betyder samma sak sombar [ 0 ]-> baz [ 0 ][ "bing" ] ?> , oavsett hur många bar eller baz-element det finns i XML; och om du skriverbar [ 0 ]-> baz [ 0 ] ?> får du allt stränginnehåll i den noden - inklusive CDATA-sektioner - oavsett om den också har underordnade element eller attribut. Du har också tillgång till namnutrymmesinformation, möjligheten att göra enkla redigeringar av XML, och till och med möjligheten att "importera" till ett DOM-objekt, för mycket mer kraftfull manipulation. Allt detta går förlorat genom att förvandla objektet till en array istället för att läsa och förstå exemplen på den här sidan.

Dessutom, eftersom den inte är designad för detta ändamål, kommer konverteringen till JSON och tillbaka faktiskt att förlora information i vissa situationer. Till exempel kommer alla element eller attribut i ett namnområde helt enkelt att kasseras, och allt textinnehåll kommer att kasseras om ett element också har underordnade eller attribut. Ibland spelar det ingen roll, men om du får för vana att konvertera allt till arrayer kommer det att svida dig så småningom.

Naturligtvis kan du skriva en smartare konvertering, som inte hade dessa begränsningar, men vid den tidpunkten får du inget värde av SimpleXML alls, och du bör bara använda XML Parser-funktionerna på lägre nivå, eller XMLReader-klassen, för att skapa din struktur. Du kommer fortfarande inte att ha den extra bekvämlighetsfunktionaliteten hos SimpleXML, men det är din förlust.

2 år sedan

Om din xml-sträng innehåller booleaner kodade med "0" och "1", kommer du att stöta på problem när du castar elementet direkt till bool:

$xmlstr =<<

1
0

XML;
$values ​​= new SimpleXMLElement($xmlstr);
$truevalue = (bool)$values->truevalue; // Sann
$falsevalue = (bool)$values->falsevalue; // också sant!!!

Istället måste du kasta till sträng eller int först:

$truevalue = (bool)(int)$values->truevalue; // Sann
$falsevalue = (bool)(int)$values->falsevalue; // falskt

9 år sedan

Om du behöver mata ut giltig xml i ditt svar, glöm inte att ställa in din rubrikinnehållstyp till xml förutom att eko ut resultatet av asXML():

$xml = simplexml_load_file("...");
...
... xml-grejer
...

//output xml i ditt svar:
header("Content-Type: text/xml");
echo $xml -> asXML();
?>

9 år sedan

Från README-filen:

SimpleXML är tänkt att vara ett enkelt sätt att komma åt XML-data.

SimpleXML-objekt följer fyra grundläggande regler:

1) egenskaper betecknar element-iteratorer
2) numeriska index betecknar element
3) icke-numeriska index betecknar attribut
4) strängkonvertering gör det möjligt att komma åt TEXT-data

Vid iteration av egenskaper upprepas alltid tillägget
alla noder med det elementnamnet. Sålunda måste metoden child() vara
kallas att iterera över subnoder. Men gör också följande:
foreach ($obj->nodnamn som $elem) (
// gör något med $elem
}
resulterar alltid i iteration av "nodnamn"-element. Så inte längre
kontroll behövs för att särskilja antalet noder av den typen.

När ett element TEXT-data nås via en egenskap
då inkluderar resultatet inte TEXT-data för underelement.

Kända problem
============

På grund av motorproblem är det för närvarande inte möjligt att komma åt
ett underelement av index 0: $object->property.

8 år sedan

Att använda saker som: is_object($xml->modul->admin) för att kontrollera om det faktiskt finns en nod som heter "admin", verkar inte fungera som förväntat, eftersom simplexml alltid returnerar ett objekt - i så fall ett tomt - även om en viss nod inte finns.
För mig verkar den gamla goda funktionen tomma() fungera alldeles utmärkt i sådana fall.

8 år sedan

Ett snabbt tips om xpath-frågor och standardnamnrymder. Det ser ut som att XML-systemet bakom SimpleXML fungerar på samma sätt som jag tror att XML-systemet .NET använder: när man behöver adressera något i standardnamnutrymmet måste man deklarera namnområdet med registerXPathNamespace och sedan använda dess prefix till adressera annars i standardnamnområdet levande element.

$string =<<


Joe
Jane

Jag vet att det är svaret - men vad är frågan?


XML;

$xml = simplexml_load_string ($string);
$xml -> registerXPathNamespace("def" , "http://www.w3.org/2005/Atom");

$nodes = $xml -> xpath ("//def:document/def:title" );

?>

9 år sedan

Medan SimpleXMLElement påstår sig vara iterabel, är det gör inte verkar implementera standard Iterator-gränssnittsfunktioner som::next och::reset korrekt. Därför verkar, medan foreach() fungerar, funktioner som next(), current() eller each() inte fungera som du kan förvänta dig -- pekaren verkar aldrig röra sig eller återställs hela tiden.

6 år sedan

Om XML-dokumentets kodning inte är UTF-8, måste kodningsdeklarationen visas omedelbart efter version="..." och före fristående="...". Detta är ett krav i XML-standarden.

Om kodning av XML-dokument skiljer sig från UTF-8. Kodningsdeklarationen bör följa omedelbart efter versionen = "..." och före fristående = "...". Detta krav är standard XML.

Ok

Ryska språket. ryska språket
Allvarligt fel: Oupptäckt undantag "Undantag" med meddelandet "Sträng kunde inte tolkas som XML" i...