ws library for WebSocket server in Node.js - Mini Project: Build & Apply

Basic WebSocket Server with ws Library

📖 Scenario: You want to create a simple WebSocket server that can accept connections from clients and send messages back and forth.This is useful for real-time chat apps, live notifications, or games.

🎯 Goal: Build a WebSocket server using the ws library in Node.js that listens on port 8080, accepts client connections, and sends a welcome message.

📋 What You'll Learn

Create a WebSocket server using the ws library

Listen on port 8080

Send a welcome message to each client when they connect

Log connection and message events to the console

💡 Why This Matters

🌍 Real World

WebSocket servers enable real-time communication for chat apps, live updates, multiplayer games, and collaborative tools.

💼 Career

Understanding how to build WebSocket servers is valuable for backend developers working on interactive web applications and real-time data streaming.

1

Install and import the ws library

Create a constant called WebSocketServer by requiring the ws library.

Node.js

# Your code here

Hint

Use require('ws').Server to get the WebSocketServer class.

2

Create the WebSocket server on port 8080

Create a constant called wss and assign it a new WebSocketServer instance that listens on port 8080.

Node.js

const WebSocketServer = require('ws').Server;
# Your code here

Hint

Use new WebSocketServer({ port: 8080 }) to create the server.

3

Add connection event listener

Use wss.on('connection', (ws) => { ... }) to listen for new client connections. Inside the callback, send the message 'Welcome to the server!' to the connected client using ws.send().

Node.js

const WebSocketServer = require('ws').Server;
const wss = new WebSocketServer({ port: 8080 });
# Your code here

Hint

Use wss.on('connection', (ws) => { ws.send('Welcome to the server!'); }).

4

Log connection and message events

Inside the connection event callback, add a console.log to print 'Client connected'. Also, add a listener on ws for the 'message' event that logs Received: plus the message content.

Node.js

const WebSocketServer = require('ws').Server;
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (ws) => {
    ws.send('Welcome to the server!');
    # Your code here
});

Hint

Use console.log('Client connected') and ws.on('message', (message) => { console.log('Received: ' + message); }).

Practice

1. What is the main purpose of the ws library in Node.js?

easy

A. To connect to SQL databases

B. To create WebSocket servers and clients for real-time communication

C. To handle HTTP requests and routing

D. To manage file uploads in Node.js applications

Solution

1. Step 1: Understand the role of ws

   The ws library is designed specifically for WebSocket communication, enabling real-time data exchange between server and client.

2. Step 2: Compare with other options

   Options A, B, and C relate to other Node.js tasks like file uploads, HTTP routing, and database connections, which are not the focus of ws.

3. Final Answer:

   To create WebSocket servers and clients for real-time communication -> Option B

4. Quick Check:

   WebSocket library = real-time communication [OK]

Hint: Remember: ws = WebSocket server/client library [OK]

Common Mistakes:

• Confusing ws with HTTP or database libraries
• Thinking ws handles file uploads
• Assuming ws manages REST API routing

2. Which of the following is the correct way to create a WebSocket server using the ws library?

easy

A. const server = new WebSocketServer({ port: 8080 });

B. const server = new WebSocket({ port: 8080 });

C. const server = new WebSocketServer.listen(8080);

D. const server = ws.createServer(8080);

Solution

1. Step 1: Recall the correct constructor usage

   The ws library uses WebSocketServer constructor with an options object, including the port number.

2. Step 2: Check each option's syntax

   const server = new WebSocketServer({ port: 8080 }); correctly uses new WebSocketServer({ port: 8080 }). Options B, C, and D use incorrect constructors or methods not defined in ws.

3. Final Answer:

   const server = new WebSocketServer({ port: 8080 }); -> Option A

4. Quick Check:

   Correct constructor syntax = const server = new WebSocketServer({ port: 8080 }); [OK]

Hint: Use new WebSocketServer({ port }) to create server [OK]

Common Mistakes:

• Using WebSocket instead of WebSocketServer for server creation
• Calling listen() method which does not exist
• Using non-existent ws.createServer() method

3. What will the following code output when a client sends the message 'Hello' to the server?

const { WebSocketServer } = require('ws');
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', ws => {
  ws.on('message', message => {
    console.log(`Received: ${message}`);
    ws.send('Hi client');
  });
});

medium

A. Nothing happens because no connection event is handled

B. Server logs 'Hi client' and sends 'Received: Hello' back

C. Server throws an error because message event is invalid

D. Server logs 'Received: Hello' and sends 'Hi client' back

Solution

1. Step 1: Understand event handling

   The server listens for 'connection' events, then listens for 'message' events on each connection. When a message arrives, it logs the message and sends a reply.

2. Step 2: Trace the message flow

   When client sends 'Hello', server logs 'Received: Hello' and sends 'Hi client' back to client.

3. Final Answer:

   Server logs 'Received: Hello' and sends 'Hi client' back -> Option D

4. Quick Check:

   Message event logs input and replies = Server logs 'Received: Hello' and sends 'Hi client' back [OK]

Hint: Message event logs input, ws.send replies [OK]

Common Mistakes:

• Confusing message event with connection event
• Thinking server sends back the received message
• Assuming message event is invalid

4. Identify the error in this WebSocket server code snippet:

const { WebSocketServer } = require('ws');
const wss = new WebSocketServer({ port: 3000 });
wss.on('connection', function(ws) {
  ws.on('message', function(msg) {
    ws.send(msg.toUpperCase);
  });
});

medium

A. WebSocketServer should be imported from 'websocket' package

B. The 'connection' event should be 'connect'

C. Using msg.toUpperCase without parentheses causes a runtime error

D. ws.send cannot send strings, only buffers

Solution

1. Step 1: Check method usage on message

   The code uses msg.toUpperCase without parentheses, so it passes the function itself instead of calling it.

2. Step 2: Understand the impact

   This causes a runtime error because ws.send expects a string or buffer, not a function reference.

3. Final Answer:

   Using msg.toUpperCase without parentheses causes a runtime error -> Option C

4. Quick Check:

   Method call missing () causes error = Using msg.toUpperCase without parentheses causes a runtime error [OK]

Hint: Always call string methods with () to avoid errors [OK]

Common Mistakes:

• Confusing event names 'connection' vs 'connect'
• Importing WebSocketServer from wrong package
• Thinking ws.send cannot send strings

5. You want to broadcast a message to all connected clients using the ws library. Which code snippet correctly sends 'Hello all!' to every client connected to the server?

const { WebSocketServer } = require('ws');
const wss = new WebSocketServer({ port: 8080 });

// Broadcast function here
function broadcast(message) {
  // ???
}

hard

A. wss.clients.forEach(client => { if (client.readyState === WebSocket.OPEN) client.send(message); });

B. wss.clients.map(client => client.send(message));

C. wss.broadcast(message);

D. wss.send(message);

Solution

1. Step 1: Understand how to access clients

   The wss.clients set contains all connected clients. We must iterate over it to send messages.

2. Step 2: Check client connection state before sending

   Only clients with readyState === WebSocket.OPEN can receive messages safely.

3. Step 3: Verify each option

   wss.clients.forEach(client => { if (client.readyState === WebSocket.OPEN) client.send(message); }); correctly uses forEach and checks readyState. wss.clients.map(client => client.send(message)); uses map which is not appropriate here. Options A and D use non-existent methods.

4. Final Answer:

   wss.clients.forEach(client => { if (client.readyState === WebSocket.OPEN) client.send(message); }); -> Option A

5. Quick Check:

   Broadcast = forEach + readyState check [OK]

Hint: Use forEach and check readyState before sending [OK]

Common Mistakes:

• Using map instead of forEach for side effects
• Calling non-existent broadcast or send on server
• Not checking client readyState before sending