We'll need to create two new files called profiles.js and json_and_back.js.

Let's create the object that we'll later be converting to JSON.

module.exports = {
  ryan : {
           name: "Ryan Dahl",
           irc:'ryah',
           twitter:'ryah',
           github:'ry',
           location:'San Francisco, USA',
           description: "Creator of node.js"
          },
  isaac : {
            name: "Isaac Schlueter",
            irc:'isaacs',
            twitter:'izs',
            github:'isaacs',
            location:'San Francisco, USA',
            description: "Author of npm, core contributor"
           },
  bert : {
           name: "Bert Belder",
           irc:'piscisaureus',
           twitter:'piscisaureus',
           github:'piscisaureus',
           location:'Netherlands',
           description: "Windows support, overall contributor"
          },
  tj : {
          name: "TJ Holowaychuk",
          irc:'tjholowaychuk',
          twitter:'tjholowaychuk',
          github:'visionmedia',
          location:'Victoria, BC, Canada',
          description: "Author of express, jade and other popular modules"
          },
  felix : {
          name: "Felix Geisendorfer",
          irc:'felixge',
          twitter:'felixge',
          github:'felixge',
          location:'Berlin, Germany',
          description: "Author of formidable, active core developer"
          }
};

This object contains profile information on some of the leading members of the Node Community (though it's entirely non-exhaustive and doesn't even contain all of the core development team). One thing to note here is the use of module.exports. We'll be seeing more of this In Chapter 9, Writing Your Own Module. We're using module.exports to modularize our profiles object here in a bid to keep our code uncluttered. We can load any expression into module.exports, save it as a separate file (which in our case, we'll call profiles.js), and use require in our main file to dynamically load it at initialization.

var profiles = require('./profiles'), // note the .js suffix is optional

Nice and tidy. To convert our profiles object into a JSON representation, we use JSON.stringify, which will return a string composed of JSON data. We're going to fundamentally alter our object (which is now a string) using replace.

profiles = JSON.stringify(profiles).replace(/name/g, 'fullname'),

Here we have called replace, using a regular expression with the global g option to change every occurrence of name in our JSON string to fullname.

But wait! There appears to be some kind of mistake. Felix's last name is missing an umlaut! Let's correct it by converting our JSON data back into an object, and correct his name by altering the value of the re-designated fullname property:

profiles = JSON.parse(profiles);
profiles.felix.fullname = "Felix Geisendörfer";
console.log(profiles.felix);

When we run our application, console.log will output the following:

{ fullname: 'Felix Geisendörfer',
  irc: 'felixge',
  twitter: 'felixge',
  github: 'felixge',
  location: 'Berlin, Germany',
  description: 'Author of formidable, active core developer' }

The first key is now fullname, and Geisendörfer is spelled correctly.

First, we have an everyday JavaScript object, which we serialize into a JSON representation. We also call the String.replace method on our JSON string, changing every occurrence of name into fullname.

Using replace in this way and context isn't an advisable practice since any occurrences of name are replaced. There could very easily have been other places in the string where name may have existed, which would be replaced unintentionally. We used replace here to affirm that profiles have become a JSON string, as we couldn't use replace on an object.

Then we convert our modified JSON string back into an object, using JSON.parse. To test that our keys were indeed transformed from name to fullname, and to affirm that we are again working with an object, we correct the felix profile via profiles.felix.fullname, and then log profiles.felix to the console.

JSON is a highly versatile and flexible tool for cross-platform communication. Let's look at a more advanced application of the standard.

<html>
<head>
<script>
  var who = 'ryan';
  function cb(o) {
    alert(o.name + ' : ' + o.description);
  }
  var s = document.createElement('script'),
  s.src = 'http://localhost:8080/?callback=cb&who=' + who;
  document.getElementsByTagName("head")[0].appendChild(s);
</script>
</head>
</html>

var http = require('http'),
var url = require('url'),
var profiles = require('./profiles'),

http.createServer(function (request, response) {
  var urlObj = url.parse(request.url, true), 
    cb = urlObj.query.callback, who = urlObj.query.who,
    profile;

  if (cb && who) {
    profile = cb + "(" + JSON.stringify(profiles[who]) + ")";
    response.end(profile);
  }

}).listen(8080);