Read from xml javascript

Reads XML documents and emits JavaScript objects with a simple, easy to use structure.

Small, fast and simple
Runs everywhere (browser, node.js, React Native, ServiceWorkers, WebWorkers. )
Event driven and synchronous API
Can process input piece-by-piece in a serial fashion
Stream mode (low memory usage)
Reads CDATA sections

npm install --save xml-reader

Objects emitted by the reader are trees where each node has the following structure:

interface XmlNode 
 name: string; // element name (empty for text nodes)
 type: string; // node type (element or text), see NodeType constants
 value: string; // value of a text node
 parent: XmlNode; // reference to parent node (null with parentNodes option disabled or root node)
 attributes: [name: string]: string>; // map of attributes name => value
 children: XmlNode[]; // array of children nodes
>

Breaking changes in version 2

Added the tagPrefix option with a default value of ‘tag:’ . This way we avoid possible name collisions with the done event. To keep the old behavior, set it to an empty string.

Check the xml-query package! It is very useful to read values from the structures returned by xml-reader .

Read document (event driven)

Basic example. Read and parse a XML document.

const XmlReader = require('xml-reader');
const reader = XmlReader.create();
const xml =
 ` 
  Alice
 Bob
 Hello
 This is a demo!
 `;
 reader.on('done', data => console.log(data));
reader.parse(xml);
 /*
Console output:
 < name: 'message',
 type: 'element',
 children: [
 < name: 'to',
 type: 'element',
 children: [< type: 'text', value: 'Alice' >]>,
 < name: 'from',
 type: 'element',
 children: [< type: 'text', value: 'Bob' >]>,
 < name: 'heading',
 type: 'element',
 attributes: < color: 'blue' >,
 children: [< type: 'text', value: 'Hello' >]>,
 < name: 'body',
 type: 'element',
 attributes: < color: 'red' >,
 children: [< type: 'text', value: 'This is a demo!' >]>]>
 Note: empty values and references to parent nodes removed for brevity!
*/

Read document (synchronous)

This mode is only valid for reading complete documents (root node must be closed).

const XmlReader = require('xml-reader');
 const xml = 'Hello!';
const result = XmlReader.parseSync(xml/*, options*/);

In stream mode, nodes are removed from root as they are emitted. This way memory usage does not increases.

const XmlReader = require('xml-reader');
 const reader = XmlReader.create(stream: true>);
const xml =
 ` 
 
 
 
 `;
 reader.on('tag:item', (data) => console.log(data));
// , children: []>
// , children: []>
// , children: []>
 reader.on('done', (data) => console.log(data.children.length));
// 0
 reader.parse(xml);

You can also listen to all tags:

reader.on('tag', (name, data) => console.log(`received a $name> tag:`, data));

In this example we are calling multiple times to the parser. This is useful if your XML document is a stream that comes from a TCP socket or WebSocket (for example XMPP streams).

Simply feed the parser with the data as it arrives. As you can see, the result is exactly the same as the previous one.

const XmlReader = require('xml-reader');
 const reader = XmlReader.create(stream: true>);
const xml =
 ` 
 
 
 
 `;
 reader.on('tag:item', (data) => console.log(data));
// , children: []>
// , children: []>
// , children: []>
 reader.on('done', (data) => console.log(data.children.length));
// 0
 // Note that we are calling the parse function providing just one char each time
xml.split('').forEach(char => reader.parse(char));

Use the reset() method to reset the reader. This is useful if a stream gets interrupted and you want to start a new one or to use the same reader instance to parse multiple documents (just reset the reader between them).

const doc1 = '. ';
const doc2 = '. ';
 reader.parse(doc1);
 // when the document ends, the reader stops emitting events
reader.reset();
 // now you can parse a new document
reader.parse(doc2);


 stream: false,
 parentNodes: true,
 tagPrefix: 'tag:',
 doneEvent: 'done',
 emitTopLevelOnly: false,
>

If true (default), each node of the AST has a parent node which point to its parent. If false the parent node is always null .

Enable or disable stream mode. In stream mode nodes are removed from root after being emitted. Default false . Ignored in parseSync ;

Default value is ‘done’ . This is the name of the event emitted when the root node is closed and the parse is done. Ignored in parseSync ;

Default value is ‘tag:’ . The event driven API emits an event each time a tag is read. Use this option to set a name prefix. Ignored in parseSync ;

Default value is false . When true, tag events are only emitted by top level nodes (direct children from root). This is useful for XMPP streams like XMPP where each top level child is a stanza.

For example, given the following XML stream:

stream>
 message from="alice" to="bob">
 body>hellobody>
 date>2016-10-06date>
 message>
  message from="alice" to="bob">
 body>byebody>
 date>2016-10-07date>
 message>

tags emitted with emitTopLevelOnly=false

body
date
message
body
date
message

tags emitted with emitTopLevelOnly=true

Источник

Parsing and serializing XML

At times, you may need to parse XML content and convert it into a DOM tree, or, conversely, serialize an existing DOM tree into XML. In this article, we’ll look at the objects provided by the web platform to make the common tasks of serializing and parsing XML easy.

Serializes DOM trees, converting them into strings containing XML.

Constructs a DOM tree by parsing a string containing XML, returning a XMLDocument or Document as appropriate based on the input data.

Loads content from a URL; XML content is returned as an XML Document object with a DOM tree built from the XML itself.

A technology for creating strings that contain addresses for specific portions of an XML document, and locating XML nodes based on those addresses.

Creating an XML document

Using one of the following approaches to create an XML document (which is an instance of Document ).

Parsing strings into DOM trees

This example converts an XML fragment in a string into a DOM tree using a DOMParser :

const xmlStr = 'hey!'; const parser = new DOMParser(); const doc = parser.parseFromString(xmlStr, "application/xml"); // print the name of the root element or error message const errorNode = doc.querySelector("parsererror"); if (errorNode)  console.log("error while parsing"); > else  console.log(doc.documentElement.nodeName); >

Parsing URL-addressable resources into DOM trees

Using XMLHttpRequest

Here is sample code that reads and parses a URL-addressable XML file into a DOM tree:

const xhr = new XMLHttpRequest(); xhr.onload = () =>  dump(xhr.responseXML.documentElement.nodeName); >; xhr.onerror = () =>  dump("Error while getting XML."); >; xhr.open("GET", "example.xml"); xhr.responseType = "document"; xhr.send();

The value in the xhr object’s responseXML field is a Document constructed by parsing the XML.

If the document is HTML, the code shown above will return a Document . If the document is XML, the resulting object is actually a XMLDocument . The two types are essentially the same; the difference is largely historical, although differentiating has some practical benefits as well.

Note: There is in fact an HTMLDocument interface as well, but it is not necessarily an independent type. In some browsers it is, while in others it is an alias for the Document interface.

Serializing an XML document

Given a Document , you can serialize the document’s DOM tree back into XML using the XMLSerializer.serializeToString() method.

Use the following approaches to serialize the contents of the XML document you created in the previous section.

Serializing DOM trees to strings

First, create a DOM tree as described in How to Create a DOM tree. Alternatively, use a DOM tree obtained from XMLHttpRequest .

To serialize the DOM tree doc into XML text, call XMLSerializer.serializeToString() :

const serializer = new XMLSerializer(); const xmlStr = serializer.serializeToString(doc);

Serializing HTML documents

If the DOM you have is an HTML document, you can serialize using serializeToString() , but there is a simpler option: just use the Element.innerHTML property (if you want just the descendants of the specified node) or the Element.outerHTML property if you want the node and all its descendants.

const docInnerHtml = document.documentElement.innerHTML;

As a result, docInnerHtml is a string containing the HTML of the contents of the document; that is, the element’s contents.

You can get HTML corresponding to the and its descendants with this code:

const docOuterHtml = document.documentElement.outerHTML;

MDN

Support

Our communities

Developers

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.

Источник

Read from xml javascript

WordPress 6 с Нуля до Гуру

Этот курс научит Вас созданию самых разных сайтов на самой популярной в мире CMS — WordPress. Вы увидите установку и настройку локального сервера, разбор каждой настройки, каждой кнопки и каждого пункта меню в панели WordPress.

Также Вы получите и всю практику, поскольку прямо в курсе с нуля создаётся полноценный Интернет-магазин, который затем публикуется в Интернете. И всё это прямо на Ваших глазах.

Помимо уроков к курсу идут упражнения для закрепления материала.

И, наконец, к курсу идёт ценнейший Бонус по тому, как используя ChatGPT и создавая контент для сайта, можно выйти на пассивный доход. Вы наглядно увидите, как зарегистрироваться в ChatGPT (в том числе, и если Вы из России), как правильно выбрать тему для сайта, как правильно генерировать статьи для него(чтобы они индексировались поисковыми системами) и как правильно монетизировать трафик на сайте.

Подпишитесь на мой канал на YouTube, где я регулярно публикую новые видео.

YouTube