Wie man Array zu SimpleXML konvertiert

Wie kann ich ein Array in PHP in ein SimpleXML-Objekt konvertieren?

ein kurzes:

< ?php $test_array = array ( 'bla' => 'blub', 'foo' => 'bar', 'another_array' => array ( 'stack' => 'overflow', ), ); $xml = new SimpleXMLElement(''); array_walk_recursive($test_array, array ($xml, 'addChild')); print $xml->asXML(); 

Ergebnisse in

 < ?xml version="1.0"?>  bla foo stack  

Schlüssel und Werte werden vertauscht – Sie könnten das mit array_flip() vor dem array_walk beheben. array_walk_recursive benötigt PHP 5. Sie könnten stattdessen array_walk verwenden, aber Sie werden dann im xml nicht 'stack' => 'overflow' .

Hier ist php 5.2 Code, der ein Array beliebiger Tiefe in xml-Dokument konvertiert:

 Array ( ['total_stud']=> 500 [0] => Array ( [student] => Array ( [id] => 1 [name] => abc [address] => Array ( [city]=>Pune [zip]=>411006 ) ) ) [1] => Array ( [student] => Array ( [id] => 2 [name] => xyz [address] => Array ( [city]=>Mumbai [zip]=>400906 ) ) ) ) 

generiertes XML wäre wie

 < ?xml version="1.0"?>  500  1 abc 
Pune 411006
1 abc
Mumbai 400906

PHP-Ausschnitt

 < ?php // function defination to convert array to xml function array_to_xml( $data, &$xml_data ) { foreach( $data as $key => $value ) { if( is_numeric($key) ){ $key = 'item'.$key; //dealing with <0/>.. issues } if( is_array($value) ) { $subnode = $xml_data->addChild($key); array_to_xml($value, $subnode); } else { $xml_data->addChild("$key",htmlspecialchars("$value")); } } } // initializing or creating array $data = array('total_stud' => 500); // creating object of SimpleXMLElement $xml_data = new SimpleXMLElement('< ?xml version="1.0"?>'); // function call to convert array to xml array_to_xml($data,$xml_data); //saving generated xml file; $result = $xml_data->asXML('/file/path/name.xml'); ?> 

Dokumentation zu SimpleXMLElement::asXML die in diesem Snippet verwendet wird

Die hier angegebenen Antworten konvertieren das Array nur in XML mit Knoten. Sie können keine Attribute festlegen. Ich habe eine PHP-function geschrieben, mit der Sie ein Array in PHP konvertieren und auch Attribute für bestimmte Knoten in der XML festlegen können. Der Nachteil hier ist, dass Sie ein Array in einer bestimmten Weise mit wenigen Konventionen konstruieren müssen (nur wenn Sie Attribute verwenden wollen)

Im folgenden Beispiel können Sie auch Attribute in XML festlegen.

Detailliertes Beispiel und Verwendung finden Sie hier: http://www.lalit.org/lab/convert-php-array-to-xml-with-attributes/

 < ?php $books = array( '@attributes' => array( 'type' => 'fiction' ), 'book' => array( array( '@attributes' => array( 'author' => 'George Orwell' ), 'title' => '1984' ), array( '@attributes' => array( 'author' => 'Isaac Asimov' ), 'title' => 'Foundation', 'price' => '$15.61' ), array( '@attributes' => array( 'author' => 'Robert A Heinlein' ), 'title' => 'Stranger in a Strange Land', 'price' => array( '@attributes' => array( 'discount' => '10%' ), '@value' => '$18.00' ) ) ) ); /* creates   1984   Foundation $15.61   Stranger in a Strange Land $18.00   */ ?> 

Ich habe alle Antworten gefunden, um zu viel Code zu verwenden. Hier ist ein einfacher Weg, es zu tun:

 function to_xml(SimpleXMLElement $object, array $data) { foreach ($data as $key => $value) { if (is_array($value)) { $new_object = $object->addChild($key); to_xml($new_object, $value); } else { // if the key is an integer, it needs text with it to actually work. if ($key == (int) $key) { $key = "key_$key"; } $object->addChild($key, $value); } } } 

Dann ist es eine einfache Sache, das Array in die function zu senden, die Rekursion verwendet, damit es ein mehrdimensionales Array behandelt:

 $xml = new SimpleXMLElement(''); to_xml($xml, $my_array); 

Jetzt enthält $ xml ein wunderschönes XML-Objekt, das auf Ihrem Array basiert, genau wie Sie es geschrieben haben.

 print $xml->asXML(); 
 < ? php
 Funktion array_to_xml (Array $ arr, SimpleXMLElement $ xml)
 {
     foreach ($ arr als $ k => $ v) {
         is_array ($ v)
             ?  array_to_xml ($ v, $ xml-> addChild ($ k))
             : $ xml-> addChild ($ k, $ v);
     }
     Zurückgeben von $ xml;
 }

 $ test_array = Array (
     'bla' => 'blub',
     'foo' => 'bar',
     'another_array' => Array (
         'stack' => 'Überlauf',
     ),
 );

 echo array_to_xml ($ test_array, neues SimpleXMLElement ('')) -> asXML ();

Ab PHP 5.4

 function array2xml($data, $root = null){ $xml = new SimpleXMLElement($root ? '< ' . $root . '/>' : ''); array_walk_recursive($data, function($value, $key)use($xml){ $xml->addChild($key, $value); }); return $xml->asXML(); } 

Eine weitere Verbesserung:

 /** * Converts an array to XML * * @param array $array * @param SimpleXMLElement $xml * @param string $child_name * * @return SimpleXMLElement $xml */ public function arrayToXML($array, SimpleXMLElement $xml, $child_name) { foreach ($array as $k => $v) { if(is_array($v)) { (is_int($k)) ? $this->arrayToXML($v, $xml->addChild($child_name), $v) : $this->arrayToXML($v, $xml->addChild(strtolower($k)), $child_name); } else { (is_int($k)) ? $xml->addChild($child_name, $v) : $xml->addChild(strtolower($k), $v); } } return $xml->asXML(); } 

Verwendung:

 $this->arrayToXML($array, new SimpleXMLElement(''), 'child_name_to_replace_numeric_integers'); 

Hier ist mein Eintrag, einfach und sauber ..

 function array2xml($array, $xml = false){ if($xml === false){ $xml = new SimpleXMLElement(''); } foreach($array as $key => $value){ if(is_array($value)){ array2xml($value, $xml->addChild($key)); }else{ $xml->addChild($key, $value); } } return $xml->asXML(); } header('Content-type: text/xml'); print array2xml($array); 

Wie auch immer … Ich nahm onokazu’s Code (danke!) Und fügte die Fähigkeit hinzu, wiederholt Tags in XML zu haben, es unterstützt auch Attribute, hoffe, dass jemand es nützlich findet!

  < ?php function array_to_xml(array $arr, SimpleXMLElement $xml) { foreach ($arr as $k => $v) { $attrArr = array(); $kArray = explode(' ',$k); $tag = array_shift($kArray); if (count($kArray) > 0) { foreach($kArray as $attrValue) { $attrArr[] = explode('=',$attrValue); } } if (is_array($v)) { if (is_numeric($k)) { array_to_xml($v, $xml); } else { $child = $xml->addChild($tag); if (isset($attrArr)) { foreach($attrArr as $attrArrV) { $child->addAttribute($attrArrV[0],$attrArrV[1]); } } array_to_xml($v, $child); } } else { $child = $xml->addChild($tag, $v); if (isset($attrArr)) { foreach($attrArr as $attrArrV) { $child->addAttribute($attrArrV[0],$attrArrV[1]); } } } } return $xml; } $test_array = array ( 'bla' => 'blub', 'foo' => 'bar', 'another_array' => array ( array('stack' => 'overflow'), array('stack' => 'overflow'), array('stack' => 'overflow'), ), 'foo attribute1=value1 attribute2=value2' => 'bar', ); $xml = array_to_xml($test_array, new SimpleXMLElement(''))->asXML(); echo "$xml\n"; $dom = new DOMDocument; $dom->preserveWhiteSpace = FALSE; $dom->loadXML($xml); $dom->formatOutput = TRUE; echo $dom->saveXml(); ?> 

Ich benutze ein paar functionen, die ich vor einiger Zeit geschrieben habe, um das XML aus PHP und jQuery usw. zu generieren. Weder verwenden Sie irgendwelche zusätzlichen Frameworks, sondern generieren lediglich einen String, der dann mit SimpleXML (oder einem anderen Framework) verwendet werden kann ) …

Wenn es für irgendjemanden nützlich ist, benutze es bitte 🙂

 function generateXML($tag_in,$value_in="",$attribute_in=""){ $return = ""; $attributes_out = ""; if (is_array($attribute_in)){ if (count($attribute_in) != 0){ foreach($attribute_in as $k=>$v): $attributes_out .= " ".$k."=\"".$v."\""; endforeach; } } return "< ".$tag_in."".$attributes_out.((trim($value_in) == "") ? "/>" : ">".$value_in."" ); } function arrayToXML($array_in){ $return = ""; $attributes = array(); foreach($array_in as $k=>$v): if ($k[0] == "@"){ // attribute... $attributes[str_replace("@","",$k)] = $v; } else { if (is_array($v)){ $return .= generateXML($k,arrayToXML($v),$attributes); $attributes = array(); } else if (is_bool($v)) { $return .= generateXML($k,(($v==true)? "true" : "false"),$attributes); $attributes = array(); } else { $return .= generateXML($k,$v,$attributes); $attributes = array(); } } endforeach; return $return; } 

Grüße an alle 🙂

Ich wollte einen Code, der alle Elemente innerhalb eines Arrays und behandelt sie als Attribute und alle Arrays als Unterelemente.

Also für sowas wie

 array ( 'row1' => array ('head_element' =>array("prop1"=>"some value","prop2"=>array("empty"))), "row2"=> array ("stack"=>"overflow","overflow"=>"overflow") ); 

Ich würde so etwas bekommen

 < ?xml version="1.0" encoding="utf-8"?>         

Um dies zu erreichen, ist der Code unten, aber sei sehr vorsichtig, es ist rekursiv und kann tatsächlich einen Stapelüberlauf verursachen 🙂

 function addElements(&$xml,$array) { $params=array(); foreach($array as $k=>$v) { if(is_array($v)) addElements($xml->addChild($k), $v); else $xml->addAttribute($k,$v); } } function xml_encode($array) { if(!is_array($array)) trigger_error("Type missmatch xml_encode",E_USER_ERROR); $xml=new SimpleXMLElement('< ?xml version=\'1.0\' encoding=\'utf-8\'?>< '.key($array).'/>'); addElements($xml,$array[key($array)]); return $xml->asXML(); } 

Möglicherweise möchten Sie Prüfungen für die Länge des Arrays hinzufügen, so dass einige Elemente innerhalb des Datenteils und nicht als Attribut gesetzt werden.

Basiert auf allem anderen hier, handhabt numerische Indizes + Attribute durch Voranstellen mit @ , und könnte xml zu bestehenden Knoten injizieren:

Code

 function simple_xmlify($arr, SimpleXMLElement $root = null, $el = 'x') { // based on, among others http://stackoverflow.com/a/1397164/1037948 if(!isset($root) || null == $root) $root = new SimpleXMLElement('< ' . $el . '/>'); if(is_array($arr)) { foreach($arr as $k => $v) { // special: attributes if(is_string($k) && $k[0] == '@') $root->addAttribute(substr($k, 1),$v); // normal: append else simple_xmlify($v, $root->addChild( // fix 'invalid xml name' by prefixing numeric keys is_numeric($k) ? 'n' . $k : $k) ); } } else { $root[0] = $arr; } return $root; }//-- fn simple_xmlify 

Verwendung

 // lazy declaration via "queryparam" $args = 'hello=4&var[]=first&var[]=second&foo=1234&var[5]=fifth&var[sub][]=sub1&var[sub][]=sub2&var[sub][]=sub3&var[@name]=the-name&var[@attr2]=something-else&var[sub][@x]=4.356&var[sub][@y]=-9.2252'; $q = array(); parse_str($val, $q); $xml = simple_xmlify($q); // dump $xml, or... $result = get_formatted_xml($xml); // see below 

Ergebnis

 < ?xml version="1.0"?>  4  first second fifth  sub1 sub2 sub3   1234  

Bonus: Formatieren von XML

 function get_formatted_xml(SimpleXMLElement $xml, $domver = null, $preserveWhitespace = true, $formatOutput = true) { // http://stackoverflow.com/questions/1191167/format-output-of-simplexml-asxml // create new wrapper, so we can get formatting options $dom = new DOMDocument($domver); $dom->preserveWhiteSpace = $preserveWhitespace; $dom->formatOutput = $formatOutput; // now import the xml (converted to dom format) /* $ix = dom_import_simplexml($xml); $ix = $dom->importNode($ix, true); $dom->appendChild($ix); */ $dom->loadXML($xml->asXML()); // print return $dom->saveXML(); }//-- fn get_formatted_xml 

Hier ist eine function, die mir geholfen hat:

Nennen Sie es einfach mit etwas wie

 echo arrayToXml("response",$arrayIWantToConvert); function arrayToXml($thisNodeName,$input){ if(is_numeric($thisNodeName)) throw new Exception("cannot parse into xml. remainder :".print_r($input,true)); if(!(is_array($input) || is_object($input))){ return "< $thisNodeName>$input"; } else{ $newNode="< $thisNodeName>"; foreach($input as $key=>$value){ if(is_numeric($key)) $key=substr($thisNodeName,0,strlen($thisNodeName)-1); $newNode.=arrayToXml3($key,$value); } $newNode.=""; return $newNode; } } 

Sie könnten den XMLParser verwenden , an dem ich gearbeitet habe.

 $xml = XMLParser::encode(array( 'bla' => 'blub', 'foo' => 'bar', 'another_array' => array ( 'stack' => 'overflow', ) )); // @$xml instanceof SimpleXMLElement echo $xml->asXML(); 

Würde ergeben:

 < ?xml version="1.0"?>  blub bar  overflow   

Ich fand diese Lösung ähnlich wie das ursprüngliche Problem

 < ?php $test_array = array ( 'bla' => 'blub', 'foo' => 'bar', 'another_array' => array ( 'stack' => 'overflow', ), ); class NoSimpleXMLElement extends SimpleXMLElement { public function addChild($name,$value) { parent::addChild($value,$name); } } $xml = new NoSimpleXMLElement(''); array_walk_recursive($test_array, array ($xml, 'addChild')); print $xml->asXML(); 

Die meisten der obigen Antworten sind korrekt. Allerdings habe ich diese Antwort gefunden, die das array_walk_recursive Kompatibilitätsproblem und auch das numerische Schlüsselproblem triggers. Es hat auch alle Tests bestanden, die ich gemacht habe:

 function arrayToXML(Array $array, SimpleXMLElement &$xml) { foreach($array as $key => $value) { // None array if (!is_array($value)) { (is_numeric($key)) ? $xml->addChild("item$key", $value) : $xml->addChild($key, $value); continue; } // Array $xmlChild = (is_numeric($key)) ? $xml->addChild("item$key") : $xml->addChild($key); arrayToXML($value, $xmlChild); } } 

Ich habe dafür auch eine Testklasse hinzugefügt, die Sie vielleicht nützlich finden:

 class ArrayToXmlTest extends PHPUnit_Framework_TestCase { public function setUp(){ } public function tearDown(){ } public function testFuncExists() { $this->assertTrue(function_exists('arrayToXML')); } public function testFuncReturnsXml() { $array = array( 'name' => 'ardi', 'last_name' => 'eshghi', 'age' => 31, 'tel' => '0785323435' ); $xmlEl = new SimpleXMLElement(''); arrayToXml($array, $xmlEl); $this->assertTrue($xmlEl instanceOf SimpleXMLElement); } public function testAssocArrayToXml() { $array = array( 'name' => 'ardi', 'last_name' => 'eshghi', 'age' => 31, 'tel' => '0785323435' ); $expectedXmlEl = new SimpleXMLElement(''); $expectedXmlEl->addChild('name', $array['name']); $expectedXmlEl->addChild('last_name', $array['last_name']); $expectedXmlEl->addChild('age', $array['age']); $expectedXmlEl->addChild('tel', $array['tel']); $actualXmlEl = new SimpleXMLElement(''); arrayToXml($array, $actualXmlEl); $this->assertEquals($expectedXmlEl->asXML(), $actualXmlEl->asXML()); } public function testNoneAssocArrayToXml() { $array = array( 'ardi', 'eshghi', 31, '0785323435' ); // Expected xml value $expectedXmlEl = new SimpleXMLElement(''); foreach($array as $key => $value) $expectedXmlEl->addChild("item$key", $value); // What the function produces $actualXmlEl = new SimpleXMLElement(''); arrayToXml($array, $actualXmlEl); $this->assertEquals($expectedXmlEl->asXML(), $actualXmlEl->asXML()); } public function testNestedMixArrayToXml() { $testArray = array( "goal", "nice", "funny" => array( 'name' => 'ardi', 'tel' =>'07415517499', "vary", "fields" => array( 'small', 'email' => 'ardi.eshghi@gmail.com' ), 'good old days' ), "notes" => "come on lads lets enjoy this", "cast" => array( 'Tom Cruise', 'Thomas Muller' => array('age' => 24) ) ); // Expected xml value $expectedXmlEl = new SimpleXMLElement(''); $expectedXmlEl->addChild('item0', $testArray[0]); $expectedXmlEl->addChild('item1', $testArray[1]); $childEl = $expectedXmlEl->addChild('funny'); $childEl->addChild("name", $testArray['funny']['name']); $childEl->addChild("tel", $testArray['funny']['tel']); $childEl->addChild("item0", "vary"); $childChildEl = $childEl->addChild("fields"); $childChildEl->addChild('item0', 'small'); $childChildEl->addChild('email', $testArray['funny']['fields']['email']); $childEl->addChild("item1", 'good old days'); $expectedXmlEl->addChild('notes', $testArray['notes']); $childEl2 = $expectedXmlEl->addChild('cast'); $childEl2->addChild('item0', 'Tom Cruise'); $childChildEl2 = $childEl2->addChild('Thomas Muller'); $childChildEl2->addChild('age', $testArray['cast']['Thomas Muller']['age']); // What the function produces $actualXmlEl = new SimpleXMLElement(''); arrayToXml($testArray, $actualXmlEl); $this->assertEquals($expectedXmlEl->asXML(), $actualXmlEl->asXML()); } } 

andere Lösung:

 $marray=array(....); $options = array( "encoding" => "UTF-8", "output_type" => "xml", "version" => "simple", "escaping" => array("non-ascii, on-print, markup") ); $xmlres = xmlrpc_encode_request('root', $marray, $options); print($xmlres); 

Wenn das Array assoziativ ist und korrekt codiert ist, ist es wahrscheinlich einfacher, es zuerst in xml umzuwandeln. Etwas wie:

  function array2xml ($array_item) { $xml = ''; foreach($array_item as $element => $value) { if (is_array($value)) { $xml .= "< $element>".array2xml($value).""; } elseif($value == '') { $xml .= "< $element />"; } else { $xml .= "< $element>".htmlentities($value).""; } } return $xml; } $simple_xml = simplexml_load_string(array2xml($assoc_array)); 

Die andere Route wäre, zuerst Ihre Basis-XML zu erstellen

 $simple_xml = simplexml_load_string(""); 

und dann für jeden Teil Ihres Arrays, verwenden Sie etwas ähnlich zu meinem Text erstellen Schleife und stattdessen die simplexx functionen “addChild” für jeden Knoten des Arrays.

Ich werde das später ausprobieren und diesen Post mit beiden Versionen aktualisieren.

Nur eine Bearbeitung für eine function über, wenn eine Taste numerisch ist, fügen Sie ein Präfix “key_”

 // initializing or creating array $student_info = array(your array data); // creating object of SimpleXMLElement $xml_student_info = new SimpleXMLElement("< ?xml version=\"1.0\"?>"); // function call to convert array to xml array_to_xml($student,$xml_student_info); //saving generated xml file $xml_student_info->asXML('file path and name'); function array_to_xml($student_info, &$xml_student_info) { foreach($student_info as $key => $value) { if(is_array($value)) { if(!is_numeric($key)){ $subnode = $xml_student_info->addChild("$key"); array_to_xml($value, $subnode); } else{ $subnode = $xml_student_info->addChild("key_$key"); array_to_xml($value, $subnode); } } else { if(!is_numeric($key)){ $xml_student_info->addChild("$key","$value"); }else{ $xml_student_info->addChild("key_$key","$value"); } } } } 

Sie können die folgende function in Ihrem Code direkt verwenden,

  function artoxml($arr, $i=1,$flag=false){ $sp = ""; for($j=0;$j< =$i;$j++){ $sp.=" "; } foreach($arr as $key=>$val){ echo "$sp<".$key.">"; if($i==1) echo "\n"; if(is_array($val)){ if(!$flag){echo"\n";} artoxml($val,$i+5); echo "$sp</".$key.">\n"; }else{ echo "$val"."</".$key.">\n"; } } } 

Rufen Sie die function mit dem ersten Argument als Array auf und das zweite Argument muss 1 sein, das wird für den perfekten Einzug erhöht, und der dritte muss wahr sein.

Wenn beispielsweise die Array-Variable, die konvertiert werden soll, $ array1 ist, dann würde Calling Function mit


-Tag gekapselt werden.

  artoxml ($ array1,1, true); 

Bitte beachten Sie die Seitenquelle nach dem Ausführen der Datei, da die Symbole nicht in einer HTML-Seite angezeigt werden.

 function toXML($data, $obj = false, $dom) { $is_first_level = false; if($obj === false) { $dom = new DomDocument('1.0'); $obj = $dom; $is_first_level = true; } if(is_array($data)) { foreach($data as $key => $item) { $this->toXML($item, $obj->appendChild($dom->createElement($key)), $dom); } }else { $obj->appendChild($dom->createTextNode($data)); } if($is_first_level) { $obj->formatOutput = true; return $obj->saveXML(); } return $obj; } 

Mit FluidXML können Sie ausgehend von einem PHP-Array ein XML für SimpleXML mit … nur zwei Codezeilen generieren.

 $fluidxml = fluidxml($array); $simplexml = simplexml_import_dom($fluidxml->dom()); 

Ein Beispiel-Array könnte sein

 $array = [ 'doc' => [ 'fruit' => 'orange', 'cake' => [ '@id' => '123', '@' => 'tiramisu' ], [ 'pasta' => 'matriciana' ], [ 'pasta' => 'boscaiola' ] ] ]; 

https://github.com/servo-php/fluidxml

Sie können xmlrpc_encode verwenden, um ein xml from array zu erstellen, wenn ein ausführliches xml kein Problem darstellt. http://www.php.net/xmlrpc_encode

Achten Sie darauf, dass die erstellte XML-Datei anders ist, wenn Sie assoziative und / oder numerische Schlüssel verwenden

 < ?php // /params/param/value/struct/member // there is a tag "member" for each element // "member" contains a tag "name". its value is the associative key $xml1 = xmlrpc_encode(array('a'=>'b','c'=>'d')); $simplexml1 = simplexml_load_string($xml1); print_r($xml1); print_r($simplexml1); // /params/param/value/array/data // there is a tag "data" for each element // "data" doesn't contain the tag "name" $xml2 = xmlrpc_encode(array('a','b')); $simplexml2 = simplexml_load_string($xml2); print_r($xml2); print_r($simplexml2); ?> 
 function array2xml($array, $xml = false){ if($xml === false){ $xml = new SimpleXMLElement('< ?xml version=\'1.0\' encoding=\'utf-8\'?>< '.key($array).'/>'); $array = $array[key($array)]; } foreach($array as $key => $value){ if(is_array($value)){ $this->array2xml($value, $xml->addChild($key)); }else{ $xml->addChild($key, $value); } } return $xml->asXML(); } 

Meine Antwort, die Antworten anderer zusammengeschustert. Dies sollte korrigieren, wenn numerische Tasten nicht kompensiert werden:

 function array_to_xml($array, $root, $element) { $xml = new SimpleXMLElement("< {$root}/>"); foreach ($array as $value) { $elem = $xml->addChild($element); xml_recurse_child($elem, $value); } return $xml; } function xml_recurse_child(&$node, $child) { foreach ($child as $key=>$value) { if(is_array($value)) { foreach ($value as $k => $v) { if(is_numeric($k)){ xml_recurse_child($node, array($key => $v)); } else { $subnode = $node->addChild($key); xml_recurse_child($subnode, $value); } } } else { $node->addChild($key, $value); } } } 

Die function array_to_xml() voraus, dass das Array zuerst aus numerischen Schlüsseln besteht. Wenn Ihr Array ein initiales Element hätte, würden Sie die statementen foreach() und $elem von der function array_to_xml() und stattdessen einfach $xml .

Ich hätte die am zweithäufigsten gewählte Antwort kommentiert, weil sie nicht die Struktur erhält und schlechtes xml erzeugt, wenn es numerisch indizierte innere Arrays gibt.

Ich habe meine eigene Version darauf basierend entwickelt, weil ich unabhängig von der Struktur der Daten einen einfachen Konverter zwischen json und xml brauchte. Meine Version behält die numerischen Schlüsselinformationen und die Struktur des ursprünglichen Arrays bei. Er erstellt Elemente für die numerisch indizierten Werte, indem er Werte mit value -named Elementen mit Schlüsselattribut, das numerische Schlüssel enthält, umschließt.

Beispielsweise

array('test' => array(0 => 'some value', 1 => 'other'))

konvertiert zu

some valueother

Meine Version von array_to_xml -function (hoffe es hilft jemandem 🙂

 function array_to_xml($arr, &$xml) { foreach($arr as $key => $value) { if(is_array($value)) { if(!is_numeric($key)){ $subnode = $xml->addChild("$key"); } else { $subnode = $xml->addChild("value"); $subnode->addAttribute('key', $key); } array_to_xml($value, $subnode); } else { if (is_numeric($key)) { $xml->addChild("value", $value)->addAttribute('key', $key); } else { $xml->addChild("$key",$value); } } } } 

Die gesamte XML-Struktur ist in $ data Array definiert:

 function array2Xml($data, $xml = null) { if (is_null($xml)) { $xml = simplexml_load_string('< ' . key($data) . '/>'); $data = current($data); $return = true; } if (is_array($data)) { foreach ($data as $name => $value) { array2Xml($value, is_numeric($name) ? $xml : $xml->addChild($name)); } } else { $xml->{0} = $data; } if (!empty($return)) { return $xml->asXML(); } } 

Wenn Sie in Magento arbeiten und diese Art von assoziativem Array haben

 $test_array = array ( '0' => array ( 'category_id' => '582', 'name' => 'Surat', 'parent_id' => '565', 'child_id' => '567', 'active' => '1', 'level' => '6', 'position' => '17' ), '1' => array ( 'category_id' => '567', 'name' => 'test', 'parent_id' => '0', 'child_id' => '576', 'active' => '0', 'level' => '0', 'position' => '18' ), ); 

Am besten konvertieren Sie das assoziative Array in das XML-Format. Verwenden Sie diesen Code in der Controller-Datei.

 $this->loadLayout(false); //header ("content-type: text/xml"); $this->getResponse()->setHeader('Content-Type','text/xml'); $this->renderLayout(); $clArr2xml = new arr2xml($test_array, 'utf-8', 'listdata'); $output = $clArr2xml->get_xml(); print $output; class arr2xml { var $array = array(); var $xml = ''; var $root_name = ''; var $charset = ''; public function __construct($array, $charset = 'utf-8', $root_name = 'root') { header ("content-type: text/xml"); $this->array = $array; $this->root_name = $root_name; $this->charset = $charset; if (is_array($array) && count($array) > 0) { $this->struct_xml($array); } else { $this->xml .= "no data"; } } public function struct_xml($array) { foreach ($array as $k => $v) { if (is_array($v)) { $tag = ereg_replace('^[0-9]{1,}', 'item', $k); // replace numeric key in array to 'data' $this->xml .= "< $tag>"; $this->struct_xml($v); $this->xml .= ""; } else { $tag = ereg_replace('^[0-9]{1,}', 'item', $k); // replace numeric key in array to 'data' $this->xml .= "< $tag>< ![CDATA[$v]]>"; } } } public function get_xml() { $header = "< ?xml version=\"1.0\" encoding=\"" . $this->charset . "\"?>< " . $this->root_name . ">"; $footer = "root_name . ">"; return $header . $this->xml . $footer; } } 

I hope it helps to all.

 // Structered array for XML convertion. $data_array = array( array( '#xml_tag' => 'a', '#xml_value' => '', '#tag_attributes' => array( array( 'name' => 'a_attr_name', 'value' => 'a_attr_value', ), ), '#subnode' => array( array( '#xml_tag' => 'aa', '#xml_value' => 'aa_value', '#tag_attributes' => array( array( 'name' => 'aa_attr_name', 'value' => 'aa_attr_value', ), ), '#subnode' => FALSE, ), ), ), array( '#xml_tag' => 'b', '#xml_value' => 'b_value', '#tag_attributes' => FALSE, '#subnode' => FALSE, ), array( '#xml_tag' => 'c', '#xml_value' => 'c_value', '#tag_attributes' => array( array( 'name' => 'c_attr_name', 'value' => 'c_attr_value', ), array( 'name' => 'c_attr_name_1', 'value' => 'c_attr_value_1', ), ), '#subnode' => array( array( '#xml_tag' => 'ca', '#xml_value' => 'ca_value', '#tag_attributes' => FALSE, '#subnode' => array( array( '#xml_tag' => 'caa', '#xml_value' => 'caa_value', '#tag_attributes' => array( array( 'name' => 'caa_attr_name', 'value' => 'caa_attr_value', ), ), '#subnode' => FALSE, ), ), ), ), ), ); // creating object of SimpleXMLElement $xml_object = new SimpleXMLElement('< ?xml version=\"1.0\"?>'); // function call to convert array to xml array_to_xml($data_array, $xml_object); // saving generated xml file $xml_object->asXML('/tmp/test.xml'); /** * Converts an structured PHP array to XML. * * @param Array $data_array * The array data for converting into XML. * @param Object $xml_object * The SimpleXMLElement Object * * @see https://gist.github.com/drupalista-br/9230016 * */ function array_to_xml($data_array, &$xml_object) { foreach($data_array as $node) { $subnode = $xml_object->addChild($node['#xml_tag'], $node['#xml_value']); if ($node['#tag_attributes']) { foreach ($node['#tag_attributes'] as $tag_attributes) { $subnode->addAttribute($tag_attributes['name'], $tag_attributes['value']); } } if ($node['#subnode']) { array_to_xml($node['#subnode'], $subnode); } } } 

the following deals with namespaces. In this case, you construct the wrapper to include the namespace definitions, and pass it into the function. use a colon to identify the namespace.

Test Array

 $inarray = []; $inarray['p:apple'] = "red"; $inarray['p:pear'] = "green"; $inarray['p:peach'] = "orange"; $inarray['p1:grocers'] = ['p1:local' => "cheap", 'p1:imported' => "expensive"]; $xml = new SimpleXMLElement( 'addChild($key,null,$nspace); array_to_xml($new_object, $value); } else { $key = is_numeric($key) ? "item$key" : $key; $object->addChild($key, $value,$nspace); } } }