js2xmlparser

What is js2xmlparser?

The js2xmlparser npm package is a library that allows users to convert JavaScript objects into XML. It is particularly useful for creating XML data from JSON format, supporting various customization options to handle complex data structures and attributes.

What are js2xmlparser's main functionalities?

Basic XML Conversion

Converts a simple JavaScript object into XML. The example shows converting a person object with first and last names into an XML string.

const js2xmlparser = require('js2xmlparser');
let person = {
  firstName: 'John',
  lastName: 'Doe'
};
let xml = js2xmlparser.parse('person', person);
console.log(xml);

XML with Attributes

Demonstrates how to include attributes in the XML output. The '@' property is used to specify attributes for the XML element.

const js2xmlparser = require('js2xmlparser');
let person = {
  '@': {
    id: '12345'
  },
  firstName: 'John',
  lastName: 'Doe',
  email: '[e-mail]'
};
let xml = js2xmlparser.parse('person', person);
console.log(xml);

Handling Arrays

Shows how to handle JavaScript arrays to produce nested XML elements. Each object in the 'members' array becomes a separate XML element.

const js2xmlparser = require('js2xmlparser');
let family = {
  lastName: 'Doe',
  members: [
    {
      firstName: 'John',
      relationship: 'Father'
    },
    {
      firstName: 'Jane',
      relationship: 'Mother'
    }
  ]
};
let xml = js2xmlparser.parse('family', family);
console.log(xml);

Other packages similar to js2xmlparser

xml2js

xml2js is another popular npm package that primarily focuses on converting XML data to JavaScript objects but also supports XML building. It differs from js2xmlparser by providing bi-directional conversion (XML to JS and JS to XML) and has a slightly different API for handling options.

xmlbuilder

xmlbuilder is an npm package that provides an easy interface to build XML documents from JavaScript. Unlike js2xmlparser, which is more focused on converting existing JS objects to XML, xmlbuilder allows for more dynamic creation of XML documents through a fluent interface.

README

js2xmlparser

Overview

js2xmlparser is a Node.js module that parses JavaScript objects into XML.

Features

Since XML is a data-interchange format, js2xmlparser is designed primarily for JSON-type objects, arrays and primitive data types, like many of the other JavaScript to XML parsers currently available for Node.js.

However, js2xmlparser is capable of parsing any object, including native JavaScript objects such as Date and RegExp, by taking advantage of each object's toString function or, if this function does not exist, the String constructor.

js2xmlparser also has support for the new Map and Set objects introduced in ECMAScript 2015, treating them as JSON-type objects and arrays respectively. Support for Maps is necessary to generate XML with elements in a specific order, since JSON-type objects do not guarantee insertion order. Map keys are always converted to strings using the method described above.

js2xmlparser also supports a number of constructs unique to XML:

• attributes (through an attribute property in objects)
• mixed content (through value properties in objects)
• multiple elements with the same name (through arrays)

js2xmlparser can also pretty-print the XML it outputs.

Installation

The easiest way to install js2xmlparser is using npm:

npm install js2xmlparser

You can also build js2xmlparser from source using gulp:

git clone https://github.com/michaelkourlas/node-js2xmlparser.git
npm install
typings install
gulp

You'll need to install gulp and typings first if you don't have them:

npm install -g gulp
npm install -g typings

You can then copy the folder into your node_modules directory.

The default target will build the production variant of js2xmlparser, run all tests, and build the documentation.

You can build the production variant without running tests using the target prod. You can also build the development version using the target dev. At the moment, the only difference between the two is that the development version includes source maps.

Usage

The documentation for the current version is available here.

You can also build the documentation using gulp:

gulp docs

Examples

The following example illustrates the basic usage of js2xmlparser:

var js2xmlparser = require("js2xmlparser");

var obj = {
    "firstName": "John",
    "lastName": "Smith",
    "dateOfBirth": new Date(1964, 7, 26),
    "address": {
        "@": {
            "type": "home"
        },
        "streetAddress": "3212 22nd St",
        "city": "Chicago",
        "state": "Illinois",
        "zip": 10000
    },
    "phone": [
        {
            "@": {
                "type": "home"
            },
            "#": "123-555-4567"
        },
        {
            "@": {
                "type": "cell"
            },
            "#": "890-555-1234"
        },
        {
            "@": {
                "type": "work"
            },
            "#": "567-555-8901"
        }
    ],
    "email": "[e-mail]"
};

console.log(js2xmlparser.parse("person", obj));

This example produces the following XML:

<?xml version='1.0'?>
<person>
    <firstName>John</firstName>
    <lastName>Smith</lastName>
    <dateOfBirth>Wed Aug 26 1964 00:00:00 GMT-0400 (Eastern Summer Time)</dateOfBirth>
    <address type='home'>
        <streetAddress>3212 22nd St</streetAddress>
        <city>Chicago</city>
        <state>Illinois</state>
        <zip>10000</zip>
    </address>
    <phone type='home'>123-555-4567</phone>
    <phone type='cell'>890-555-1234</phone>
    <phone type='work'>567-555-8901</phone>
    <email>[e-mail]</email>
</person>

Additional examples can be found in examples/example.js.

Tests

js2xmlparser includes a set of tests to verify core functionality. You can run the tests using gulp:

gulp test

The test target builds the production variant of js2xmlparser before running the tests. The test-prod target does the same thing, while the test-dev target builds the development variant first instead.

License

js2xmlparser is licensed under the Apache License 2.0. Please see the LICENSE.md file for more information.

Changelog

2.0.0

• Re-write in TypeScript

• Re-write to use xmlcreate (greatly simplifies module source)

• Added support for the ECMAScript 2015 Map and Set objects

• New method of calling module:

  var js2xmlparser = require("js2xmlparser");
  
  var root = "root";
  var data = {hello: "world"};
  var options = {};
  
  // old method (no longer works):
  // js2xmlparser(root, data, options);
  
  // new method:
  js2xmlparser.parse(root, data, options);
  

• New options and changes to functionality of some existing options:

  • declaration contains additional options
  • attributeString has additional functionality
  • valueString has additional functionality
  • The functionality provided by prettyPrinting is now provided by the new format option, which contains additional options
  • arrayMap is now wrapHandlers to reflect the fact that wrapping is provided for both arrays and ES2015 sets
  • convertMap is now typeHandlers to match the name change to arrayMap
  • The functionality provided by useCDATA is now provided by the new cdataInvalidChars and cdataKeys options, which also provide additional functionality
  • Added support for document type definitions using the dtd option