Welcome to our exploration of XML, a widely used format for storing and exchanging structured data. Unlike JSON, which we've discussed in previous lessons as a lightweight data format, XML provides a more robust structure that resembles a tree, ideal for representing hierarchical data. XML stands for eXtensible Markup Language and is renowned for its self-descriptive nature, where each piece of data is wrapped in tags, forming a clear hierarchy.

Here's a simple analogy: consider an XML document like a family tree where each branch represents categories of data and the leaves represent the actual data entries. Unlike rigid data formats, XML's flexibility means you can define your structure with custom tags, making it highly adaptable to various applications, from web services to data configuration.

Just like JSON, XML is pivotal in data exchange processes across different systems. Throughout this lesson, we aim to deepen your understanding of XML's structure and how to use R's xml2 package to parse and manipulate XML data efficiently.

First, let's consider an XML file named data.xml. Our goal is to read and understand its structure:

HTML, XML
Copy to clipboard
1<school>
2    <student>
3        <name>Emma</name>
4        <grade>10</grade>
5    </student>
6    <student>
7        <name>Liam</name>
8        <grade>9</grade>
9    </student>
10    <student>
11        <name>Olivia</name>
12        <grade>11</grade>
13    </student>
14</school>

This XML document describes a school with several students, each having a name and a grade. The root element here is <school>, encapsulating the nested <student> elements.

To begin parsing, we start by loading the xml2 package and reading the XML document. Note that xml2 is an R package, which can be installed from CRAN.

R
Copy to clipboard
1library(xml2)
2
3file_path <- "data.xml"
4xml_data <- read_xml(file_path)

1. Loading the xml2 Package: We first load the xml2 package, which provides functionality for XML parsing in R.
2. Reading the XML: The read_xml(file_path) function reads the XML file and returns an XML document object representing the data structure.

With the XML data loaded, we can now explore how to traverse the XML tree and extract data. The following code illustrates extracting student names and grades:

R
Copy to clipboard
1cat("Parsed XML data:\n")
2students <- xml_find_all(xml_data, ".//student")
3for (student in students) {
4  name <- xml_text(xml_find_first(student, "name"))
5  grade <- xml_text(xml_find_first(student, "grade"))
6  cat(sprintf("Student Name: %s, Grade: %s\n", name, grade))
7}

1. Finding <student> Elements: We use the xml_find_all(xml_data, ".//student") function to retrieve all <student> elements. The ".//student" string is an XPath expression. In XPath, the "." symbol refers to the current node, and the "//" indicates that the search should include all descendants of this node, regardless of their depth in the hierarchy. This means that by using ".//student", we can find all <student> elements nested anywhere within the XML structure, starting from the root node, eliminating the need for specifying the complete path to the nodes.
2. Accessing Sub-elements: Within each <student>, we use xml_find_first(student, "name") and xml_find_first(student, "grade") to access the name and grade sub-elements, respectively. The xml_text() function extracts the text content inside the element.
3. Output Data: We print each student's name and grade, transforming XML data into a human-readable format.

The above code block outputs:

Plain text
Copy to clipboard
1Parsed XML data:
2Student Name: Emma, Grade: 10
3Student Name: Liam, Grade: 9
4Student Name: Olivia, Grade: 11

Each step in this process reflects how the xml2 package simplifies hierarchical data navigation, allowing you to effortlessly extract meaningful information from structured data.

In this lesson, you discovered how XML, a structured format for hierarchical data, is critical for data interchange across systems. We explored parsing and constructing XML files using R's xml2 package, focusing on extracting real-world data from structured documents.

You've built on your existing knowledge of structured formats, akin to JSON, and now possess practical skills in handling XML data proficiently. As you move forward, I encourage you to practice parsing custom XML files, reinforcing these concepts. This lesson serves as a foundation; upcoming exercises will enhance your understanding and ability to handle various data formats. Keep experimenting with XML, and you'll find it a key tool in your data management toolkit.