কীভাবে আমি পিএইচপি-তে একটি অ্যারেরকে সিম্পল এক্সএমএল অবজেক্টে রূপান্তর করতে পারি?
কীভাবে আমি পিএইচপি-তে একটি অ্যারেরকে সিম্পল এক্সএমএল অবজেক্টে রূপান্তর করতে পারি?
উত্তর:
একটি সংক্ষিপ্ত এক:
<?php
$test_array = array (
'bla' => 'blub',
'foo' => 'bar',
'another_array' => array (
'stack' => 'overflow',
),
);
$xml = new SimpleXMLElement('<root/>');
array_walk_recursive($test_array, array ($xml, 'addChild'));
print $xml->asXML();
ফলাফল স্বরূপ
<?xml version="1.0"?>
<root>
<blub>bla</blub>
<bar>foo</bar>
<overflow>stack</overflow>
</root>
কী এবং মানগুলি অদলবদল হয় - আপনি array_flip()
অ্যারে_ওয়াকের আগে এটি ঠিক করতে পারেন । array_walk_recursive
পিএইচপি 5 প্রয়োজন। আপনি array_walk
পরিবর্তে ব্যবহার করতে পারেন , তবে আপনি 'stack' => 'overflow'
এক্সএমএল পাবেন না ।
array_flip
যেমন না উল্টানো অ্যারে (যেমন করতে পারেন কাজ করবে না another_array
প্রধান অ্যারের ভিতরে)।
array_flip
কেবলমাত্র যদি অ্যারেতে কোনও অভিন্ন মান না থাকে কেবল তখনই কাজ করে।
এখানে পিএইচপি 5.2 কোড যা কোনও গভীরতার অ্যারেটিকে 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 হবে:
<?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>
পিএইচপি স্নিপেট
<?php
// function defination to convert array to xml
function array_to_xml( $data, &$xml_data ) {
foreach( $data as $key => $value ) {
if( is_array($value) ) {
if( is_numeric($key) ){
$key = 'item'.$key; //dealing with <0/>..<n/> issues
}
$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');
?>
এখানে প্রদত্ত উত্তরগুলি কেবল অ্যারেগুলিকে নোডের সাথে এক্সএমএলে রূপান্তর করে, আপনি গুণাবলী সেট করতে সক্ষম নন। আমি একটি পিএইচপি ফাংশন লিখেছি যা আপনাকে পিএইচপিতে একটি অ্যারে রূপান্তর করতে এবং এক্সএমএলে নির্দিষ্ট নোডের জন্য বৈশিষ্ট্যও সেট করতে দেয়। ডাউনসাইডটি হ'ল আপনাকে কয়েকটি কনভেনশন নিয়ে একটি নির্দিষ্ট উপায়ে একটি অ্যারে তৈরি করতে হবে (কেবলমাত্র যদি আপনি বৈশিষ্ট্যগুলি ব্যবহার করতে চান)
নিম্নলিখিত উদাহরণটি আপনাকে এক্সএমএলেও অ্যাট্রিবিউট সেট করতে দেয়।
উত্সটি এখানে পাওয়া যাবে: https://github.com / ডিজিটিককেটস / ল্লেট / ব্লব / মাস্টার / src / Array2XML.php
<?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
<books type="fiction">
<book author="George Orwell">
<title>1984</title>
</book>
<book author="Isaac Asimov">
<title>Foundation</title>
<price>$15.61</price>
</book>
<book author="Robert A Heinlein">
<title>Stranger in a Strange Land</title>
<price discount="10%">$18.00</price>
</book>
</books>
*/
?>
if(!is_array($arr)) {
করতে if(!is_array($arr) && $arr !== '') {
যাতে এটি খালি স্ট্রিং জন্য একটি নতুন টেক্সট নোড যোগ করা হবে না এবং এর ফলে সাধারণভাবে সংক্ষেপে খালি ট্যাগ বিন্যাস রাখে অর্থাত 'tag'=>''
হয় <tag/>
পরিবর্তে<tag></tag>
আমি খুব বেশি কোড ব্যবহার করার জন্য উত্তরগুলি পেয়েছি। এটি করার একটি সহজ উপায় এখানে:
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);
}
}
}
তারপরে এটি ফাংশনে অ্যারে প্রেরণের একটি সহজ বিষয়, যা পুনরাবৃত্তি ব্যবহার করে, সুতরাং এটি একটি বহুমাত্রিক অ্যারে পরিচালনা করবে:
$xml = new SimpleXMLElement('<rootTag/>');
to_xml($xml, $my_array);
এখন $ xML- এ আপনার অ্যারের ভিত্তিতে একটি সুন্দর এক্সএমএল অবজেক্ট রয়েছে ঠিক কীভাবে আপনি এটি লিখেছিলেন।
print $xml->asXML();
if ( is_numeric( $key ) ) $key = "numeric_$key";
।
$xml = new SimpleXMLElement('<?xml version="1.0" encoding="UTF-8" ?><rootTag/>');
বৈধ ইউটিএফ -8 এনকোডিংয়ের জন্য পরিবর্তন করেছি ।
$object->addChild($key, $value);
করতে চাইতে পারেন $object->addChild($key, htmlspecialchars($value));
।
<? PHP ফাংশন অ্যারে_টো_এক্সএমএল (অ্যারে $ আরআর, সিম্পল এক্সএমলেমেন্ট $ এক্সএমএল) { foreach ($ k => = ভি হিসাবে $ আরআর) { is_array (উ $) ? অ্যারে_টো_এক্সএমএল ($ v, $ xML-> অ্যাডচাইল্ড ($ কে)) : $ xML-> অ্যাডচিল্ড ($ কে, $ ভি); } প্রত্যাবর্তন $ এক্সএমএল; } $ test_array = অ্যারে ( 'bla' => 'ব্লাব', 'foo' => 'বার', 'another_array' => অ্যারে ( 'স্ট্যাক' => 'ওভারফ্লো', ), ); প্রতিধ্বনি অ্যারে_টো_এক্সএমএল ($ পরীক্ষা_আররে, নতুন সিম্পল এক্সএমলেমেন্ট ('<রুট />')) -> এসএক্সএমএল ();
$k = (is_numeric($k)) ? 'item' : $k;
করুনforeach()
পিএইচপি 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();
}
আরেকটি উন্নতি:
/**
* 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();
}
ব্যবহার:
$this->arrayToXML($array, new SimpleXMLElement('<root/>'), 'child_name_to_replace_numeric_integers');
এখানে আমার প্রবেশ, সহজ এবং পরিষ্কার ..
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);
যাইহোক যাইহোক ... আমি ওনোকাজু কোডটি (ধন্যবাদ!) নিয়েছি এবং এক্সএমএলে বারবার ট্যাগ করার ক্ষমতা যুক্ত করেছি, এটি বৈশিষ্ট্যগুলিও সমর্থন করে, আশা করি যে কেউ এটির কাজে লাগবে!
<?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('<root/>'))->asXML();
echo "$xml\n";
$dom = new DOMDocument;
$dom->preserveWhiteSpace = FALSE;
$dom->loadXML($xml);
$dom->formatOutput = TRUE;
echo $dom->saveXml();
?>
if (is_numeric($k)) { $i = $k + 1; $child = $xml->addChild("_$i"); array_to_xml($v, $child); }
আমি পিএইচপি এবং জিকুয়েরি ইত্যাদি থেকে পিছনে পিছনে এক্সএমএল জেনারেট করার জন্য কিছুক্ষণ আগে লিখেছিলাম এমন কয়েকটি ফাংশন ব্যবহার করি ... আর কোনও অতিরিক্ত ফ্রেমওয়ার্ক ব্যবহার না করে কেবল স্ট্রিং উত্পন্ন করে যা সিম্পল এক্সএমএল (বা অন্য কাঠামোর সাথে ব্যবহার করা যেতে পারে) ) ...
এটি যদি কারও কাজে লাগে তবে দয়া করে এটি ব্যবহার করুন :)
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;
}
সবার প্রতি ভালোবাসা :)
আমি একটি কোড চেয়েছিলাম যা একটি অ্যারের ভিতরে থাকা সমস্ত উপাদানগুলিকে নিয়ে যাবে এবং সেগুলিকে গুণাবলী হিসাবে এবং সমস্ত অ্যারে উপ উপাদান হিসাবে বিবেচনা করবে।
তাই কিছু জন্য
array (
'row1' => array ('head_element' =>array("prop1"=>"some value","prop2"=>array("empty"))),
"row2"=> array ("stack"=>"overflow","overflow"=>"overflow")
);
আমি এই জাতীয় কিছু পেতে হবে
<?xml version="1.0" encoding="utf-8"?>
<someRoot>
<row1>
<head_element prop1="some value">
<prop2 0="empty"/>
</head_element>
</row1>
<row2 stack="overflow" overflow="stack"/>
</someRoot>
এটি অর্জনের জন্য কোডটি নীচে রয়েছে, তবে খুব সতর্ক থাকুন, এটি পুনরাবৃত্তিযোগ্য এবং প্রকৃতপক্ষে স্ট্যাকওভারফ্লো হতে পারে :)
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();
}
আপনি অ্যারের দৈর্ঘ্যের জন্য চেক যোগ করতে চাইতে পারেন যাতে কোনও উপাদান কোনও ডেটা অংশের মধ্যে সেট হয়ে যায় এবং বৈশিষ্ট্য হিসাবে না।
এখানে অন্য সমস্ত কিছুর উপর ভিত্তি করে, সংখ্যাসূচক সূচকগুলি + বৈশিষ্ট্যগুলি উপসর্গের মাধ্যমে পরিচালনা করে @
এবং বিদ্যমান নোডগুলিতে এক্সএমএল ইনজেক্ট করতে পারে:
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
// 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
<?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>
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
এখানে একটি ফাংশন যা আমার জন্য কৌশলটি করেছে:
ঠিক এরকম কিছু দিয়ে কল করুন
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</$thisNodeName>";
}
else{
$newNode="<$thisNodeName>";
foreach($input as $key=>$value){
if(is_numeric($key))
$key=substr($thisNodeName,0,strlen($thisNodeName)-1);
$newNode.=arrayToXml3($key,$value);
}
$newNode.="</$thisNodeName>";
return $newNode;
}
}
আমি যে এক্সএমএল পার্সারের উপর কাজ করছি তা আপনি ব্যবহার করতে পারেন ।
$xml = XMLParser::encode(array(
'bla' => 'blub',
'foo' => 'bar',
'another_array' => array (
'stack' => 'overflow',
)
));
// @$xml instanceof SimpleXMLElement
echo $xml->asXML();
ফলাফল হবে:
<?xml version="1.0"?>
<root>
<bla>blub</bla>
<foo>bar</foo>
<another_array>
<stack>overflow</stack>
</another_array>
</root>
আমি এই সমাধানটি মূল সমস্যার মতোই পেয়েছি
<?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('<root/>');
array_walk_recursive($test_array, array ($xml, 'addChild'));
print $xml->asXML();
উপরের উত্তরগুলির বেশিরভাগই সঠিক। যাইহোক, আমি এই উত্তরটি নিয়ে এসেছি যা অ্যারে_ওয়াক_সংশ্লিষ্ট সামঞ্জস্যতা সমস্যা এবং সংখ্যাসূচক কীগুলি সমস্যার সমাধান করে। এটি আমার করা সমস্ত পরীক্ষাগুলিও পাস করেছে:
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);
}
}
আমি এটির জন্য একটি পরীক্ষার ক্লাসও যুক্ত করেছি যা আপনি দরকারী মনে করতে পারেন:
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' => '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('<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());
}
}
অন্যান্য সমাধান:
$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);
যদি অ্যারেটি সহকারী হয় এবং সঠিকভাবে কীড হয় তবে প্রথমে এটি এক্সএমএলে পরিণত করা আরও সহজ হবে। কিছুটা এইরকম:
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));
অন্য রুটটি হ'ল প্রথমে আপনার বুনিয়াদি এক্সএমএল তৈরি করা
$simple_xml = simplexml_load_string("<array></array>");
এবং তারপরে আপনার অ্যারের প্রতিটি অংশের জন্য, আমার পাঠ্যের অনুরূপ কিছু ব্যবহার করুন লুপ তৈরি করুন এবং এর পরিবর্তে অ্যারের প্রতিটি নোডের জন্য সিম্পলসিএমএল ফাংশন "অ্যাডচিল্ড" ব্যবহার করুন।
আমি এটি পরে চেষ্টা করব এবং উভয় সংস্করণ দিয়ে এই পোস্টটি আপডেট করব।
উপরের ফাংশনটিতে কেবল একটি সম্পাদনা, যখন কোনও কী সংখ্যাসূচক হয়, একটি উপসর্গ "কী_" যুক্ত করুন
// initializing or creating array
$student_info = array(your array data);
// creating object of SimpleXMLElement
$xml_student_info = new SimpleXMLElement("<?xml version=\"1.0\"?><student_info></student_info>");
// 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");
}
}
}
}
আপনি সরাসরি আপনার কোডে নিম্নলিখিত ফাংশনটি ব্যবহার করতে পারেন,
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";
}
}
}
প্রথম আর্গুমেন্ট সহ ফাংশনটিকে আপনার অ্যারে হিসাবে কল করুন এবং দ্বিতীয় যুক্তিটি 1 হওয়া আবশ্যক, এটি নিখুঁত ইনডেন্টেশনের জন্য বৃদ্ধি করা হবে এবং তৃতীয়টি সত্য হতে হবে।
উদাহরণস্বরূপ, যদি রূপান্তরিত করতে অ্যারে ভেরিয়েবলটি $ অ্যারে 1 হয় তবে কলিং হবে, কলিং ফাংশনটি <pre>
ট্যাগ সহ মোড়ক করা উচিত ।
artoxml ($ array1,1, সত্য);
ফাইলটি কার্যকর করার পরে পৃষ্ঠা উত্সটি দেখুন, কারণ <এবং> চিহ্নগুলি এইচটিএমএল পৃষ্ঠায় প্রদর্শিত হবে না।
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;
}
function array2xml(array $data, SimpleXMLElement $object = null, $oldNodeName = 'item')
{
if (is_null($object)) $object = new SimpleXMLElement('<root/>');
$isNumbered = true;
$idx = 0;
foreach ($data as $key => $x)
if (is_string($key) || ($idx++ != $key + 0))
$isNumbered = false;
foreach ($data as $key => $value)
{
$attribute = preg_match('/^[0-9]/', $key . '') ? $key : null;
$key = (is_string($key) && !preg_match('/^[0-9]/', $key . '')) ? $key : preg_replace('/s$/', '', $oldNodeName);
if (is_array($value))
{
$new_object = $object->addChild($key);
if (!$isNumbered && !is_null($attribute)) $new_object->addAttribute('id', $attribute);
array2xml($value, $new_object, $key);
}
else
{
if (is_bool($value)) $value = $value ? 'true' : 'false';
$node = $object->addChild($key, htmlspecialchars($value));
if (!$isNumbered && !is_null($attribute) && !isset($node->attributes()->id))
$node->addAttribute('id', $attribute);
}
}
return $object;
}
এই ফাংশনটি উদাহরণস্বরূপ <obj>...</obj> <obj> ... </obj> সংখ্যার সূচকগুলির জন্য এক্সএমএল ট্যাগগুলির একটি তালিকা দেয়।
ইনপুট:
array(
'people' => array(
'dog',
'cat',
'life' => array(
'gum',
'shoe',
),
'fish',
),
array('yeah'),
)
আউটপুট:
<root>
<people>
<people>dog</people>
<people>cat</people>
<life>
<life>gum</life>
<life>shoe</life>
</life>
<people>fish</people>
<people>
<people>yeah</people>
</people>
</people>
</root>
এটি সমস্ত সাধারণ চাহিদা মেটাতে হবে। হতে পারে আপনি ২ য় লাইনটি এতে পরিবর্তন করতে পারেন:
$key = is_string($key) ? $key : $oldNodeName . '_' . $key;
অথবা আপনি যদি বহুবচনগুলি এর সাথে শেষ করে কাজ করছেন:
$key = is_string($key) ? $key : preg_replace('/s$/', '', $oldNodeName);
সঙ্গে FluidXML আপনি তৈরি করতে পারেন, একটি থেকে শুরু পিএইচপি অ্যারে , জন্য একটি XML SimpleXML সঙ্গে ... কোডের মাত্র দুই লাইন।
$fluidxml = fluidxml($array);
$simplexml = simplexml_import_dom($fluidxml->dom());
একটি উদাহরণ অ্যারে হতে পারে
$array = [ 'doc' => [
'fruit' => 'orange',
'cake' => [
'@id' => '123',
'@' => 'tiramisu' ],
[ 'pasta' => 'matriciana' ],
[ 'pasta' => 'boscaiola' ]
] ];
অ্যারে থেকে এক্সএমএল তৈরি করতে আপনি xmlrpc_encode ব্যবহার করতে পারেন যদি ভার্বোজ এক্সএমএল কোনও সমস্যা না হয়। www.php.net/xmlrpc_encode
আপনি সহযোগী এবং / অথবা সংখ্যাসূচক কী ব্যবহার করার ক্ষেত্রে তৈরি হওয়া এক্সএমএল আলাদা হওয়ার বিষয়ে সতর্ক হন
<?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();
}
আমার উত্তর, অন্যের উত্তর একসাথে জড়িত। সংখ্যার কীগুলির ক্ষতিপূরণ দিতে ব্যর্থতার জন্য এটি সংশোধন করা উচিত:
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);
}
}
}
array_to_xml()
ফাংশন অনুমান করা হয়েছে যে অ্যারে প্রথম সাংখ্যিক কি তৈরি করা হয়। যদি আপনার অ্যারেতে প্রাথমিক উপাদান থাকে তবে আপনি ফাংশন থেকে স্টেটমেন্ট foreach()
এবং $elem
স্টেটমেন্টগুলি ফেলে দেবেন array_to_xml()
এবং কেবল $xml
পরিবর্তে পাস করবেন ।
আমি দ্বিতীয় সর্বাধিক ভোট দেওয়া উত্তরটি মন্তব্য করতাম, কারণ এটি কাঠামো সংরক্ষণ করে না এবং সংখ্যায় সূচকযুক্ত অভ্যন্তরীণ অ্যারে থাকলে খারাপ এক্সএমএল উত্পন্ন করে।
আমি এর উপর ভিত্তি করে আমার নিজস্ব সংস্করণ বিকাশ করেছি, কারণ আমার তথ্যের কাঠামো নির্বিশেষে জেসন এবং এক্সএমএল এর মধ্যে সরল রূপান্তরকারী প্রয়োজন। আমার সংস্করণটি মূল অ্যারের সংখ্যাসূচক কী তথ্য এবং কাঠামো সংরক্ষণ করে। এটি কী-অ্যাট্রিবিউটের সাথে মান-বিশিষ্ট উপাদানগুলিতে মানগুলি মোড়কের মাধ্যমে সংখ্যাসূচক সূচকযুক্ত মানগুলির জন্য উপাদান তৈরি করে যা সংখ্যাসূচক কী রয়েছে।
উদাহরণ স্বরূপ
array('test' => array(0 => 'some value', 1 => 'other'))
রূপান্তর
<test><value key="0">some value</value><value key="1">other</value></test>
অ্যারে_ টো এক্সএলএমএল-ফাংশনটির আমার সংস্করণ (আশা করি এটি কারও সাহায্য করবে :)
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);
}
}
}
}
পুরো এক্সএমএল কাঠামোটি ডেটা অ্যারেতে সংজ্ঞায়িত করা হয়েছে:
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();
}
}
আপনি যদি ম্যাজেন্টোতে কাজ করেন এবং আপনার কাছে এই ধরণের সাহসী অ্যারে থাকে
$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'
),
);
তাহলে এসোসিয়েটিভ অ্যারেগুলিকে এক্সএমএল ফর্ম্যাটে রূপান্তর করা ভাল। এই কোডটি নিয়ন্ত্রণকারী ফাইলে ব্যবহার করুন।
$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;
}
}
আমি আশা করি এটি সকলকে সহায়তা করে।
// 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\"?><student_info></student_info>');
// 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);
}
}
}