node-expat

What is node-expat?

The node-expat package is a fast XML parser for Node.js, which is a binding for the Expat XML parser library. It is used to parse XML documents efficiently and can handle large XML files with ease. It provides a streaming interface for XML parsing, making it suitable for applications that need to process XML data in real-time or in chunks.

What are node-expat's main functionalities?

Basic XML Parsing

This feature allows you to parse XML documents and handle different events such as start and end of elements, and text nodes. The code sample demonstrates how to set up a basic XML parser and handle these events.

const expat = require('node-expat');
const parser = new expat.Parser('UTF-8');

parser.on('startElement', (name, attrs) => {
  console.log(`Start element: ${name}`);
  console.log(attrs);
});

parser.on('endElement', (name) => {
  console.log(`End element: ${name}`);
});

parser.on('text', (text) => {
  console.log(`Text: ${text}`);
});

const xml = '<root><child id="1">Hello</child></root>';
parser.write(xml);

Streaming XML Parsing

This feature allows you to parse large XML files by streaming the data. The code sample demonstrates how to set up a streaming XML parser that reads from a file stream, making it suitable for processing large XML files without loading the entire file into memory.

const fs = require('fs');
const expat = require('node-expat');
const parser = new expat.Parser('UTF-8');

parser.on('startElement', (name, attrs) => {
  console.log(`Start element: ${name}`);
  console.log(attrs);
});

parser.on('endElement', (name) => {
  console.log(`End element: ${name}`);
});

parser.on('text', (text) => {
  console.log(`Text: ${text}`);
});

const stream = fs.createReadStream('path/to/large.xml');
stream.pipe(parser);

Other packages similar to node-expat

sax

The sax package is a simple, fast, and streaming XML parser for Node.js. It provides a similar streaming interface for XML parsing but is written entirely in JavaScript, making it more portable. Compared to node-expat, sax may be slower for very large XML files but is easier to install and use since it does not require native bindings.

xml2js

The xml2js package is a popular XML parser that converts XML documents into JavaScript objects. It is not a streaming parser like node-expat but is very convenient for converting XML data into a more easily manipulable format. It is suitable for smaller XML files or when you need to work with the entire XML document as a JavaScript object.

fast-xml-parser

The fast-xml-parser package is a fast and lightweight XML parser that can parse XML into JavaScript objects. It supports both synchronous and asynchronous parsing and can handle large XML files efficiently. Compared to node-expat, it offers more flexibility in terms of parsing options and does not require native bindings, making it easier to install and use.

README

node-expat

Motivation

You use node.js for speed? You process XML streams? Then you want the fastest XML parser: libexpat!

Speed

A stupid speed test is supplied in bench.js. We measure how many 25-byte elements a SAX parser can process:

• node-xml (pure JavaScript): 23,000 el/s
• libxmljs (libxml2 binding): 77,000 el/s
• node-expat (libexpat binding, this): 113,000 el/s

These numbers were recorded on a Core 2 2400 MHz and may turn out to be bullshit, given my few node.js experience.

Instructions

node-waf configure
node-waf build

For using the library, make sure build/default/expat.node is in either $NODE_PATH or require.paths.

Important events emitted by a parser:

• startElement with name, attrs
• endElement with name
• text with string

There are more. Use test.js for reference.

Error handling

We don't emit an error event because libexpat doesn't use a callback either. Instead, check that parse() returns true. A descriptive string can be obtained via getError() to provide user feedback.

Namespace handling

A word about special parsing of xmlns: this is not neccessary in a bare SAX parser like this, given that the DOM replacement you are using (if any) is not relevant to the parser.