JSON and XML Processing

JSON (JavaScript Object Notation) and XML (Extensible Markup Language) are two of the most widely used data interchange formats for transferring structured data between different systems, applications, and services. Understanding how to process these formats is crucial for web development, API integration, and data management.

JSON (JavaScript Object Notation)
JSON is a lightweight, human-readable, and language-independent data format. It is built on two structures:
1. A collection of name/value pairs (like an object, record, struct, dictionary, hash table, keyed list, or associative array).
2. An ordered list of values (like an array, vector, list, or sequence).
JSON is commonly used for data transmission in web applications (especially when interacting with RESTful APIs), configuration files, and data storage. Its simplicity and compact nature make it very popular.

In PHP, you can process JSON using built-in functions:
* `json_encode($value)`: Converts a PHP value (array or object) into a JSON string.
* `json_decode($json_string, $associative = false, $depth = 512, $options = 0)`: Converts a JSON string into a PHP value. If `$associative` is `true`, JSON objects will be converted into associative arrays; otherwise, they will be converted into `stdClass` objects.

XML (Extensible Markup Language)
XML is a markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable. It is designed to store and transport data. XML uses a tree-like structure composed of elements, attributes, and text content. Unlike HTML, XML does not have predefined tags; instead, it allows users to define their own tags, making it highly extensible. XML also supports DTDs (Document Type Definitions) or XML Schemas for validating the structure and content of XML documents. While often more verbose than JSON, XML provides robust features for complex data structures and validation. It has been historically used for web services (like SOAP), configuration files, and data archiving.

In PHP, there are several ways to process XML:
* SimpleXML: A popular and easy-to-use extension for accessing and manipulating XML. It converts XML into an object structure where elements and attributes can be accessed like object properties or array elements.
* `simplexml_load_string($xml_string)`: Parses an XML string into a `SimpleXMLElement` object.
* `simplexml_load_file($filename)`: Parses an XML file into a `SimpleXMLElement` object.
* DOM (Document Object Model): A more powerful and flexible API for working with XML (and HTML). It treats the XML document as a tree structure of nodes, providing fine-grained control over every part of the document. This is typically used for more complex XML manipulation, including creating new XML documents, modifying existing ones, or performing XPath queries.
* XML Parser (SAX - Simple API for XML): An event-based parser, useful for very large XML files where loading the entire document into memory (like SimpleXML or DOM) might be inefficient. It triggers events (e.g., 'start element', 'end element', 'character data') as it reads the XML stream.

Comparison:
* Verbosity: XML is generally more verbose due to its closing tags and attribute syntax. JSON is more concise.
* Readability: Both are human-readable, but JSON is often perceived as easier to read and write for simple data structures.
* Schema Support: XML has robust schema definition capabilities (DTD, XML Schema) for strict data validation. JSON also has schemas, but they are not as universally adopted or natively supported as XML's.
* Data Types: JSON natively supports basic data types (string, number, boolean, null, object, array). XML treats almost everything as text, requiring explicit type conversions in applications.
* Use Cases: JSON is preferred for modern web APIs (REST), configuration, and client-server communication due to its lightness. XML is still used in enterprise applications, SOAP-based web services, and situations requiring strong schema validation or document-oriented data.

Both formats are essential tools for any developer working with data integration and exchange, and PHP provides excellent native support for handling them.

<?php

// --- JSON Processing ---

echo "--- JSON Processing ---<br><br>";

// 1. Encoding PHP array/object to JSON string
$data = [
    'name' => 'Alice',
    'age' => 30,
    'city' => 'New York',
    'isStudent' => false,
    'courses' => ['Math', 'Physics', 'Chemistry']
];

$jsonString = json_encode($data, JSON_PRETTY_PRINT);

echo "PHP Array:<pre>";
print_r($data);
echo "</pre>";

echo "Encoded JSON String:<pre>";
echo htmlspecialchars($jsonString); // Use htmlspecialchars for safe display in browser
echo "</pre><br>";

// 2. Decoding JSON string back to PHP
$jsonToDecode = '{
    "product": "Laptop",
    "price": 1200.50,
    "inStock": true,
    "features": ["16GB RAM", "512GB SSD", "14 inch display"],
    "manufacturer": {
        "name": "Tech Corp",
        "country": "USA"
    }
}';

// Decode as an associative array
$decodedArray = json_decode($jsonToDecode, true);

echo "JSON String to Decode:<pre>";
echo htmlspecialchars($jsonToDecode);
echo "</pre>";

echo "Decoded as Associative Array:<pre>";
print_r($decodedArray);
echo "</pre>";

echo "Accessing decoded array data: Product Name - " . $decodedArray['product'] . "<br>";
echo "Manufacturer Country - " . $decodedArray['manufacturer']['country'] . "<br><br>";

// Decode as an object
$decodedObject = json_decode($jsonToDecode);

echo "Decoded as Object:<pre>";
print_r($decodedObject);
echo "</pre>";

echo "Accessing decoded object data: Product Price - " . $decodedObject->price . "<br>";
echo "In Stock? " . ($decodedObject->inStock ? 'Yes' : 'No') . "<br><br>";


// --- XML Processing (using SimpleXML) ---

echo "--- XML Processing ---<br><br>";

// 1. XML string to parse
$xmlString = '<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
    <book category="cooking">
        <title lang="en">Everyday Italian</title>
        <author>Giada De Laurentiis</author>
        <year>2005</year>
        <price>30.00</price>
    </book>
    <book category="children">
        <title lang="en">Harry Potter</title>
        <author>J. K. Rowling</author>
        <year>2005</year>
        <price>29.99</price>
    </book>
</bookstore>';

echo "XML String:<pre>";
echo htmlspecialchars($xmlString);
echo "</pre><br>";

// Parse the XML string
$xml = simplexml_load_string($xmlString);

if ($xml === false) {
    echo "Failed to load XML<br>";
    foreach(libxml_get_errors() as $error) {
        echo "\t" . $error->message;
    }
} else {
    echo "XML parsed successfully. Accessing data:<br>";

    // Access elements and attributes
    foreach ($xml->book as $book) {
        echo "Book Title: " . $book->title . " (lang: " . $book->title['lang'] . ")<br>";
        echo "Author: " . $book->author . "<br>";
        echo "Category: " . $book['category'] . "<br>"; // Access attribute of 'book' element
        echo "Price: $" . $book->price . "<br>";
        echo "--------------------<br>";
    }
}

?>