Skip to content
Related Articles

Related Articles

Servers, streams and sockets in Node

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 30 Apr, 2019

Node.js Server

Node.js is a javascript framework for writing Server-side applications.
A Node.js server provides the mechanisms for connecting to a service and sending/receiving data. It achieves this through TCP or UDP connections. Developers can hence create their own server and test their app deployment.
NodeJS comes with a simple HTTP server built-in. This HTTP server allows us to listen on an arbitrary port(specified by us) and receive callbacks via a callback function that will be invoked every time a request is made to the server.
The callback will receive two arguments: a Request object and a Response object. The Request object will be filled with useful properties about the request, and the Response object will be used to send a response to the client.

Once you have installed Node, let’s try building our first web server. For example, let us code a server.js file-

const http = require('http');
const hostname = '';
const port = 8081;
const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello, Welcome to GeeksforGeeks !\n');
server.listen(port, hostname, () => {
  console.log(`Your Node.js server is running at http://${hostname}:${port}/`);

Now to execute this file from terminal simply write:-

node server.js

and you’ll see:

And on navigating to the specified url a simple HTML page will open displaying :

Hence, we created a local Node.js web server listening on port 8081.

Node.js Stream

Streams are collections of data — just like arrays or strings. A stream is an abstract interface for working with streaming data in Node.js. The stream module provides a base API that makes it easy to build objects that implement the stream interface. In Node.js, there are four types of streams –

    Writable – streams to which data can be written.
    Readable – streams from which data can be read.
    Duplex – streams that are both Readable and Writable.
    Transform – Duplex streams that can modify or transform the data as it is written and read

Using Node.js streams we can modify and transform data.

Reading a file using Streams

Create a text file with any arbitrary content. For example – Node.txt with the following content-

Welcome to Nodejs streams usage. Read this file.

Create a js file ,example- read.js ,with the following content-

var fs = require("fs"); //using the Node fs module you can read a file
var data = '';
// Create a read stream with your text file name in quotes (Node.txt)
var readerStream = fs.createReadStream('Node.txt'); 
//Stream events-
//'data','end','error'----see details at
readerStream.on('data', function(chunk) {
   data += chunk;
readerStream.on('end',function() {
readerStream.on('error', function(err) {
console.log("Reading complete");

Now run the above read.js file to see the output-

Writing a file using streams

Create a js file ,example- write.js ,with the following content-

var fs = require("fs");
//data variable containing the data to be written to the file
var data = 'Hello welcome to Node.js tutorials on GeeksforGeeks'
// Create a writable stream with the output file name in quotes (Node1.txt)
var writerStream = fs.createWriteStream('Node1.txt');
// utf8 encoding
//end of file
// Handle stream events --> finish, and error
writerStream.on('finish', function() {
   console.log("Write completed.");
writerStream.on('error', function(err) {
console.log("You've successfully created Node1.txt");

Execute the above file-

And the text file has been created. To check-

Node.js Sockets

Here we are talking in reference to “net” module of Node.js and not referring Socket.IO -a library that enables real-time, bidirectional and event-based communication between the browser and the server.

The net module provides an asynchronous network API for creating stream-based TCP or IPC servers (net.createServer()) and clients (net.createConnection()).

“net.Socket” is a class that is an abstraction of a TCP socket or a streaming IPC endpoint, and is also a duplex stream so it can be used for both reading and writing data.

A net.Socket can be created by the user and used directly to interact with a server. For example, it is returned by net.createConnection(), so the user can use it to talk to the server.

It can also be created by Node.js and passed to the user when a connection is received. For example, it is passed to the listeners of a ‘connection’ event emitted on a net.Server, so the user can use it to interact with the client.

For example to create a test socket in Node.js create a file ,example- test.js, with the following content-

// server
require('net').createServer(function (socket) {
    socket.on('data', function (data) {
// client
var s = require('net').Socket();

Running the above file creates a client-server model and returns-

net.Socket comes with many functions and events like-

Event: ‘close’-
Added in: v0.1.90
hadError true if the socket had a transmission error.
Emitted once the socket is fully closed. The argument hadError is a boolean which says if the socket was closed due to a transmission error.

Event: ‘connect’-
Added in: v0.1.90
Emitted when a socket connection is successfully established. See net.createConnection().

Added in: v0.1.90
Returns the bound address, the address family name and port of the socket as reported by the operating system: { port: 12346, family: ‘IPv4’, address: ‘’ }

Added in: v0.5.3
The amount of received bytes.

Added in: v0.5.3
The number of bytes sent.

Further can be explored at the official documentation of Node.js mentioned in the references.



My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!