Cross-browser JSON Serialization in JavaScript

In this article we will examine the benefits of object serialization, the current browser implementations, and develop some code that could help your Ajax-based projects. Assume we have a fairly complex JavaScript object defined using literal notation:


var obj1 = {
	b1: true,
	s1: "text string",
	n1: 12345,
	n2: null,
	n3: undefined,
	a1: [ 1,1,2,3,5,8, [13, 21, 34] ],
	o1: {
		a: [3, 2, 1],
		b: {
			c: 42,
			d: [ 3.14, 1.618 ]
		}
	}
};

We can access any of the object properties in a variety of ways:


obj1.s1;				// returns "text string"
obj1["n1"];				// returns 12345
obj1.a1[6][1];			// returns 21
obj1["o1"]["b"]["c"];	// returns 42

This object can also be passed to JavaScript functions and methods rather than specifying individual arguments. Useful stuff. However, what if we need to store this object in a cookie? What if we need to pass the object to a web services via an Ajax request? What if that web service wants to return a modified version of the object? The answer is serialization:

Serialization is the process of turning any object into a string.
De-serialization turns that string back into a native object.

Perhaps the best string notation we can use in JavaScript is JSON — JavaScript Object Notation. JSON is a lightweight data-interchange format inspired by JavaScript object literal notation as shown above. JSON is supported by PHP and many other server-side languages (refer to json.org). There are two JSON methods in JavaScript:

JSON.stringify(obj) — converts an JavaScript object to a JSON string
JSON.parse(str) — converts a JSON string back to a JavaScript object

Unfortunately, very few browsers provide these methods. To date, only Firefox 3.5, Internet Explorer 8.0 and Chrome 3 beta offer native support. Some JavaScript libraries offer their own JSON tools (such as YUI

) but many do not (including jQuery). However, all is not lost — JavaScript is flexible and we can implement the JSON stringify and parse methods whenever a browser requires them. At the top of our code, we will create a JSON variable that points to the native JSON object or an empty object if it is unavailable:


var JSON = JSON || {};

The JSON.stringify code is a little more complex:


// implement JSON.stringify serialization
JSON.stringify = JSON.stringify || function (obj) {

	var t = typeof (obj);
	if (t != "object" || obj === null) {

		// simple data type
		if (t == "string") obj = '"'+obj+'"';
		return String(obj);

	}
	else {

		// recurse array or object
		var n, v, json = [], arr = (obj && obj.constructor == Array);

		for (n in obj) {
			v = obj[n]; t = typeof(v);

			if (t == "string") v = '"'+v+'"';
			else if (t == "object" && v !== null) v = JSON.stringify(v);

			json.push((arr ? "" : '"' + n + '":') + String(v));
		}

		return (arr ? "[" : "{") + String(json) + (arr ? "]" : "}");
	}
};

If JSON.stringify is not available, we define a new function that accepts a single obj parameter. The parameter can be a single value, an array, or a complex object such as obj1 above. The code examines the object type. Single values are returned immediately and only strings are modified to put quotes around the value. If an array or object is passed, the code iterates through every property:

Strings values have quotes added.
Child arrays or objects are recursively passed to the JSON.stringify function.
The resulting values are added to the end of a json[] array as a “name : value” string, or just a single value for array items.
Finally, the json array is converted to a comma-delimited list and returned within array [] or object {} brackets as necessary.

If your brain’s aching, you’ll be pleased to know that the JSON.parse code is much simpler:


// implement JSON.parse de-serialization
JSON.parse = JSON.parse || function (str) {
	if (str === "") str = '""';
	eval("var p=" + str + ";");
	return p;
};

This converts a JSON string to an object using eval(). Before you rush off to implement JSON serialization functions in all your projects, there are a few gotchas:

This code has been intentionally kept short. It will work in most situations, but there are subtle differences with the native JSON.stringify and JSON.parse methods.
Not every JavaScript object is supported. For example, a Date() will return an empty object, whereas native JSON methods will encode it to a date/time string.
The code will serialize functions, e.g. var obj1 = { myfunc: function(x) {} }; whereas native JSON methods will not.
Very large objects will throw recursion errors.
The use of eval() in JSON.parse is inherently risky. It will not be a problem if you are calling your own web services, but calls to third-party applications could accidentally or intentionally break your page and cause security issues. If necessary, a safer (but longer and slower) JavaScript parser is available from json.org.

I hope you find the code useful. Feel free to use it in your own projects. Resource files:

Frequently Asked Questions about JavaScript JSON Serialization

What is JSON serialization in JavaScript?

JSON serialization in JavaScript is the process of converting JavaScript objects into a JSON string format. This is done using the JSON.stringify() method. The resulting JSON string can be stored or sent to a server. It’s a crucial process in web development as it allows data to be easily transferred between client and server.

How do I use JSON.stringify() in JavaScript?

JSON.stringify() is a method in JavaScript that converts a JavaScript object into a JSON string. Here’s a simple example:

let obj = {name: "John", age: 30, city: "New York"};
let myJSON = JSON.stringify(obj);
console.log(myJSON);
In this example, the JavaScript object ‘obj’ is converted into a JSON string using JSON.stringify() and stored in the variable ‘myJSON’.

Can I serialize arrays in JavaScript?

Yes, you can serialize arrays in JavaScript using the JSON.stringify() method. This method works not only with simple arrays, but also with arrays of objects. Here’s an example:

let arr = [1, 2, 3, 4];
let myJSON = JSON.stringify(arr);
console.log(myJSON);
In this example, the array ‘arr’ is converted into a JSON string.

How do I deserialize a JSON string in JavaScript?

Deserialization is the process of converting a JSON string back into a JavaScript object. This is done using the JSON.parse() method. Here’s an example:

let myJSON = '{"name":"John", "age":30, "city":"New York"}';
let obj = JSON.parse(myJSON);
console.log(obj);
In this example, the JSON string ‘myJSON’ is converted back into a JavaScript object using JSON.parse().

What happens if I try to serialize a function in JavaScript?

If you try to serialize a function in JavaScript using JSON.stringify(), the function will be ignored and won’t appear in the resulting JSON string. This is because JSON is a data format and doesn’t support JavaScript’s execution abilities.

Can I customize the serialization process in JavaScript?

Yes, you can customize the serialization process in JavaScript using a replacer function or a replacer array as the second argument to JSON.stringify(). This allows you to filter-out values or modify them during the serialization process.

What is pretty-printing in JavaScript JSON serialization?

Pretty-printing is a way to format the resulting JSON string in a more readable way. This is done by providing a number as the third argument to JSON.stringify(), which represents the number of spaces to use for indentation.

Can I serialize and deserialize dates in JavaScript?

Yes, but it requires some extra steps. By default, when you serialize a Date object in JavaScript, it will be converted to a string in ISO format. When you deserialize it, it won’t be automatically converted back to a Date object. You’ll need to manually convert it back using the new Date() constructor.

What is the toJSON() method in JavaScript?

The toJSON() method in JavaScript is used to alter the behavior of JSON.stringify(). When an object has a toJSON() method, JSON.stringify() calls it and serializes the value it returns, instead of the original object.

Can I handle large numbers during JSON serialization in JavaScript?

Yes, but with some limitations. JavaScript can accurately represent numbers up to 2^53 – 1. If you need to serialize larger numbers, you might need to convert them to strings first to avoid precision loss.