Why Node.js for server-side JavaScript in Node.js - See It in Action

Why Node.js for server-side JavaScript

📖 Scenario: You are building a simple server that responds to web requests. You want to understand why Node.js is a good choice for running JavaScript on the server.

🎯 Goal: Create a basic Node.js server script step-by-step to see how Node.js handles server-side JavaScript efficiently.

📋 What You'll Learn

Create a simple HTTP server using Node.js built-in modules

Set a port number for the server to listen on

Write the core logic to respond with a friendly message

Complete the server setup to start listening on the port

💡 Why This Matters

🌍 Real World

Node.js is widely used to build fast and scalable web servers that handle many users at once without slowing down.

💼 Career

Understanding how to create a basic Node.js server is a key skill for backend developers working with JavaScript.

1

DATA SETUP: Import the HTTP module

Write a line to import the built-in Node.js http module using import syntax.

Node.js

// Import the http module
// Your code here

Hint

Use import http from 'http'; to bring in the HTTP module.

2

CONFIGURATION: Set the server port

Create a constant called port and set it to 3000.

Node.js

import http from 'http';

// Set the port number
// Your code here

Hint

Use const port = 3000; to define the port.

3

CORE LOGIC: Create the server with a response

Use http.createServer with a function that takes req and res. Inside, write headers with res.writeHead(200, {'Content-Type': 'text/plain'}) and send the text 'Hello from Node.js!' with res.end(). Assign this server to a constant called server.

Node.js

import http from 'http';

const port = 3000;

// Create the server and respond with a message
// Your code here

Hint

Use http.createServer and respond with a plain text message.

4

COMPLETION: Start the server listening on the port

Call server.listen with the port constant and add a callback function that logs 'Server running on port 3000'.

Node.js

import http from 'http';

const port = 3000;

const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello from Node.js!');
});

// Start the server listening
// Your code here

Hint

Use server.listen(port, () => { console.log(...) }) to start the server.

Practice

1. Why is Node.js popular for server-side JavaScript development?

easy

A. It allows using JavaScript on the server for fast and scalable apps

B. It only works with frontend JavaScript

C. It requires a different language for backend

D. It is slower than traditional servers

Solution

1. Step 1: Understand Node.js purpose

   Node.js lets developers use JavaScript on the server side, unlike traditional setups that use other languages.

2. Step 2: Recognize benefits

   This allows building fast and scalable applications using one language for both frontend and backend.

3. Final Answer:

   It allows using JavaScript on the server for fast and scalable apps -> Option A

4. Quick Check:

   Node.js = server-side JavaScript for speed and scale [OK]

Hint: Node.js runs JavaScript on servers for fast apps [OK]

Common Mistakes:

• Thinking Node.js is only for frontend
• Believing Node.js requires multiple languages
• Assuming Node.js is slower than other servers

2. Which of the following is the correct way to import a module in Node.js?

easy

A. import fs from 'fs';

B. using fs;

C. require('fs');

D. include 'fs';

Solution

1. Step 1: Recall Node.js module syntax

   Node.js traditionally uses CommonJS syntax with require() to import modules.

2. Step 2: Identify correct syntax

   The correct way is to call require('fs') to load the file system module.

3. Final Answer:

   require('fs'); -> Option C

4. Quick Check:

   Node.js modules use require() [OK]

Hint: Use require() to import modules in Node.js [OK]

Common Mistakes:

• Using import without enabling ES modules
• Writing include or using which are not valid
• Confusing frontend import syntax with Node.js

3. What will the following Node.js code output?

const http = require('http');
const server = http.createServer((req, res) => {
  res.end('Hello World');
});
server.listen(3000, () => console.log('Server running'));

medium

A. Hello World

B. Server running

C. Error: createServer is not a function

D. Nothing happens

Solution

1. Step 1: Analyze server.listen callback

   The callback passed to server.listen runs when the server starts listening, logging 'Server running'.

2. Step 2: Understand output context

   The console.log prints 'Server running' to the terminal, not the HTTP response.

3. Final Answer:

   Server running -> Option B

4. Quick Check:

   Server start logs 'Server running' [OK]

Hint: Look for console.log inside listen callback for output [OK]

Common Mistakes:

• Confusing console output with HTTP response
• Expecting 'Hello World' in console
• Thinking createServer is undefined

4. Identify the error in this Node.js code snippet:

const http = require('http');
const server = http.createServer((req, res) => {
  res.write('Hello');
  res.end();
});
server.listen(3000);
console.log('Server running on port 3000');

medium

A. No error, code works correctly

B. res.write should be res.send

C. Missing callback in server.listen

D. res.end() must have a string argument

Solution

1. Step 1: Check server.listen usage

   server.listen can be called without a callback; it still starts the server.

2. Step 2: Verify response methods

   res.write followed by res.end() is valid to send response data in Node.js.

3. Final Answer:

   No error, code works correctly -> Option A

4. Quick Check:

   res.write + res.end() is valid response [OK]

Hint: res.write + res.end() is valid; listen callback optional [OK]

Common Mistakes:

• Thinking res.send exists in Node.js core
• Expecting listen must have callback
• Believing res.end requires argument

5. You want to build a chat app that updates messages instantly for many users. Why is Node.js a good choice for this server-side task?

hard

A. Node.js requires multiple threads for each user connection

B. Node.js cannot handle many simultaneous users

C. Node.js is slower than traditional servers for real-time apps

D. Node.js uses an event-driven model that handles many connections efficiently

Solution

1. Step 1: Understand event-driven model

   Node.js uses an event-driven, non-blocking model that efficiently manages many connections without creating new threads for each.

2. Step 2: Apply to real-time chat app

   This makes Node.js ideal for apps needing instant updates and many simultaneous users, like chat apps.

3. Final Answer:

   Node.js uses an event-driven model that handles many connections efficiently -> Option D

4. Quick Check:

   Event-driven = efficient many users [OK]

Hint: Event-driven model handles many users well [OK]

Common Mistakes:

• Thinking Node.js uses many threads per user
• Assuming Node.js is slow for real-time
• Believing Node.js can't scale for many users