ACTIONSCRIPT 3 Developer’s Guide en

ACTIONSCRIPT 3.0 DEVELOPER’S GUIDE
Using native JSON functionality
You can override, define, or redefine toJSON() on any ActionScript class. However, most built-in ActionScript classes
don't define toJSON(). The Object class does not define toJSON in its default prototype or declare it as a class member.
Only a handful of native classes define the method as a prototype function. Thus, in most classes you can’t override
toJSON() in the traditional sense.
Native classes that don’t define toJSON() are serialized to JSON by the internal JSON implementation. Avoid
replacing this built-in functionality if possible. If you define a toJSON() member, the JSON class uses your logic
instead of its own functionality.
Using the JSON.stringify() replacer parameter
Overriding toJSON() on the prototype is useful for changing a class’s JSON export behavior throughout an
application. In some cases, though, your export logic might apply only to special cases under transient conditions. To
accommodate such small-scope changes, you can use the replacer parameter of the JSON.stringify() method.
The stringify() method applies the function passed through the replacer parameter to the object being encoded.
The signature for this function is similar to that of toJSON():
function (k,v):*
Unlike toJSON(), the replacer function requires the value, v, as well as the key, k. This difference is necessary
because stringify() is defined on the static JSON object instead of the object being encoded. When
JSON.stringify() calls replacer(k,v), it is traversing the original input object. The implicit this parameter
passed to the replacer function refers to the object that holds the key and value. Because JSON.stringify() does
not modify the original input object, that object remains unchanged in the container being traversed. Thus, you can
use the code this[k]to query the key on the original object. The v parameter holds the value that toJSON() converts.
Like toJSON(), the replacer function can return any type of value. If replacer returns a string, the JSON engine
escapes the contents in quotes and then wraps those escaped contents in quotes as well. This wrapping guarantees that
stringify() receives a valid JSON string object that remains a string in a subsequent call to JSON.parse().
The following code uses the replacer parameter and the implicit this parameter to return the time and hours values
of a Date object:
JSON.stringify(d, function (k,v):* {
return "any date format you like via replacer: "+
"holder[k].time:"+this[k].time + " holder[k].hours:"+this[k].hours;
});
Using the JSON.parse() reviver parameter
The reviver parameter of the JSON.parse() method does the opposite of the replacer function: It converts a JSON
string into a usable ActionScript object. The reviver argument is a function that takes two parameters and returns
any type:
function (k,v):*
In this function, k is a key, and v is the value of k. Like stringify(), parse() traverses the JSON key-value pairs and
applies the reviver function—if one exists—to each pair. A potential problem is the fact that the JSON class does not
output an object’s ActionScript class name. Thus, it can be challenging to know which type of object to revive. This
problem can be especially troublesome when objects are nested. In designing toJSON(), replacer, and reviver
functions, you can devise ways to identify the ActionScript objects that are exported while keeping the original objects
intact.
Last updated 6/6/2012
120