PHP Ein (komplexes) Array in eine XML-Datei "parsen" (Hillfee!)

CPU

Lieutenant
Registriert
Jan. 2006
Beiträge
704
Hallo,

ich habe mir einen XML-Parser gebaut, der unter PHP4 und PHP5 lauffähig ist. Dieser geht die XML-Datei durch und erstellt ein Array.
Folgender XML-Baum
Code:
<?xml version="1.0"?>
<bestaende>
	<bestaende>
		<artikel artnr="401017">
			<bestand>nein</bestand>
		</artikel>
		<artikel artnr="401167">
			<bestand>nein</bestand>
		</artikel>
		<artikel artnr="401171">
			<bestand>nein</bestand>
		</artikel>
		<artikel artnr="401748">
			<bestand>nein</bestand>
		</artikel>
		<artikel artnr="401791">
			<bestand>nein</bestand>
		</artikel>
		<artikel artnr="402127">
			<bestand>ja</bestand>
		</artikel>
		<artikel artnr="404398">
			<bestand>nein</bestand>
			<lieferwoche>36</lieferwoche>
		</artikel>
		<artikel artnr="405023">
			<bestand>ja</bestand>
		</artikel>
		<artikel artnr="405458">
			<bestand>ja</bestand>
		</artikel>
	</bestaende>
	<messages></messages>
</bestaende>
würde folgendes Array ausgeben:
PHP:
Array
(
    [bestaende] => Array
        (
            [-] => Array
                (
                )

            [+] => Array
                (
                    [bestaende] => Array
                        (
                            [0] => Array
                                (
                                    [+] => Array
                                        (
                                            [artikel] => Array
                                                (
                                                    [0] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [1] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [2] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [3] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [4] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [5] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => ja
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [6] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                    [lieferwoche] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => 36
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [7] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => ja
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [8] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => ja
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                )

                                        )

                                )

                        )

                    [messages] => Array
                        (
                            [0] => Array
                                (
                                    [+] => 
                                )

                        )

                )

        )

)
Unter "-" finden sich alle Attribute und unter "+" der Inhalt bzw. die Kinderknoten.
Nun meine Frage ist folgende:
Wie kann ich nun den Array in einen XML-String umwandeln? Dies muss sicherlich mit Rekursion geschehen! Doch wie weiß ich nicht! Ich probiere schon seit längerer Zeit daran herum und schaffe es nicht!

Schon mal Danke für's lesen,
CPU :(:(:(
 
ich hab mal schnell was vorbereitet, ich habs nicht gecheckt aber so müsste es funktionieren, ich hoff ich hab keinen Schreibfehler drinne:

PHP:
<?php
function parseArray($array)
{
	//Rückgabevariable
	$return = '';
	
	//alle Array Elemente durchgehen
	foreach($array as $element ==> $key)
	{
		//check ob das Arrayelemnt ein Array ist
		if(is_array($element)) //wenn ja, dann ruf rekursiv die Funktion nochmal auf
			$return .= '<'.$key.'>'.parseArray($element).'</'.$key.'>';
		else //wenn nicht, parse einfach das Element als XML
			$return .= '<'.$key.'>'.$element.'</'.$key.'>';
	}
	//Ausgabe
	return $return;
}
?>



edit!

Moment, ich hab den Thead falsch gelesen - das is garnicht die Antwort auf deine Frage, moment, ich bereite mal schnell nochwas vor :P
 
Habe es nicht getestet, aber ungefähr so:
PHP:
<?
function arrToXmlString($elementName, $arr){
	
	$innerXmlString = "";
	if($arr["+"] && count($arr["+"])>0){
		foreach($arr["+"] as $key=>$val){
			$innerXmlString.=arrToXmlString($key, $val);
		}
	}
	
	$attributeString="";
	if($arr["-"] && count($arr["-"])>0){
		foreach($arr["-"] as $key=>$val){
			$attributeString.=" $key=\"".htmlentities($val)."\"";
		}
	}
	
	return "<$elementName $attributeString>$innerXmlString</$elementName>";

}

$result = arrToXmlString("bestaende", $arr);
?>
 
Oh, danke ... :D *glücklich*

CPU
P.S.: Ich werd's gleich mal ausprobieren!! :freaky:
 
Leider funktioniert das Skript nicht ... Wenn ich den Array einsetzte, und das root-Element angebe, kommt nur
HTML:
<bestand ></bestand>

CPU :(
 
Du solltest den Aufruf evtl. so machen:
PHP:
$result = arrToXmlString("bestaende", $arr["bestaende"]);
Abgesehen davon antwortet dir keiner weil du es dir ja auch nicht zu einfach machen sollst ;). Du kannst davon ausgehen, dass mein Script auch nicht problemlos laufen wird, habe es nur so aus der Luft programmiert.
 
Also ich habe gerade noch mal eine halbe Stunde dran tumgebastelt, doch es funktioniert nicht ... :rolleyes:

Tja ....
 
Ich habe mir die Mühe gemacht es mal kurz anzusehen. Es scheint, dass der von dir erzeugte Array einen Fehler hat. Auszug:
PHP:
Array
(
    [bestaende] => Array
        (
            [-] => Array
                (
                )

            [+] => Array
                (
                    [bestaende] => Array
                        (
                            [0] => Array
                                (
                                    [+] => Array
                                        (
                                            [artikel] => Array
                                                (
                                                    [0] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                )

                                                        )

                                                    [1] => Array
                                                        (
                                                            [-] => 
                                                            [+] => Array
                                                                (
                                                                    [bestand] => Array
                                                                        (
                                                                            [0] => Array
                                                                                (
                                                                                    [+] => nein
                                                                                )

                                                                        )

                                                                )

                                                        )


                                                )

                                        )

                                )

                        )

                    [messages] => Array
                        (
                            [0] => Array
                                (
                                    [+] => 
                                )

                        )

                )

        )

)

  • In Level 1 (bestaende) folgen direkt +/- Elemente.
  • In Level 2 (nochmals bestaende) folgt ein numerisches Element [0], das seinerseits direkt +/- Elemente enthält
  • In Level 3 (artikel) folgen mehrere numerische Elemente (hier 0-1), die ihrerseits +/- Elemente enthalten

Ich finde das inkonsistent, das macht es für eine rekursion schwierig. Müsste es nicht eher so sein, dass Level 2 in seinem [+] Element mehrere artikel Elemente enthält, die jeweils wieder ein eigenes +/- Element enthalten?
 
Also, ich möchte nicht um den heißen Brei reden: ich versuche im moment eine XML-Klasse für PHP4 sowie PHP5 zu schreiben.

Eine bestehende Klasse zu nehmen wäre viel einfacher (man muss ja das Rad nicht nochmals erfinden :p), aber des geht leider aus gewissen Gründen nicht!
Daher habe ich mir mehrere Klassen besorgt und mir daraus eine "eigene" Klasse gebaut! Das Ergebnis gleicht aber der Klasse XMLize (hier)!

Also versuche ich dann mal eine wirklich eigene Klasse zu schreiben ... es sei denn, Ihr habt eine gute Idee!

CPU
(Danke für's zuhören!) :rolleyes:
 
Wie wärs mit sowas? (nur demo, kein test)

@Spezialisten: Ja ich weiß man kanns besser machen, mit nem schönen Composite, Interfaces usw....

PHP:
<?
class XmlElement {
	private $name;
	$attributes = array();
	$content = array();
	
	public function XmlElement($name){
		$this->name=$name;
	}
	
	public function setAttribute($key, $value){
		$this->attributes[$key]=$value;
	}
	
	public function getAttributes($key){
		return $this->attributes[$key];
	}
	
	public function getAttributeNames(){
		return array_keys($this->attributes);
	}
	
	public function getContent(){
		return $this->content;
	}
	
	public function addContent($obj){
		$this->content[] = $obj;
	}
	
	public function removeContent($obj){
		//... jetzt bist du dran
	}
}

class XmlText {
	private $text;
	public function XmlText($text){
		$this->text=$text;
	}
	
	public function getText(){
		return $this->text;
	}
	
	public function setText($value){
		$this->text = $value;
	}	
}

$subKnoten1 = new XmlElement("knoten");
$subKnoten1->addContent(new XmlText("nachricht1"));

$subKnoten2 = new XmlElement("knoten");
$subKnoten1->addContent(new XmlText("nachricht2"));

$subKnoten3 = new XmlElement("knoten");
$subKnoten1->addContent(new XmlText("nachricht3"));

$rootKnoten = new XmlElement("wurzel");
$rootKnoten->addContent($subKnoten1);
$rootKnoten->addContent($subKnoten2);
$rootKnoten->addContent($subKnoten3);

?>
 
Er darf ja keine bestehende Klasse verwenden... denn dann wäre DOM bzw. DOMXML bereits ausreichend.
 
Also, ich habe folgende Beschränkungen:
  • muss unter PHP5 und sollte unter PHP4 lauffähig sein
  • man sollte leicht auf die XML-Daten zugreifen können
  • man sollte diese leicht verändern können

Daher habe ich simpleXML zunächst abgelehnt, nun aber ist mir PHP4 egal - wer PHP4 auf seinem Server laufen hat hat pech gehabt! :evillol:

Nun eine kurze Frage zu simpleXML: Ich kann ja "objektorientiert" darauf zugreifen, d.h. das XML-Dokument wird in einem Objekt-Array gespeichert. Wie kann ich nun etwas ändern und wieder abspeichern?

Danke :freaky:
CPU
 
hier bitteschön:

PHP:
<?php
$xmlstr = <<<XML
<?xml version='1.0' standalone='yes'?>
<xml>
	<node>
		<sub>content</sub>
	</node>
</xml>
XML;

//simplexml initialisieren mit dem
//oben definierten test-xmlstring
$xml = new SimpleXMLElement($xmlstr);

//content ändern:
$xml->node[0]->sub = "even more content";

//neuen knoten hinzufügen
$node = $xml->addChild('node');
$node->addAttribute('type', 'unknown'); //ein Attribut
$node->addChild('sub', 'CONTENT'); //und einen knoten im knoten :-)

//ausgeben als xml
echo $xml->asXml();
?>
wenn du jetzt eine Datei hast kannst du dir das öffnen der Datei und einlesen in einen String und anschließendes initialisieren eines simplexml objektes sparen, dafür gibts bereits:
PHP:
$xml = simplexml_load_file('test.xml')
hat nämlich den selben effekt und du sparst die 2 zeilen code :P

und zum speichern... naja, business as usual halt

PHP:
$handle = fopen('test.xml', 'w');
fwrite($handle, $xml->asXml());
fclose($handle);


hat das deine Frage bezüglich ändern und wieder speichern beantwortet^^?
 
Zurück
Oben