Php simplexml add cdata

PHP: How to Handle ≪![Cdata[ With Simplexmlelement

PHP: How to handle

You’re probably not accessing it correctly. You can output it directly or cast it as a string. (in this example, the casting is superfluous, as echo automatically does it anyway)

$content = simplexml_load_string( 
' '
);
echo (string) $content;

// or with parent element:

$foo = simplexml_load_string( 
' '
);
echo (string) $foo->content;

You might have better luck with LIBXML_NOCDATA :

$content = simplexml_load_string( 
' ' 
, null 
, LIBXML_NOCDATA
);

How to write CDATA using SimpleXmlElement?

Got it! I adapted the code from this great solution (archived version):

   
// http://coffeerings.posterous.com/php-simplexml-and-cdata 
class SimpleXMLExtended extends SimpleXMLElement  
public function addCData( $cdata_text ) $node = dom_import_simplexml( $this ); 
$no = $node->ownerDocument; 
 
$node->appendChild( $no->createCDATASection( $cdata_text ) ); 
> 
 
>
 
$xmlFile = 'config.xml'; 
 
// instead of $xml = new SimpleXMLElement( '' ); 
$xml = new SimpleXMLExtended( '' ); 
 
$xml->title = NULL; // VERY IMPORTANT! We need a node where to append 
 
$xml->title->addCData( 'Site Title' ); 
$xml->title->addAttribute( 'lang', 'en' ); 
 
$xml->saveXML( $xmlFile ); 
 
?>

Reading text in `

SimpleXML reads CDATA nodes absolutely fine. The only problem you’re having is that print_r , var_dump , and similar functions don’t give an accurate representation of SimpleXML objects, because they are not implemented fully in PHP.

If you run echo $myNode->description you will see the content of the CDATA section just fine. The reason is that when you ask for a SimpleXMLElement to be converted to a string, it automatically combines all the text and CDATA content for you — but until you do, it remembers the distinction.

As a general case, to extract the string content of any element or attribute in SimpleXML, cast to string with (string)$myNode . This also prevents other issues, such as functions complaining about getting an object when they were expecting a string, or failure to serialize when saving to a session.

See also my previous answer at https://stackoverflow.com/a/13830559/157957

simpleXML get value from CDATA

In your simplexml_load_file() , you need to add the parameter LIBXML_NOCDATA flag:

$url = "http://www.ss.lv/lv/real-estate/flats/riga/hand_over/rss/";
$result = simplexml_load_file($url, 'SimpleXMLElement', LIBXML_NOCDATA); 
// ^^ here
foreach($result->channel->item as $item) $title = (string) $item->title; 
$desc = (string) $item->description; 
$dom = new DOMDocument($desc); 
$dom->loadHTML($desc); 
$bold_tags = $dom->getElementsByTagName('b'); 
foreach($bold_tags as $b) echo $b->nodeValue . '
'; 
>
>

PHP, SimpleXML, decoding entities in CDATA

The purpose of CDATA sections in XML is to encapsulate a block of text «as is» which would otherwise require special characters (in particular, > , < and & ) to be escaped. A CDATA section containing the character & is the same as a normal text node containing & .

If a parser were to offer to ignore this, and pretend all CDATA nodes were really just text nodes, it would instantly break as soon as someone mentioned «P&O Cruises» — that & simply can’t be there on its own (rather than as & , or &somethingElse; ).

The LIBXML_NOCDATA is actually pretty useless with SimpleXML, because (string)$foo neatly combines any sequence of text and CDATA nodes into an ordinary PHP string. (Something which people frequently fail to notice, because print_r doesn’t.) This isn’t necessarily true of more systematic access methods, such as DOM, where you can manipulate text nodes and CDATA nodes as objects in their own right.

What it effectively does is go through the document, and wherever it encounters a CDATA section, it takes the content, escapes it, and puts it back as an ordinary text node, or «merges» it with any text nodes to either side. The text represented is identical, just stored in the document in a different way; you can see the difference if you export back to XML, as in this example:

$xml_string = "Welcome aboard this ";

$person = new SimpleXMLElement($xml_string);
echo 'CDATA retained: ', $person->asXML();
// CDATA retained: 
// Welcome aboard this 

$person = new SimpleXMLElement($xml_string, LIBXML_NOCDATA);
echo 'CDATA merged: ', $person->asXML();
// CDATA merged: 
// Welcome aboard this P&O Cruises voyage! 

If the XML document you’re parsing contains a CDATA section which actually contains entities, you need to take that string and unescape it completely independent of the XML. One common reason to do this (other than laziness with poorly understood libraries) is to treat something marked up in HTML as just any old string inside an XML document, like this:

IMSoP
really bad at keeping my answers brief ;)]]> 

SimpleXML: handle CDATA tag presence in node value

What you need to look at is the «inner XML» of that element, which is tricky in SimpleXML ( ->asXML() will give you the «outer XML», e.g. ).

Your best bet here is to use the DOM which gives you more access to the detailed structure of the document, rather than trying to give you the content, so distinguishes «text nodes» and «CDATA nodes». However, it’s worth double-checking that you do actually need this, as for 99.9% of use cases, you shouldn’t care whether somebody sent you bar & baz or , since by definition they represent the same string.

How to parse CDATA HTML-content of XML using SimpleXML?

I once answered it but I don’t find the answer any longer.

If you take a look at the string (simplified/beautified):

You can see that you have HTML encoded inside the node-value of the element. So first you need to obtain the HTML value, which you already do:

$html = $boo->children('content', true)->encoded;

Then you need to parse the HTML inside $html . With which libraries HTML parsing can be done with PHP is outlined in:

If you decide to use the more or less recommended DOMDocument for the job, you only need to get the attribute value of a certain element:

Or for its sister library SimpleXML you already use (so this is more recommended, see as well the next section):

In context of your question here the following tip:

You’re using SimpleXML. DOMDocument is a sister-library, meaning you can interchange between the two so you don’t need to learn a full new library.

For example, you can use only the HTML parsing feature of DOMDocument , but import it then into SimpleXML . This is useful, because SimpleXML does not support HTML parsing.

That works via simplexml_import_dom() .

A simplified step-by-step example:

// get the HTML string out of the feed:
$htmlString = $boo->children('content', true)->encoded;

// create DOMDocument for HTML parsing:
$htmlParser = new DOMDocument();

// load the HTML:
$htmlParser->loadHTML($htmlString);

// import it into simplexml:
$html = simplexml_import_dom($htmlParser);

Now you can use $html as a new SimpleXMLElement that represents the HTML document. As your HTML chunks did not have any tags, according to the HTML specification, they are put inside the tag. This will allow you for example to access the href attribute of the first inside the second

element in your example:#

// access the element you're looking for:
$href = $html->body->p[1]->a['href'];

Here the full view from above (Online Demo):

// get the HTML string out of the feed:
$htmlString = $boo->children('content', true)->encoded;

// create DOMDocument for HTML parsing:
$htmlParser = new DOMDocument();

// your HTML gives parser warnings, keep them internal:
libxml_use_internal_errors(true);

// load the HTML:
$htmlParser->loadHTML($htmlString);

// import it into simplexml:
$html = simplexml_import_dom($htmlParser);

// access the element you're looking for:
$href = $html->body->p[1]->a['href'];

// output it
echo $href, "\n";

laura-bertram-trance-gemini-145-1080.jpg

Modify ![CDATA[]] in PHP? (XML)

That is true for SimpleXML. CDATA Sections are a special kind of text nodes. They are actually here to make embedded parts more readable for humans. SimpleXML does not really handle XML nodes so you will have to let it convert them to standard text nodes.

If you have a JS or HTML fragment in XML it is easier to read if the special characters like < are not escaped. And this is what CDATA sections are for (and some backwards compatibility for browsers).

So to modify a CDATA section and keep it, you will have to use DOM. DOM actually knows about the different node types. Here is a small example:

$xml = '';

$document = new DOMDocument();
$document->loadXml($xml);
$xpath = new DOMXpath($document);

foreach ($xpath->evaluate('//link/text()') as $linkValue) $linkValue->data .= '?abc';
>
echo $document->saveXml();

Getting cdata content while parsing xml file

SimpleXML has a bit of a problem with CDATA, so use:

$xml = simplexml_load_file('xmlfile', 'SimpleXMLElement', LIBXML_NOCDATA);
if(!empty($xml))
 $nodes = $xml->xpath('//xml/events');
>
print_r( $nodes );

Array
( 
[0] => SimpleXMLElement Object 
( 
[@attributes] => Array 
( 
[date] => 01-10-2009 
[color] => 0x99CC00 
[selected] => true 
)
 
[event] => SimpleXMLElement Object 
( 
[title] => You can use HTML and CSS 
[description] => This is the description 
)
 
)

)

PHP — Parse XML with simplexml_load_string — Getting empty values with CDATA?

The problem seems to be that the cast you’re doing to array can return results different than the actual structure of the XML object.

Something like the following code should give you an array with the correct info:

$array = array_map('strval', (array) $xml->Product);

Take care you cast those parts to string of which you’ll get the data from (in the example done via strval() ). In the opposite, json_encode() is not working well with SimpleXMLElement.

Источник

How to write cdata using simplexmlelement in Php?

The SimpleXmlElement class in PHP provides an easy way to work with XML data, but sometimes when you try to add content that includes special characters such as , or &, the output will not be valid XML and will generate parse errors. One solution to this problem is to wrap the content in a CDATA section, which is treated as raw character data rather than parsed as markup. Here are two methods to write CDATA using SimpleXmlElement:

Method 1: Create a DOMNode and add it to the SimpleXmlElement

To write CDATA using SimpleXmlElement in PHP, you can create a DOMNode and add it to the SimpleXmlElement. Here is how to do it:

$xml = new SimpleXMLElement(' '); $cdata = ' . 'your CDATA content here' . ']]>'; $node = dom_import_simplexml($xml); $child = $node->ownerDocument->createCDATASection($cdata); $node->appendChild($child);

In the above code, we first create a new SimpleXmlElement with an empty root element. Then we create a string variable $cdata that contains the CDATA content we want to add. We then use the dom_import_simplexml function to get the DOMNode object of the SimpleXmlElement. We create a new CDATA section using the createCDATASection method of the owner document of the node. Finally, we append the CDATA section to the node using the appendChild method.

Here is another example that shows how to add CDATA to an existing SimpleXmlElement:

$xml = new SimpleXMLElement(' '); $cdata = ' . 'your CDATA content here' . ']]>'; $data = $xml->data; $node = dom_import_simplexml($data); $child = $node->ownerDocument->createCDATASection($cdata); $node->appendChild($child);

In this example, we first create a SimpleXmlElement with a root element that contains a data element. We then create the CDATA content as before. We get the data element using the object property notation of the SimpleXmlElement. We get the DOMNode object of the data element using the dom_import_simplexml function. We create a new CDATA section using the createCDATASection method of the owner document of the node. Finally, we append the CDATA section to the data element using the appendChild method.

These examples should help you to write CDATA using SimpleXmlElement in PHP.

Method 2: Use the addCData method of SimpleXmlElement

To write CDATA using SimpleXmlElement in PHP, you can use the addCData() method. Here’s an example:

$xml = new SimpleXMLElement(' '); $element = $xml->addChild('element'); $element->addCData('This is CDATA content.'); echo $xml->asXML();

 root> element> element> root>

In the example above, we first create a new SimpleXMLElement object with an empty root element. Then, we add a child element called «element» using the addChild() method. Finally, we add CDATA content to the «element» using the addCData() method.

You can also use the __toString() method to add CDATA content directly to an element when creating it, like this:

$xml = new SimpleXMLElement(' '); $xml->addChild('element', new SimpleXMLElement(')); echo $xml->asXML();

This will output the same XML as the previous example.

That’s it! By using the addCData() method or the __toString() method with a SimpleXMLElement object, you can easily add CDATA content to your XML document.

Источник