parse-strings-in-object

Parse Strings in JS Object

Overview

A very simple module that takes a JavaScript object and returns a new object with string representations of booleans, nulls and numbers converted to their proper types.

So:

• 'true' and 'false' becomes true and false
• '1' and '3.147' become 1 and 3.147
• '192.168.1.1' is left alone even though it "looks" like a number
• 'null' becomes null

It works recursively, so nested structures are no problem.

This module was originally inspired by the experience of using a configuration module (rc) and having to check things like active === false || active === 'false' repeatedly. I have therefore provided an example of this use case below.

Usage

Install from npm:

npm install parse-strings-in-object

In JS

There is only one argument to pass to the module - a valid JavaScript object.

const parser = require('parse-strings-in-object');
const niceParsedObject = parser(yourOriginalObject);

Or, more tersely:

const niceParsedObject = require('parse-strings-in-object')(yourOriginalObject)

In TypeScript

Import and use:

import parser from 'parse-strings-in-object';

const niceParsedObject = parser(yourOriginalObject);

Example

const before = {
    active: true,
    anInt: 1,
    aFloat: 1.1,
    justAString: 'hello',
    ipAddress: '192.168.1.101'
}

let after = require("parse-strings-in-object")(before);
console.log(JSON.stringify(after, null, 4), typeof after.aFloat, 'and also a', typeof after.anInt);

The output will be:

{
    active: true,
    anInt: 1,
    aFloat: 1.1,
    justAString: 'hello',
    ipAddress: '192.168.1.101'
}
number
and also a
number

Notice that both ints and floats are converted correctly to the single number type, and a number-like string such as an IP address is left alone (stays a string).

---

Example in rc config

The rc module for configuration loading allows hard-coded defaults (where types are respected) and also overrides ini files, environment variables and command-line params, where only strings are possible. This makes strict comparisons with === prone to bugs.

The module addresses this nicely. Just wrap the returned config object in a parse-strings-in-object require statement. For example:

const conf = require('parse-strings-in-object')(require('rc')('myapp', {
    anOrdinaryString: 'test',
    aBoolean: true,
    aNumber: 9000
}));

Now, if you run your app with --aBoolean=false or --aNumber=9001 then you can safely check whether aBoolean === true or aNumber===9000 and get the expected results.

Why is this necessary?

JavaScript can coerce types, so this can get you into trouble. For example, you might get configuration or JSON including strings as values:

'isMaster': 'true',
myNumber: '0'

So, now:

console.log(isMaster); // "true": as expected, but actually string
console.log(isMaster==true, isMaster===true); // "false false": oops
console.log(myNumber); // "0": as expected, but actually a string
console.log(typeof myNumber, myNumber==0, myNumber===0); // "string true false": hmmm
console.log(!myNumber); // "true": this is getting confusing

Development and testing

Feel free to improve the module! All pull requests shall be considered.

Since the module is written in TypeScript, you need to npm run build before using.

Unit tests provided by the Jest framework:

npm run test