Comment convertir le tableau de SimpleXML

Ici est php 5.2 code qui va le transformer en tableau de toute la profondeur de document xml:

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
                        )   
                )

        )
)

XML généré serait que:

<?xml version="1.0"?>
<student_info>
    <total_stud>500</total_stud>
    <student>
        <id>1</id>
        <name>abc</name>
        <address>
            <city>Pune</city>
            <zip>411006</zip>
        </address>
    </student>
    <student>
        <id>1</id>
        <name>abc</name>
        <address>
            <city>Mumbai</city>
            <zip>400906</zip>
        </address>
    </student>
</student_info>

Bout de code PHP

<?php
//function definition 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/>..<n/> 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"?><data></data>');

//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');

?>

Documentation sur SimpleXMLElement::asXML est utilisé dans cet extrait de code

J'ai trouvé toutes les réponses à utiliser trop de code. Voici un moyen facile de le faire:

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);
        }   
    }   
}   

Ensuite, c'est une simple question d'envoyer le tableau dans la fonction, qui utilise la récursivité, il va gérer un tableau multidimensionnel:

$xml = new SimpleXMLElement('<rootTag/>');
to_xml($xml, $my_array);

Maintenant $xml contient un bel objet XML basé sur votre tableau de exactement comment vous l'avez écrit.

print $xml->asXML();

De PHP 5.4

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

Voici mon entrée, simple et propre..

function array2xml($array, $xml = false){
    if($xml === false){
        $xml = new SimpleXMLElement('<root/>');
    }
    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);

Je utiliser un couple de fonctions que j'ai écrit tout à l'arrière pour générer le xml pour passer en arrière et en avant à partir de PHP et jQuery etc...
Ni un cadres purement génère une chaîne de caractères qui peut ensuite être utilisé avec SimpleXML (ou les autres)...

Si c'est utile à quelqu'un, merci de l'utiliser 🙂

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."</".$tag_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;
}   

De l'amour à tous 🙂

Basé sur tout le reste ici, les poignées des indices numériques + attributs via les préfixant avec @, et pourrait injecter xml pour les nœuds existants:

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

Utilisation

//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

Résultat

<?xml version="1.0"?>
<x>
<hello>4</hello>
<var name="the-name" attr2="something-else">
<n0>first</n0>
<n1>second</n1>
<n5>fifth</n5>
<sub x="4.356" y="-9.2252">
<n0>sub1</n0>
<n1>sub2</n1>
<n2>sub3</n2>
</sub>
</var>
<foo>1234</foo>
</x>

Bonus: le Formatage 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

Vous pouvez utiliser le XMLParser que j'ai été travailler sur.

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

Dans

<?xml version="1.0"?>
<root>
<bla>blub</bla>
<foo>bar</foo>
<another_array>
<stack>overflow</stack>
</another_array>
</root>

La plupart des réponses ci-dessus sont correctes. Cependant, je suis venu avec cette réponse qui résout le array_walk_recursive problème de compatibilité et aussi les touches numériques de problème. Il a également passé tous les tests que j'ai fait:

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);
}
}   

J'ai aussi ajouté une classe de test pour ce qui pourront vous être utiles:

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('<root/>');
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('<root/>'); 
$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('<root/>');
arrayToXml($array, $actualXmlEl);
$this->assertEquals($expectedXmlEl->asXML(), $actualXmlEl->asXML());
}
public function testNoneAssocArrayToXml() {
$array = array(
'ardi',
'eshghi',
31,
'0785323435'
);
//Expected xml value
$expectedXmlEl = new SimpleXMLElement('<root/>'); 
foreach($array as $key => $value)
$expectedXmlEl->addChild("item$key", $value);
//What the function produces       
$actualXmlEl =  new SimpleXMLElement('<root/>');
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' => '[email protected]'
),
'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('<root/>'); 
$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('<root/>');
arrayToXml($testArray, $actualXmlEl);
$this->assertEquals($expectedXmlEl->asXML(), $actualXmlEl->asXML());
}
}      

SI le tableau est associative et saisies correctement, il serait probablement plus facile de le transformer en xml en premier. Quelque chose comme:

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

L'autre voie serait de créer votre base xml d'abord, comme

$simple_xml = simplexml_load_string("<array></array>");

puis pour chaque partie de votre tableau, utiliser quelque chose de similaire à mon texte de la création de boucle et d'utiliser plutôt la simplexml fonctions "addChild" pour chaque nœud de la matrice.

Je vais essayer ça plus tard et de mettre à jour ce post avec les deux versions.

Vous pouvez Utiliser la fonction suivante dans votre code directement,

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

Appeler la fonction avec le premier argument comme votre tableau et le deuxième argument doit être de 1, ce sera augmenté pour une parfaite mise en retrait, et le troisième doit être vrai.

par exemple, si la variable tableau à convertir est $array1 puis,
l'appel, l'appel de fonction doit être encapsulé avec <pre> tag.

 artoxml($array1,1,true); 

Veuillez voir le source de la page après l'exécution du fichier, parce que le < et > les symboles ne sont pas affichées dans une page html.

Avec FluidXML vous pouvez générer, à partir d'une Tableau PHP, XML pour SimpleXML avec... seulement deux lignes de code.

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

Un exemple de tableau pourrait être

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

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

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();
}

J'aurais commenté la deuxième plus voté réponse, parce qu'elle ne préserve pas de la structure et génère une mauvaise xml si il est indexé numériquement intérieur des tableaux.

J'ai développé ma propre version basée sur elle, parce que j'avais besoin de convertisseur simple entre json et xml indépendamment de la structure de données. Ma version conserve touche numérique, de l'information et de la structure du tableau d'origine. Il permet de créer des éléments pour la indexé numériquement les valeurs par emballage de valeurs valeur nommée éléments-clés de l'attribut qui contient touche numérique.

Par exemple

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

convertit à

<test><value key="0">some value</value><value key="1">other</value></test>

Ma version de array_to_xml -fonction (espérons que cela aide quelqu'un 🙂

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);
}
}
}
}   

Si vous travaillez dans magento et vous avez ce type de tableau associatif

$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'
),
);

alors c'est préférable de les convertir en tableau associatif au format xml.Utiliser ce code dans le fichier contrôleur.

$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 .= "</$tag>";
} else {
$tag = ereg_replace('^[0-9]{1,}', 'item', $k); //replace numeric key in array to 'data'
$this->xml .= "<$tag><![CDATA[$v]]></$tag>";
}
}
}
public function get_xml()
{
$header = "<?xml version=\"1.0\" encoding=\"" . $this->charset . "\"?><" . $this->root_name . ">";
$footer = "</" . $this->root_name . ">";
return $header . $this->xml . $footer;
}
}

J'espère que cela aide à tous.

le suivant traite avec des espaces de noms. Dans ce cas, vous construisez le wrapper pour inclure l'espace de noms des définitions, et la passer dans la fonction. utilisez une virgule pour identifier l'espace de noms.

Test Tableau

$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( '<p:wrapper xmlns:p="http://namespace.org/api" xmlns:p1="http://namespace.org/api2 /> ');
array_to_xml($xml,$inarray); 
function array_to_xml(SimpleXMLElement $object, array $data)
{   
$nslist = $object->getDocNamespaces();
foreach ($data as $key => $value)
{   
$nspace = null;
$keyparts = explode(":",$key,2);
if ( count($keyparts)==2) 
$nspace = $nslist[$keyparts[0]];
if (is_array($value))
{   
$key = is_numeric($key) ? "item$key" : $key;
$new_object = $object->addChild($key,null,$nspace);
array_to_xml($new_object, $value);
}   
else
{   
$key = is_numeric($key) ? "item$key" : $key;
$object->addChild($key, $value,$nspace);
}   
}   
}   

Vous pouvez le faire par DOM aussi. Veuillez voir ci-dessous le code.

<?php
$el = array();
$command = array();
$dom = new DOMDocument('1.0', 'utf-8');
$dom->formatOutput = true;
$xml_array = [
'root'=>[
'Good guy' => [
'name' => [
'_cdata' => 'Luke Skywalker'
],
'weapon' => 'Lightsaber'
],
'Bad guy' => [
'name' => 'Sauron',
'weapon' => 'Evil Eye'
]
]
];
convert_xml($xml_array);
if(!empty($el))
{
$dom->appendChild(end($el));
}
echo $dom->saveXML();
?>
<?php
function convert_xml($Xml)
{
global $el, $dom;
foreach($Xml as $id=>$val)
{
if(is_numeric($id))
{
$id = "Item".($id);
}
$id = str_replace(' ', '-', strtolower($id));
if(is_array($val))
{
$ele = $dom->createElement($id);
array_push($el, $ele);
convert_xml($val);
}
else
{
$ele = $dom->createElement($id, $val);
if(!empty($el))
{
$com = end($el)->appendChild($ele);
}
else
{
$dom->appendChild($ele);
}
}
}
if(sizeof($el) > 1)
{
$child = end($el);
$com = prev($el)->appendChild($child);
array_pop($el);
}
}
?>