Why Node.js for server-side JavaScript in Node.js

Introduction

Node.js lets you run JavaScript outside the browser, so you can build fast and scalable servers using one language.

You want to build a web server that handles many users at the same time.

You want to use JavaScript for both frontend and backend to keep things simple.

You need a fast way to handle real-time data like chat or live updates.

You want to build APIs that connect your app to databases or other services.

You want to create tools or scripts that run on your computer using JavaScript.

Syntax

Node.js

import http from 'node:http';

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

server.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Node.js uses modules to organize code, like 'http' for creating servers.

You write JavaScript code that runs on your computer, not in a browser.

Examples

Reading a file asynchronously using Node.js built-in 'fs' module.

Node.js

import fs from 'node:fs';

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

Reading a file synchronously, blocking code until done.

Node.js

import { readFileSync } from 'node:fs';

const data = readFileSync('file.txt', 'utf8');
console.log(data);

Using Express framework on Node.js to create a simple web server.

Node.js

import express from 'express';

const app = express();

app.get('/', (req, res) => {
  res.send('Hello from Express on Node.js!');
});

app.listen(3000);

Sample Program

This program creates a simple web server using Node.js. When you visit the homepage, it shows a welcome message. For other pages, it shows a 404 message.

Node.js

import http from 'node:http';

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Welcome to Node.js server!');
  } else {
    res.writeHead(404, {'Content-Type': 'text/plain'});
    res.end('Page not found');
  }
});

server.listen(3000, () => {
  console.log('Server running at http://localhost:3000');
});

Important Notes

Node.js uses an event-driven, non-blocking model to handle many tasks at once efficiently.

It is great for apps that need to handle many connections without slowing down.

Node.js has a large community and many ready-to-use packages to speed up development.

Summary

Node.js lets you use JavaScript on the server to build fast and scalable apps.

It works well for real-time apps and when you want one language for frontend and backend.

Node.js uses modules and an event-driven model to handle many tasks efficiently.

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