Although this function has three different ways to execute, you will most likely only use the network listener. In fact, the other two listeners are difficult, if not impossible, to even execute on Windows. Let's cover the last two quickly.

The path listener will use a local socket server, and the file descriptor will need a handle. If this sounds foreign, it means you will use the other method.

The network listener requires that the port be used. The host will default to localhost if nothing is passed in. In all the functions, a callback will be attached to the listening event.

Here is an example of listening on a network port with all the parameters defined:

var server = http.createServer();
server.listen(8080, 'localhost', function(){
    console.log('The server is listening');
});

This will stop the server from listening. The callback will be attached to the close event.

Here is a simple example:

var server = http.createServer();
server.listen(8080, 'localhost', function () {
    server.close(function () {
        console.log('Server has closed');
    });
});

This event fires when a request comes in:

server.on('request', function (req, res) { });

server.on('request', function (req, res) {
    res.end();
    console.log('A request was received');
});

This event fires when the server closes:

server.on('close', function () { });

This event fires when the client sends an HTTP upgrade:

server.on('upgrade', function (req, socket, buffer) { });

Sometimes, you will want to make decisions based on the information in the headers. Here is an example using headers to check for basic authentication:

server.on('request', function (req, res) {
    if (req.headers.authorization !== undefined)
        //do a check here
    res.end();
});

This returns the method as a string in uppercase. Here is an example for GET:

server.on('request', function (req, res) {
    if (req.method === 'GET')
        res.write(req.method);
    res.end();
});

This will be a string of the URL, including any query parameters. You can parse the string yourself or use Node's query string module and use the parse function.

Here is a simple example that will serve any files in the current directory. Remember that this is only an example and does no error checking:

server.on('request', function (req, res) {
        var file = fs.createReadStream('.' + req.url);
        file.pipe(res);
});

If you have an incoming message, most likely, you would want to know what is in the message. As it is a readable stream, we will need to listen for the data event to get all the data out. When the data is exhausted, the end event will fire.

Here is an example that creates listeners for the data and end event:

var data = '';
response.on('data', function (chunk) {
    console.log(chunk);
    data += chunk;
});

response.on('end', function () {
    console.log(data);
});

This writes the header for the response. This needs to be called before response.write. If it is not, then the server will send it for you with the headers you have set.

statusCode is the HTTP status code of the response. A header is an object with the name of the header as a property and the value as the value.

Here is an example that writes the header:

server.on('request', function (req, res) {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end();
});

This is used instead of response.writeHead. If this is called after writeHead has been executed, then it will not change the response header. It must be called instead of it.

Here is an example that uses statusCode:

server.on('request', function (req, res) {
    res.statusCode = 404;
    res.end();
});

In the same way that statusCode must be called instead of writeHead, setHeader must be called instead of writeHead. This can be called multiple times to set multiple headers.

Here is an example of using statusCode and setHeader together:

server.on('request', function (req, res) {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/html');
    res.setHeader('Custom-Header', 'Custom-Value');
    res.end();
});

The response.write parameter is a writable stream, so this interface can be used. A chunk can be a buffer or string. The encoding is optional as it will default to UTF8. Here is an example that writes a simple HTML page as the response:

server.on('request', function (req, res) {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/html');
    res.write('<html><body><h1>Hello!</h1></body></html>');
    res.end();
});

The response parameter is a writable stream, so we must end the stream when we are done writing. Data is any optional data that needs to be written, and encoding will default to UTF8. All of the examples for response have used res.end. If you do not end the response, the browser will wait for a response from the server.

The http.clientRequest attribute is a writable stream. It is writable as you may need to send data to the remote server, for example, when making a POST request.

This works like all the other writable streams, so data can be a buffer or string, and encoding will default to UTF8.

When you are writing to a stream, you must end the stream with this function. Without doing this, the connection will stay and/or timeout. Data is optional and can be a buffer or string, while encoding will default to UTF8.

This event fires when the remote server responds. The response object in the callback will be http.incomingMessage.

If no response handler is added, the server response will be discarded. If there is a response handler, then Node.js will start to buffer the response to memory. If you do not read it back out, you can cause the server to crash.

Here is an example listener that reads the data from the response:

var request = http.request({host: 'www.google.com', path: '/', port: 80, method: 'GET'});

request.on('response', function (response) {
    var data = '';
    response.on('data', function (chunk) {
        console.log(chunk);
        data += chunk;
    });

    response.on('end', function () {
        console.log(data);
    });
});