javascript JSON parse object property directly to int

JSON.parse accepts a second argument in the form of a function that can do some post processing.

JSON.parse('{"p": "5"}', function(k, v) { 
    return (typeof v === "object" || isNaN(v)) ? v : parseInt(v, 10); 
});

I you don't want to process all numeric strings, then create a lookup table of the properties you do want.

var props = {"p":1, "some_prop":1, "another_prop":1};

JSON.parse('{"p": "5"}', function(k, v) { 
    return props.hasOwnProperty(k) ? parseInt(v, 10) : v; 
});

If your data source can't be fixed (numbers should be passed as numbers, not as strings), you can pass JSON.parse a "reviver" function, which will receive each item as it's being processed. This gives you the option of transforming it:

// Create this once
var propsToConvert = {
    TheProperty: 1,
    TheOtherProperty: 1,
    YetAnotherProperty: 1,
    // ...and so on...
};

// Use it each time you parse
var obj = JSON.parse(str, function(key, value) {
    if (propsToConvert.hasOwnProperty(key)) {
        return parseInt(value, 10);
    }
    return value;
});

Live example | source

Or if the property names are not sufficiently unique (TheProperty doesn't always need handling, just when it's a property of TheObject), you can do this as a two-level check:

// Define the object names and their property names (once)
var propsToConvert = {
    TheObject: {
        TheProperty: 1,
        TheOtherProperty: 1,
        YetAnotherProperty: 1,
        // ...and so on...
    },
    AnotherObject: {
        // Other properties...
    }
};

// Use it each time you parse
var obj = JSON.parse(str, function(key, value) {
    var name, props;

    if (typeof value === "object") {
        props = propsToConvert[key];
        if (props) {
            for (name in props) {
                value[name] = parseInt(value[name], 10);
            }
        }
    }
});

(Revivers are called inside-out, so the properties will be on the object by the time you see the object's key; that's why we update them in place.)

You get the idea, there's a lot you can do with reviver functions.

Side note: parseInt, which I've used above, is fairly forgiving — possibly more forgiving than you want. For instance:

var a = parseInt('1a', 10); // 1, instead of NaN

If you're okay with strings like "0x10" being treated as hex, then:

var a = Number(str);

...which will give you NaN for invalid number strings (Number("1a") is NaN). Since JSON isn't meant to have hex numbers, if you're sure the broken data source won't encode them as hex, you're golden.

Otherwise, if you need decimal but you want to be strict, you'll need to do a regex on the string to make sure it matches the pattern for a valid decimal number (which is fairly complex, if you want to support all the stuff JavaScript numeric literals support).

I don't think you'll be able to modify the parser, but instead of many similar lines of code, use an array of the properties and access them with the [] notation in a loop to parseInt() them. Of course, if you have access to the code producing the JSON, it is easier to change it to output ints properly unquoted.

// Array of properties you want to parse out
var parseUs = ['prop1','prop2','prop3','prop4'];

// Array of objects you need to parse them in
var objs = [obj1, obj2, obj3];

// Iterate over the objects
for (var i=0; i<objs.length; i++) {

  // And over the properties array
  for (var j=0; j<parseUs.length; j++) {
    // Parse out the int value if the object has the property
    if (objs[i].hasOwnProperty(parseUs[j]) {
      objs[i][parseUs[j]] = parseInt(parseUs[j], 10);
    }
  }
}

Note: This won't work if the objects share property names which are not int values in all of them. If that's the case, you would need to modify this to use an array of properties per object.

@kbec gives the correct answer. If you don't have control over your data source, then you can use something like this:

function intify(obj, fields) {
  if (typeof(obj) == "undefined") return;
  var numFields = fields.length;
  for (var i = 0; i < numFields; i++) {
    var field = fields[i];
    if (typeof(obj[field]) != "undefined") {
      obj[field] = parseInt(obj[field], 10);
    }
  }
  return obj;
}

intify(obj, ['foo', 'bar']);
intify(obj.baz, ['boo']);