Node.js is a platform for building scalable network applications. In a few lines of code, you can create a fully functional server in node. Node uses an event based, non-blocking model. This enables the ability to write servers that serve multiple requests without having to wait for any single request. Before, I get into the actual topic of this post, let me introduce you to a very simple server written in node.js.

var http = require('http');
var url = require('url');

http.createServer(function(request, response){
	var path = url.parse(request.url).pathname;
	console.log('a request was received for: ' + path);
	response.writeHead(200, {'Content-Type': 'text/plain' });
	response.end('Hello, World!');
}).listen(8888);

console.log('Server listening at 8888...\n');

That’s all the code you need for creating a server! An explanation is in order now, before I get in to the core of this post. Lines 1 and 2 attempts to load two “modules” – http and url, which are provided by node.js itself. As the name implies, the http module creates an instance of the http module that could be used to create a http server, using the createServer method. The best thing about javascript is that you can pass around a function just like you could pass a variable. A callback is passed to this method which has to be executed when a request is received.

You can imagine it this way. When a request arrives to your server, your application starts handling them. If there is a callback encountered while preparing the response, the app calls the function, “remembers” that a callback is pending, and goes back to the event loop, waiting for other requests. Once the long running operation is complete, it “informs” your app, during which it takes the data reutrned by the method call and finishes processing the request. Remember, any method call or any activity within this callback method should also use the principle of callbacks, so that the server is not hung processing a synchronous activity.

Let me quickly add a few more words about the lines within the callback. Line 5 uses the “url” module imported to find out the path for which a request was issues. Line 6 just logs a message informing the path for which a request was received. Line 7 calls the writeHead method of the response object to set a status code for the request. In this case, we send a status code of 200, implying that the request was valid and an equally valid response follows. The second parameters is a key-value pair that indicates the content type of the response, in this case as we are just returning a hard-coded message, its “text/plain”. Line 8, ends the response by writing a message. You can also use the write method of response to write more data before calling end. Then, listen method of the server object (returned by createServer) is called by passing in the port number.

Let’s run this code to initialize the server. The last line in the snippet above prints a message saying that the server is listening in 8888 and then waits for the requests.

You can run this code by going in to the folder containing the node.js executable as shown below:

When you enter the address http://127.0.0.1:8888 in the address bar of a browser, it just displays the message “Hello, World!”. Now go back to the console, you will notice the messages logged to the console by the console.log method call. The first line will be an informational message saying that the server is listening. Then you will notice 2 entries that also specifies the path. The first time a request is received, the browser also requests for a favicon.ico that it uses to display in the browser’s title bar or the tab. In case you want to go through a comprehensive article that introduces node.js go to this link. If not, proceed further!

The main intention of this article ( at last ) is to introduce a way by which you could process the values posted from a form. I decided to write this article because I had to refer to a number of articles to get a clear picture as to how to do this, when I was getting started with node.js.

To begin with, let me briefly discuss the requirement: The user is presented with a form that asks for the users’ first name and last name. Once the user enters the information and clicks the “Go” button, the next page displays a hello message to the user with the name entered. Let us get started with it!

By default node does not have a module that would help us with inspecting the POSTed form values (afaik). It just provides events using which we can “collect” form data. Once all the form data is received, we can work on that. I will get to that part in jus a bit. Let me introduce you to the script that satisfies our requirement.

var http = require('http');

var postHTML =
  '<html><head><title>Post Example</title></head>' +
  '<body>' +
  '<form method="post">' +
  'Your Fist Name: <input name="first_name"><br>' +
  'Your Last Name: <input name="last_name"><br>' +
  '<input type="submit">' +
  '</form>' +

  '</body></html>';

http.createServer(function (req, res) {
  req.on('end', function () {
    res.writeHead(200);
    res.end(postHTML);
  });
}).listen(8080);

Code snippet above does a part of the task. When you run this file using node and browse to http://127.0.0.1:8080, you see a form with 2 text boxes – one for first name and one for last name. Clicking on the submit button does not do anything at this point. Let us add the ability to parse the posted data and print it to the user. The modification to the above snippet also introduces you to the concept of “modules” in node. You will understand more as I introduce the code.

var http = require('http');
var splitter = require('./splitter.js');

var postHTML =
  '<html><head><title>Post Example</title></head>' +
  '<body>' +
  '<form method="post">' +
  'Your Fist Name: <input name="first_name"><br>' +
  'Your Last Name: <input name="last_name"><br>' +
  '<input type="submit">' +
  '</form>' +
  '</body></html>';

http.createServer(function (req, res) {
  var body = "";
  req.on('data', function (chunk) {
    body += chunk;
  });
  req.on('end', function () {
    console.log('POSTed: ' + body);

	if (body != '')
	{
	    var hash = splitter.formValues(body);

	     console.log("input1 = " + hash["first_name"]);
	     console.log("input2 = " + hash["last_name"]);

	     res.writeHead(200);
	     res.write('Hello ' + hash["first_name"] + ', ' + hash["last_name"] + '!');
	     res.end();
	     return;
	}

    res.writeHead(200);
    res.end(postHTML);
  });
}).listen(8080);

Code snippet above is the updated code where I have added the ability to deal with posted form values. Line 2 includes a “custom” module, that would help us with parsing the posted form data. I will get to that part in the subsequent section. But, just like the http variable, this can be used to call a function that can be used to parse posted form values. Before that, let me discuss about the additions to the code. Lines 16-18 is used to “collect” the posted data. The on method is used to bind to a certain event. In this case, I am binding to the “data” event. A “data” event is raised when some data was posted by a form. Notice line 17, where the data handed to the callback is appended to the variable body. This is because, for a form that posts huge amount of data, this event will be raised number of times. Eventually when all the data is completely transferred, the end event is raised. At this point, the variable body contains the complete data posted. Now using the formValues method provided by the splitter module, I get a hash object that contains the values posted. For example hash["first_name"] gets the first name posted when the form was submitted.

Now, let me discuss a bit about the splitter module. Given below is line 2:

var splitter = require('./splitter.js');

http is a module provided by node. Whereas, splitter is a custom module I added. Thats why we also have to include the path where the module is present relative to the current execution directory. ./ refers to the current directory. Thus, both the application and the module exist in the same directory. Note that the addition of the extension (.js) is optional. Given below is the code for the splitter. Its pretty simple.

exports.formValues = function(data){
	var splits = data.split('&');
	var hash = [];
	console.log(splits.length);
	for (i = 0; i < splits.length; i++)
	{
		var iSplit = splits[i].split('=');
		hash[iSplit[0]] = iSplit[1];
	}
	return hash;
}

Notice the first line, the method formValues is prefixed with the exports keyword. This indicates that this method is a public (exported) method that other modules could use. Without the exports keyword, this method will be local (private) to this module. The method in itself, does not do anything great. It gets the form data passed and splits it by '&'. Then for each of the items, in the format key=value, the item is again split by '=' and then added to a javascript property and then returned to the caller. Now the properties could be accessed by the caller using the key name (e.g. first_name, last_name] - lines 24 to 27.

Now some screen shots for a clearer understanding. The first screen shot just displays the form:

User enters the first and last names, clicks on the submit button. Lines 28 - 31 takes care of this. The splitter module is used to get the form values, then the text is built displaying a message and written to the response after which the response is ended. User is now presented a welcome message as shown below:

For the sake of completeness, here are the messages in the console:

Hope you liked this blog post, which served 2 purposes, a very quick introduction to node and then a method to deal with posted form data! Have fun and do post your questions & comments!