PHP XML Parser

PHP é uma linguagem de script popular para desenvolvimento web, permitindo que desenvolvedores criem sites dinâmicos incorporando código dentro de HTML. Um dos seus recursos mais úteis é a capacidade de trabalhar com XML, uma linguagem de marcação projetada para armazenar e transportar dados.

Neste guia, abordaremos a funcionalidade XML do PHP, incluindo suas vantagens, sintaxe e exemplos de uso. Ao final, você entenderá como trabalhar com XML para construir melhores sites e aplicações.

O que é XML?

XML significa "eXtensible Markup Language". É uma linguagem de marcação que permite aos desenvolvedores definir suas próprias tags e estruturas de documentos, tornando-a uma linguagem altamente flexível e personalizável. XML é comumente usado para armazenar e transportar dados, como em serviços web, bancos de dados e feeds RSS.

XML é semelhante ao HTML, mas enquanto o HTML define como as páginas web são exibidas em um navegador, o XML define a estrutura e o conteúdo dos dados. Tags XML são usadas para identificar elementos de dados e seus relacionamentos, facilitando a transferência de dados entre diferentes sistemas.

Vantagens de Usar XML no PHP

Usar XML no PHP oferece várias vantagens, incluindo:

• Troca de dados: XML é um formato ideal para trocar dados entre diferentes sistemas e plataformas. Como XML é independente de plataforma, os dados podem ser facilmente transferidos entre sistemas independentemente do sistema operacional ou linguagem de programação utilizada.
• Armazenamento de dados: XML é uma ótima maneira de armazenar e organizar dados em um formato estruturado. Ao usar XML para armazenar dados, os desenvolvedores podem acessar e manipular os dados facilmente conforme necessário.
• Transformação de dados: XML pode ser facilmente transformado em outros formatos, como HTML, PDF e CSV, usando XSLT (Extensible Stylesheet Language Transformations).

Sintaxe do XML no PHP

Para trabalhar com XML no PHP, você precisará estar familiarizado com a sintaxe usada para definir documentos XML. Documentos XML consistem em elementos, atributos e valores.

Elementos são definidos usando tags de abertura e fechamento, como <book> e </book>. Elementos também podem conter elementos filhos, como:

<book>
  <title>The Great Gatsby</title>
  <author>F. Scott Fitzgerald</author>
</book>

Atributos são usados para fornecer informações adicionais sobre elementos, como:

<book id="1234">
  <title>The Great Gatsby</title>
  <author>F. Scott Fitzgerald</author>
</book>

Valores são o conteúdo de um elemento, como "The Great Gatsby" ou "F. Scott Fitzgerald."

Qual abordagem XML devo usar?

PHP vem com três parsers, e escolher o correto é importante:

• SimpleXML — a API mais simples. Ela transforma um documento XML em uma árvore de objetos que você navega com sintaxe de propriedade normal ($xml->book->title). Melhor para documentos pequenos a médios com uma estrutura conhecida. Este guia foca no SimpleXML; veja PHP SimpleXML para uma referência mais aprofundada.
• DOMDocument (a extensão DOM) — uma implementação completa do DOM W3C. Mais verbosa, mas permite criar, mover e remover nós com precisão, sendo necessária para XSLT e validação. Veja PHP XML DOM.
• XMLReader / XMLWriter — um parser de streaming baseado em pull. Lê um nó por vez em vez de carregar a árvore inteira na memória, sendo a escolha certa para arquivos muito grandes (centenas de MB) onde SimpleXML e DOM esgotariam a memória.

As funções SAX históricas xml_parser_create() ainda existem, mas raramente são usadas em código novo; o SimpleXML cobre o mesmo terreno com muito menos código repetitivo.

Lendo um documento XML com SimpleXML

Para carregar um arquivo XML em uma árvore de objetos, use a função simplexml_load_file(). Se a fonte for uma string (por exemplo, uma resposta de API) em vez de um arquivo, use simplexml_load_string().

Sempre verifique o valor de retorno: em um documento malformado, ambas as funções retornam false em vez de lançar uma exceção, então um resultado não verificado é uma fonte comum de bugs silenciosos.

$xml = simplexml_load_file("books.xml");
if ($xml === false) {
    echo "Failed to load XML file.";
    exit;
}

Isso lê o arquivo XML e o converte em um objeto SimpleXMLElement, que você acessa usando a sintaxe orientada a objetos do PHP. Elementos filhos se tornam propriedades, e elementos repetidos (como múltiplas tags <book>) se comportam como uma lista iterável.

Lendo atributos

Atributos não são propriedades — você os lê com sintaxe de array no elemento. Dado <book id="1234">, o id é $book['id']:

$xml = simplexml_load_string('<book id="1234"><title>The Great Gatsby</title></book>');
echo $xml['id'];     // 1234
echo $xml->title;    // The Great Gatsby

Note que os valores do SimpleXML são objetos, não strings simples. Converta com (string) quando precisar de uma string real (por exemplo, antes de uma comparação estrita ou json_encode).

Escrevendo um documento XML com SimpleXML

Para construir XML do zero, crie um SimpleXMLElement com um elemento raiz e adicione filhos com addChild():

$xml = new SimpleXMLElement('<books></books>');
$book = $xml->addChild('book');
$book->addChild('title', 'The Great Gatsby');
$book->addChild('author', 'F. Scott Fitzgerald');
$xml->asXML('books.xml');

Isso cria um SimpleXMLElement com o elemento raiz <books>, adiciona um filho <book> com filhos <title> e <author>, e salva o documento em books.xml. Chamar asXML() sem argumento retorna o XML como uma string em vez de gravar um arquivo, o que é útil quando você precisa enviá-lo em uma resposta HTTP.

Exemplos de Uso

Vejamos alguns exemplos práticos de uso de XML no PHP.

Lendo Dados XML

Suponha que você tenha um arquivo XML chamado "books.xml" com os seguintes dados:

<books>
  <book>
    <title>The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
  </book>
  <book>
    <title>To Kill a Mockingbird</title>
    <author>Harper Lee</author>
  </book>
</books>

Para ler esses dados no PHP, você pode usar a função simplexml_load_file(), assim:

$xml = simplexml_load_file("books.xml");
if ($xml === false) {
    echo "Failed to load XML file.";
    exit;
}
foreach ($xml->book as $book) {
  echo $book->title . " by " . $book->author . "\n";
}

Este código carrega o arquivo XML em um objeto SimpleXMLElement e itera sobre cada elemento <book> usando um loop foreach. Dentro do loop, ele acessa os elementos filhos <title> e <author> usando sintaxe orientada a objetos e os exibe no console.

Escrevendo Dados XML

Suponha que você queira criar um novo arquivo XML com os seguintes dados:

<colors>
  <color>
    <name>Red</name>
    <hex>#FF0000</hex>
  </color>
  <color>
    <name>Green</name>
    <hex>#00FF00</hex>
  </color>
  <color>
    <name>Blue</name>
    <hex>#0000FF</hex>
  </color>
</colors>

Para criar esses dados XML no PHP, você pode usar a classe SimpleXMLElement, assim:

$xml = new SimpleXMLElement('<colors></colors>');
$red = $xml->addChild('color');
$red->addChild('name', 'Red');
$red->addChild('hex', '#FF0000');
$green = $xml->addChild('color');
$green->addChild('name', 'Green');
$green->addChild('hex', '#00FF00');
$blue = $xml->addChild('color');
$blue->addChild('name', 'Blue');
$blue->addChild('hex', '#0000FF');
$xml->asXML('colors.xml');

Este código cria um novo objeto SimpleXMLElement com o elemento raiz <colors>. Em seguida, adiciona três elementos filhos <color>, cada um com dois elementos filhos <name> e <hex>, e define seus valores correspondentemente. Por fim, salva o documento XML em um arquivo chamado "colors.xml."

Armadilhas comuns

• Resultado de carregamento não verificado. simplexml_load_file() e simplexml_load_string() retornam false, não null, em caso de erro de parse. Teste com === false antes de usar o resultado.
• Valores são objetos, não strings. $xml->title é um SimpleXMLElement. Funciona em contextos de string (echo, concatenação), mas falha em comparações inesperadas; converta com (string) em caso de dúvida.
• Erros de parse suprimidos. Para inspecionar por que o parsing falhou, chame libxml_use_internal_errors(true) antes de carregar e depois leia libxml_get_errors().
• Namespaces. Se seu XML usa namespaces (ex.: xmlns:), o acesso por propriedade simples não encontrará os elementos — use children() ou xpath() com o namespace registrado.
• Entrada não confiável. Não faça parse de XML de fontes não confiáveis sem cuidado: ataques de entidade externa (XXE) são um risco real. No PHP moderno, o carregamento de entidades relevantes está desabilitado por padrão, mas verifique antes de processar XML fornecido pelo usuário.

Tópicos relacionados

• PHP SimpleXML — referência completa para a extensão SimpleXML.
• simplexml_load_file() e simplexml_load_string() — as duas funções de carregamento em detalhes.
• PHP XML DOM — a API DOMDocument mais poderosa.
• PHP JSON — a alternativa mais leve para intercâmbio de dados.

Conclusão

Neste guia, abordamos o que é XML, por que é útil e como ler, escrever e manipular XML no PHP com a biblioteca SimpleXML, além das armadilhas comuns a observar. SimpleXML é a maneira mais rápida de lidar com dados XML estruturados no PHP; use DOMDocument quando precisar de controle refinado de nós e XMLReader para arquivos muito grandes. Note que as funções XML do PHP requerem a extensão libxml, que está habilitada por padrão na maioria das instalações padrão.

Prática