PHP chuyển đổi XML thành JSON

Tôi đang cố gắng chuyển đổi xml sang json trong php. Nếu tôi thực hiện chuyển đổi đơn giản bằng cách sử dụng xml và json_encode đơn giản, không có thuộc tính nào trong chương trình xml.

$xml = simplexml_load_file("states.xml");
echo json_encode($xml);

Vì vậy, tôi đang cố gắng tự phân tích nó như thế này.

foreach($xml->children() as $state)
{
    $states[]= array('state' => $state->name); 
}       
echo json_encode($states);

và đầu ra cho trạng thái {"state":{"0":"Alabama"}}chứ không phải là{"state":"Alabama"}

Tôi đang làm gì sai?

XML:

<?xml version="1.0" ?>
<states>
    <state id="AL">     
    <name>Alabama</name>
    </state>
    <state id="AK">
        <name>Alaska</name>
    </state>
</states>

Đầu ra:

[{"state":{"0":"Alabama"}},{"state":{"0":"Alaska"}

bãi chứa var:

object(SimpleXMLElement)#1 (1) {
["state"]=>
array(2) {
[0]=>
object(SimpleXMLElement)#3 (2) {
  ["@attributes"]=>
  array(1) {
    ["id"]=>
    string(2) "AL"
  }
  ["name"]=>
  string(7) "Alabama"
}
[1]=>
object(SimpleXMLElement)#2 (2) {
  ["@attributes"]=>
  array(1) {
    ["id"]=>
    string(2) "AK"
  }
  ["name"]=>
  string(6) "Alaska"
}
}
}

Json & Array từ XML trong 3 dòng:

$xml = simplexml_load_string($xml_string);
$json = json_encode($xml);
$array = json_decode($json,TRUE);

Xin lỗi vì đã trả lời một bài viết cũ, nhưng bài viết này phác thảo một cách tiếp cận tương đối ngắn, súc tích và dễ duy trì. Tôi đã thử nghiệm nó và làm việc khá tốt.

http://lostechies.com/seanbiefeld/2011/10/21/simple-xml-to-json-with-php/

<?php   
class XmlToJson {
    public function Parse ($url) {
        $fileContents= file_get_contents($url);
        $fileContents = str_replace(array("\n", "\r", "\t"), '', $fileContents);
        $fileContents = trim(str_replace('"', "'", $fileContents));
        $simpleXml = simplexml_load_string($fileContents);
        $json = json_encode($simpleXml);

        return $json;
    }
}
?>

Tôi đã hiểu rồi. json_encode xử lý các đối tượng khác với chuỗi. Tôi chuyển đối tượng thành một chuỗi và nó hoạt động ngay bây giờ.

foreach($xml->children() as $state)
{
    $states[]= array('state' => (string)$state->name); 
}       
echo json_encode($states);

Tôi đoán tôi đến bữa tiệc hơi muộn nhưng tôi đã viết một chức năng nhỏ để hoàn thành nhiệm vụ này. Nó cũng quan tâm đến các thuộc tính, nội dung văn bản và ngay cả khi nhiều nút có cùng tên nút là anh em ruột.

Từ chối trách nhiệm: Tôi không phải là người bản địa PHP, vì vậy xin vui lòng chịu những lỗi đơn giản.

function xml2js($xmlnode) {
    $root = (func_num_args() > 1 ? false : true);
    $jsnode = array();

    if (!$root) {
        if (count($xmlnode->attributes()) > 0){
            $jsnode["$"] = array();
            foreach($xmlnode->attributes() as $key => $value)
                $jsnode["$"][$key] = (string)$value;
        }

        $textcontent = trim((string)$xmlnode);
        if (count($textcontent) > 0)
            $jsnode["_"] = $textcontent;

        foreach ($xmlnode->children() as $childxmlnode) {
            $childname = $childxmlnode->getName();
            if (!array_key_exists($childname, $jsnode))
                $jsnode[$childname] = array();
            array_push($jsnode[$childname], xml2js($childxmlnode, true));
        }
        return $jsnode;
    } else {
        $nodename = $xmlnode->getName();
        $jsnode[$nodename] = array();
        array_push($jsnode[$nodename], xml2js($xmlnode, true));
        return json_encode($jsnode);
    }
}   

Ví dụ sử dụng:

$xml = simplexml_load_file("myfile.xml");
echo xml2js($xml);

Ví dụ đầu vào (myfile.xml):

<family name="Johnson">
    <child name="John" age="5">
        <toy status="old">Trooper</toy>
        <toy status="old">Ultrablock</toy>
        <toy status="new">Bike</toy>
    </child>
</family>

Ví dụ đầu ra:

{"family":[{"$":{"name":"Johnson"},"child":[{"$":{"name":"John","age":"5"},"toy":[{"$":{"status":"old"},"_":"Trooper"},{"$":{"status":"old"},"_":"Ultrablock"},{"$":{"status":"new"},"_":"Bike"}]}]}]}

In đẹp:

{
    "family" : [{
            "$" : {
                "name" : "Johnson"
            },
            "child" : [{
                    "$" : {
                        "name" : "John",
                        "age" : "5"
                    },
                    "toy" : [{
                            "$" : {
                                "status" : "old"
                            },
                            "_" : "Trooper"
                        }, {
                            "$" : {
                                "status" : "old"
                            },
                            "_" : "Ultrablock"
                        }, {
                            "$" : {
                                "status" : "new"
                            },
                            "_" : "Bike"
                        }
                    ]
                }
            ]
        }
    ]
}

Những điều cần lưu ý: Một số thẻ có cùng tên thẻ có thể là anh em ruột. Các giải pháp khác rất có thể sẽ bỏ tất cả trừ anh chị em cuối cùng. Để tránh điều này, mỗi nút đơn lẻ, ngay cả khi nó chỉ có một con, là một mảng chứa một đối tượng cho mỗi phiên bản của tên thẻ. (Xem nhiều yếu tố "" trong ví dụ)

Ngay cả phần tử gốc, trong đó chỉ có một phần tử tồn tại trong tài liệu XML hợp lệ được lưu trữ dưới dạng mảng với một đối tượng của thể hiện, chỉ để có cấu trúc dữ liệu nhất quán.

Để có thể phân biệt giữa nội dung nút XML và các thuộc tính XML, mỗi thuộc tính đối tượng được lưu trữ trong "$" và nội dung trong phần tử con "_".

Chỉnh sửa: Tôi quên hiển thị đầu ra cho dữ liệu đầu vào mẫu của bạn

{
    "states" : [{
            "state" : [{
                    "$" : {
                        "id" : "AL"
                    },
                    "name" : [{
                            "_" : "Alabama"
                        }
                    ]
                }, {
                    "$" : {
                        "id" : "AK"
                    },
                    "name" : [{
                            "_" : "Alaska"
                        }
                    ]
                }
            ]
        }
    ]
}

Một cạm bẫy phổ biến là quên rằng json_encode()không tôn trọng các yếu tố với giá trị văn bản và (các) thuộc tính. Nó sẽ chọn một trong số đó, có nghĩa là dataloss. Hàm dưới đây giải quyết vấn đề đó. Nếu một người quyết định đi theo json_encode/ decodecách, chức năng sau được khuyên dùng.

function json_prepare_xml($domNode) {
  foreach($domNode->childNodes as $node) {
    if($node->hasChildNodes()) {
      json_prepare_xml($node);
    } else {
      if($domNode->hasAttributes() && strlen($domNode->nodeValue)){
         $domNode->setAttribute("nodeValue", $node->textContent);
         $node->nodeValue = "";
      }
    }
  }
}

$dom = new DOMDocument();
$dom->loadXML( file_get_contents($xmlfile) );
json_prepare_xml($dom);
$sxml = simplexml_load_string( $dom->saveXML() );
$json = json_decode( json_encode( $sxml ) );

bằng cách làm như vậy, <foo bar="3">Lorem</foo>sẽ không kết thúc như {"foo":"Lorem"}trong JSON của bạn.

Cố gắng sử dụng cái này

$xml = ... // Xml file data

// first approach
$Json = json_encode(simplexml_load_string($xml));

---------------- OR -----------------------

// second approach
$Json = json_encode(simplexml_load_string($xml, "SimpleXMLElement", LIBXML_NOCDATA));

echo $Json;

Hoặc là

Bạn có thể sử dụng thư viện này: https://github.com/rentpost/xml2array

Tôi đã sử dụng TypeConverter của Miles Johnson cho mục đích này. Nó có thể cài đặt bằng Composer .

Bạn có thể viết một cái gì đó như thế này bằng cách sử dụng nó:

<?php
require 'vendor/autoload.php';
use mjohnson\utility\TypeConverter;

$xml = file_get_contents("file.xml");
$arr = TypeConverter::xmlToArray($xml, TypeConverter::XML_GROUP);
echo json_encode($arr);

Tối ưu hóa câu trả lời của Antonio Max:

$xmlfile = 'yourfile.xml';
$xmlparser = xml_parser_create();

// open a file and read data
$fp = fopen($xmlfile, 'r');
//9999999 is the length which fread stops to read.
$xmldata = fread($fp, 9999999);

// converting to XML
$xml = simplexml_load_string($xmldata, "SimpleXMLElement", LIBXML_NOCDATA);

// converting to JSON
$json = json_encode($xml);
$array = json_decode($json,TRUE);

Nếu bạn muốn chỉ chuyển đổi một phần cụ thể của XML thành JSON, bạn có thể sử dụng XPath để truy xuất phần này và chuyển đổi phần đó thành JSON.

<?php
$file = @file_get_contents($xml_File, FILE_TEXT);
$xml = new SimpleXMLElement($file);
$xml_Excerpt = @$xml->xpath('/states/state[@id="AL"]')[0]; // [0] gets the node
echo json_encode($xml_Excerpt);
?>

Xin lưu ý rằng nếu Xpath của bạn không chính xác, điều này sẽ xảy ra lỗi. Vì vậy, nếu bạn gỡ lỗi điều này thông qua các cuộc gọi AJAX, tôi khuyên bạn cũng nên đăng nhập các nội dung phản hồi.

This is better solution

$fileContents= file_get_contents("https://www.feedforall.com/sample.xml");
$fileContents = str_replace(array("\n", "\r", "\t"), '', $fileContents);
$fileContents = trim(str_replace('"', "'", $fileContents));
$simpleXml = simplexml_load_string($fileContents);
$json = json_encode($simpleXml);
$array = json_decode($json,TRUE);
return $array;

Giải pháp tốt nhất có tác dụng như bùa mê

$fileContents= file_get_contents($url);

$fileContents = str_replace(array("\n", "\r", "\t"), '', $fileContents);

$fileContents = trim(str_replace('"', "'", $fileContents));

$simpleXml = simplexml_load_string($fileContents);

//$json = json_encode($simpleXml); // Remove // if you want to store the result in $json variable

echo '<pre>'.json_encode($simpleXml,JSON_PRETTY_PRINT).'</pre>';

Nguồn

Đây là một cải tiến của giải pháp nâng cao nhất của Antonio Max, cũng hoạt động với XML có không gian tên (bằng cách thay thế dấu hai chấm bằng dấu gạch dưới). Nó cũng có một số tùy chọn bổ sung (và phân tích <person my-attribute='name'>John</person>chính xác).

function parse_xml_into_array($xml_string, $options = array()) {
    /*
    DESCRIPTION:
    - parse an XML string into an array
    INPUT:
    - $xml_string
    - $options : associative array with any of these keys:
        - 'flatten_cdata' : set to true to flatten CDATA elements
        - 'use_objects' : set to true to parse into objects instead of associative arrays
        - 'convert_booleans' : set to true to cast string values 'true' and 'false' into booleans
    OUTPUT:
    - associative array
    */

    // Remove namespaces by replacing ":" with "_"
    if (preg_match_all("|</([\\w\\-]+):([\\w\\-]+)>|", $xml_string, $matches, PREG_SET_ORDER)) {
        foreach ($matches as $match) {
            $xml_string = str_replace('<'. $match[1] .':'. $match[2], '<'. $match[1] .'_'. $match[2], $xml_string);
            $xml_string = str_replace('</'. $match[1] .':'. $match[2], '</'. $match[1] .'_'. $match[2], $xml_string);
        }
    }

    $output = json_decode(json_encode(@simplexml_load_string($xml_string, 'SimpleXMLElement', ($options['flatten_cdata'] ? LIBXML_NOCDATA : 0))), ($options['use_objects'] ? false : true));

    // Cast string values "true" and "false" to booleans
    if ($options['convert_booleans']) {
        $bool = function(&$item, $key) {
            if (in_array($item, array('true', 'TRUE', 'True'), true)) {
                $item = true;
            } elseif (in_array($item, array('false', 'FALSE', 'False'), true)) {
                $item = false;
            }
        };
        array_walk_recursive($output, $bool);
    }

    return $output;
}

Tất cả các giải pháp ở đây có vấn đề!

... Khi biểu diễn cần diễn giải XML hoàn hảo (không có vấn đề với các thuộc tính) và để tái tạo tất cả các thẻ văn bản-thẻ-văn bản-thẻ-văn bản -... và thứ tự các thẻ. Cũng nên nhớ ở đây rằng đối tượng JSON "là một tập hợp không có thứ tự" (không phải các khóa lặp lại và các khóa không thể có thứ tự được xác định trước) ... Ngay cả xml2json của ZF cũng sai (!) Vì không bảo toàn chính xác cấu trúc XML.

Tất cả các giải pháp ở đây đều có vấn đề với XML đơn giản này,

    <states x-x='1'>
        <state y="123">Alabama</state>
        My name is <b>John</b> Doe
        <state>Alaska</state>
    </states>

... Giải pháp @FTav có vẻ tốt hơn giải pháp 3 dòng, nhưng cũng có một chút lỗi khi được thử nghiệm với XML này.

Giải pháp cũ là tốt nhất (cho đại diện không mất)

Giải pháp, ngày nay nổi tiếng là jsonML , được sử dụng bởi dự án Zorba và các dự án khác, và được trình bày lần đầu tiên vào năm 2006 hoặc ~ 2007, bởi (riêng) Stephen McKamey và John Snelson .

// the core algorithm is the XSLT of the "jsonML conventions"
// see  https://github.com/mckamey/jsonml
$xslt = 'https://raw.githubusercontent.com/mckamey/jsonml/master/jsonml.xslt';
$dom = new DOMDocument;
$dom->loadXML('
    <states x-x=\'1\'>
        <state y="123">Alabama</state>
        My name is <b>John</b> Doe
        <state>Alaska</state>
    </states>
');
if (!$dom) die("\nERROR!");
$xslDoc = new DOMDocument();
$xslDoc->load($xslt);
$proc = new XSLTProcessor();
$proc->importStylesheet($xslDoc);
echo $proc->transformToXML($dom);

Sản xuất

["states",{"x-x":"1"},
    "\n\t    ",
    ["state",{"y":"123"},"Alabama"],
    "\n\t\tMy name is ",
    ["b","John"],
    " Doe\n\t    ",
    ["state","Alaska"],
    "\n\t"
]

Xem http://jsonML.org hoặc github.com/mckamey/jsonml . Các quy tắc sản xuất của JSON này dựa trên yếu tố JSON-analog,

Cú pháp này là một định nghĩa phần tử và tái phát, với
element-list ::= element ',' element-list | element.

Sau khi nghiên cứu một chút tất cả các câu trả lời, tôi đã tìm ra một giải pháp hoạt động tốt với các chức năng JavaScript của mình trên các trình duyệt (Bao gồm bảng điều khiển / Công cụ phát triển):

<?php

 // PHP Version 7.2.1 (Windows 10 x86)

 function json2xml( $domNode ) {
  foreach( $domNode -> childNodes as $node) {
   if ( $node -> hasChildNodes() ) { json2xml( $node ); }
   else {
    if ( $domNode -> hasAttributes() && strlen( $domNode -> nodeValue ) ) {
     $domNode -> setAttribute( "nodeValue", $node -> textContent );
     $node -> nodeValue = "";
    }
   }
  }
 }

 function jsonOut( $file ) {
  $dom = new DOMDocument();
  $dom -> loadXML( file_get_contents( $file ) );
  json2xml( $dom );
  header( 'Content-Type: application/json' );
  return str_replace( "@", "", json_encode( simplexml_load_string( $dom -> saveXML() ), JSON_PRETTY_PRINT ) );
 }

 $output = jsonOut( 'https://boxelizer.com/assets/a1e10642e9294f39/b6f30987f0b66103.xml' );

 echo( $output );

 /*
  Or simply 
  echo( jsonOut( 'https://boxelizer.com/assets/a1e10642e9294f39/b6f30987f0b66103.xml' ) );
 */

?>

Về cơ bản, nó tạo ra một DOMDocument mới, tải và tệp XML vào đó và duyệt qua từng nút và con nhận dữ liệu / tham số và xuất nó thành JSON mà không có dấu "@" gây phiền nhiễu.

Liên kết đến tệp XML .

Giải pháp này xử lý các không gian tên, thuộc tính và tạo ra kết quả nhất quán với các phần tử lặp lại (luôn trong mảng, ngay cả khi chỉ có một lần xuất hiện). Lấy cảm hứng từ sxiToArray () của ratfactor .

/**
 * <root><a>5</a><b>6</b><b>8</b></root> -> {"root":[{"a":["5"],"b":["6","8"]}]}
 * <root a="5"><b>6</b><b>8</b></root> -> {"root":[{"a":"5","b":["6","8"]}]}
 * <root xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"><a>123</a><wsp:b>456</wsp:b></root> 
 *   -> {"root":[{"xmlns:wsp":"http://schemas.xmlsoap.org/ws/2004/09/policy","a":["123"],"wsp:b":["456"]}]}
 */
function domNodesToArray(array $tags, \DOMXPath $xpath)
{
    $tagNameToArr = [];
    foreach ($tags as $tag) {
        $tagData = [];
        $attrs = $tag->attributes ? iterator_to_array($tag->attributes) : [];
        $subTags = $tag->childNodes ? iterator_to_array($tag->childNodes) : [];
        foreach ($xpath->query('namespace::*', $tag) as $nsNode) {
            // the only way to get xmlns:*, see https://stackoverflow.com/a/2470433/2750743
            if ($tag->hasAttribute($nsNode->nodeName)) {
                $attrs[] = $nsNode;
            }
        }

        foreach ($attrs as $attr) {
            $tagData[$attr->nodeName] = $attr->nodeValue;
        }
        if (count($subTags) === 1 && $subTags[0] instanceof \DOMText) {
            $text = $subTags[0]->nodeValue;
        } elseif (count($subTags) === 0) {
            $text = '';
        } else {
            // ignore whitespace (and any other text if any) between nodes
            $isNotDomText = function($node){return !($node instanceof \DOMText);};
            $realNodes = array_filter($subTags, $isNotDomText);
            $subTagNameToArr = domNodesToArray($realNodes, $xpath);
            $tagData = array_merge($tagData, $subTagNameToArr);
            $text = null;
        }
        if (!is_null($text)) {
            if ($attrs) {
                if ($text) {
                    $tagData['_'] = $text;
                }
            } else {
                $tagData = $text;
            }
        }
        $keyName = $tag->nodeName;
        $tagNameToArr[$keyName][] = $tagData;
    }
    return $tagNameToArr;
}

function xmlToArr(string $xml)
{
    $doc = new \DOMDocument();
    $doc->loadXML($xml);
    $xpath = new \DOMXPath($doc);
    $tags = $doc->childNodes ? iterator_to_array($doc->childNodes) : [];
    return domNodesToArray($tags, $xpath);
}

Thí dụ:

php > print(json_encode(xmlToArr('<root a="5"><b>6</b></root>')));
{"root":[{"a":"5","b":["6"]}]}

Tìm thấy câu trả lời của FTav hữu ích nhất vì nó rất tùy biến, nhưng chức năng xml2js của anh ta có một số sai sót. Chẳng hạn, nếu các phần tử con có tên thẻ bằng nhau thì tất cả chúng sẽ được lưu trữ trong một đối tượng, điều này có nghĩa là thứ tự các phần tử sẽ không được giữ nguyên. Trong một số trường hợp, chúng tôi thực sự muốn giữ gìn trật tự, vì vậy chúng tôi lưu trữ tốt hơn mọi dữ liệu của một thành phần trong một đối tượng riêng biệt:

function xml2js($xmlnode) {
    $jsnode = array();
    $nodename = $xmlnode->getName();
    $current_object = array();

    if (count($xmlnode->attributes()) > 0) {
        foreach($xmlnode->attributes() as $key => $value) {
            $current_object[$key] = (string)$value;
        }
    }

    $textcontent = trim((string)$xmlnode);
    if (strlen($textcontent) > 0) {
        $current_object["content"] = $textcontent;
    }

    if (count($xmlnode->children()) > 0) {
        $current_object['children'] = array();
        foreach ($xmlnode->children() as $childxmlnode) {
            $childname = $childxmlnode->getName();
            array_push($current_object['children'], xml2js($childxmlnode, true));
        }
    }

    $jsnode[ $nodename ] = $current_object;
    return $jsnode;
}

Đây là cách nó làm việc. Cấu trúc xml ban đầu:

<some-tag some-attribute="value of some attribute">
  <another-tag>With text</another-tag>
  <surprise></surprise>
  <another-tag>The last one</another-tag>
</some-tag>

Kết quả JSON:

{
    "some-tag": {
        "some-attribute": "value of some attribute",
        "children": [
            {
                "another-tag": {
                    "content": "With text"
                }
            },
            {
                "surprise": []
            },
            {
                "another-tag": {
                    "content": "The last one"
                }
            }
        ]
    }
}

Có vẻ như $state->namebiến đang giữ một mảng. Bạn có thể dùng

var_dump($state)

Bên trong foreachđể kiểm tra mà.

Nếu đó là trường hợp, bạn có thể thay đổi dòng bên trong foreachđể

$states[]= array('state' => array_shift($state->name)); 

để sửa nó

$templateData =  $_POST['data'];

// initializing or creating array
$template_info =  $templateData;

// creating object of SimpleXMLElement
$xml_template_info = new SimpleXMLElement("<?xml version=\"1.0\"?><template></template>");

// function call to convert array to xml
array_to_xml($template_info,$xml_template_info);

//saving generated xml file
 $xml_template_info->asXML(dirname(__FILE__)."/manifest.xml") ;

// function defination to convert array to xml
function array_to_xml($template_info, &$xml_template_info) {
    foreach($template_info as $key => $value) {
        if(is_array($value)) {
            if(!is_numeric($key)){
                $subnode = $xml_template_info->addChild($key);
                if(is_array($value)){
                    $cont = 0;
                    foreach(array_keys($value) as $k){
                        if(is_numeric($k)) $cont++;
                    }
                }

                if($cont>0){
                    for($i=0; $i < $cont; $i++){
                        $subnode = $xml_body_info->addChild($key);
                        array_to_xml($value[$i], $subnode);
                    }
                }else{
                    $subnode = $xml_body_info->addChild($key);
                    array_to_xml($value, $subnode);
                }
            }
            else{
                array_to_xml($value, $xml_template_info);
            }
        }
        else {
            $xml_template_info->addChild($key,$value);
        }
    }
}

Nếu bạn là người dùng Ubuntu cài đặt trình đọc xml (tôi có php 5.6. Nếu bạn có khác xin vui lòng tìm gói và cài đặt)

sudo apt-get install php5.6-xml
service apache2 restart

$fileContents = file_get_contents('myDirPath/filename.xml');
$fileContents = str_replace(array("\n", "\r", "\t"), '', $fileContents);
$fileContents = trim(str_replace('"', "'", $fileContents));
$oldXml = $fileContents;
$simpleXml = simplexml_load_string($fileContents);
$json = json_encode($simpleXml);