Node.js has a built-in HTTP module, but writing servers with it is verbose. Express.js simplifies everything. It handles routing, request parsing, and response sending with clean, simple code.
What is Express?
Express is a lightweight web framework for Node.js. It makes building web applications easier by providing helpful features for routing, middleware, and responses.
Without Express, here's a basic Node.js server:
import http from 'http';
const server = http.createServer((req, res) => {
if (req.url === '/' && req.method === 'GET') {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Home page');
} else if (req.url === '/about' && req.method === 'GET') {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('About page');
} else {
res.statusCode = 404;
res.end('Not found');
}
});
server.listen(3000);
This gets messy quickly. With multiple routes, you'd have many if-else statements.
With Express, the same thing is much simpler:
import express from 'express';
const app = express();
app.get('/', (req, res) => {
res.send('Home page');
});
app.get('/about', (req, res) => {
res.send('About page');
});
app.listen(3000);
Much cleaner. Express handles the complexity.
Setting Up Express
First, create a project and install Express:
npm init -y
npm install express
Create a file called server.js:
import express from 'express';
const app = express();
app.listen(3000, () => {
console.log('Server running on http://localhost:3000');
});
Run it:
node server.js
You have a running server. It doesn't do anything yet, but it's listening on port 3000.
Understanding Routes
A route is a combination of:
HTTP method (GET, POST, PUT, DELETE, etc.)
URL path (/home, /users, /posts/123, etc.)
Handler function (what to do when this route is called)
The basic structure is:
app.METHOD(PATH, HANDLER);
For example:
app.get('/home', (req, res) => {
res.send('This is the home page');
});
This means: "When someone sends a GET request to /home, execute this function."
GET Requests
GET requests fetch data. They're read-only and don't change anything.
import express from 'express';
const app = express();
app.get('/', (req, res) => {
res.send('Welcome to the home page');
});
app.get('/about', (req, res) => {
res.send('This is the about page');
});
app.get('/contact', (req, res) => {
res.send('Contact us at info@example.com');
});
app.listen(3000, () => {
console.log('Server running');
});
Now visit:
http://localhost:3000/ → "Welcome to the home page"
http://localhost:3000/about → "This is the about page"
http://localhost:3000/contact → "Contact us at..."
POST Requests
POST requests send data to the server. They typically create new resources.
For this, you need to parse incoming data. Express provides middleware for this:
import express from 'express';
const app = express();
// Parse JSON data
app.use(express.json());
app.get('/', (req, res) => {
res.send('GET request received');
});
app.post('/submit', (req, res) => {
const { name, email } = req.body;
res.send(`Thank you, \({name}. We'll email \){email}`);
});
app.listen(3000, () => {
console.log('Server running');
});
When someone sends a POST request to /submit with JSON data, Express parses it and stores it in req.body.
To test this, you'd need a tool like Postman or curl:
curl -X POST http://localhost:3000/submit \
-H "Content-Type: application/json" \
-d '{"name":"John","email":"john@example.com"}'
Response: "Thank you, John. We'll email john@example.com"
URL Parameters
Routes can have dynamic parts. Parameters start with a colon:
import express from 'express';
const app = express();
app.get('/users/:id', (req, res) => {
const userId = req.params.id;
res.send(`Getting user ${userId}`);
});
app.get('/posts/:postId/comments/:commentId', (req, res) => {
const { postId, commentId } = req.params;
res.send(`Comment \({commentId} on post \){postId}`);
});
app.listen(3000);
Examples:
Query Parameters
Query parameters come after a question mark and are optional:
import express from 'express';
const app = express();
app.get('/search', (req, res) => {
const query = req.query.q;
const limit = req.query.limit;
res.send(`Searching for "\({query}", limit \){limit}`);
});
app.listen(3000);
Examples:
GET /search?q=javascript → "Searching for 'javascript', limit undefined"
GET /search?q=node&limit=10 → "Searching for 'node', limit 10"
Response Methods
Express provides several ways to send responses:
import express from 'express';
const app = express();
// Send plain text
app.get('/text', (req, res) => {
res.send('This is plain text');
});
// Send JSON
app.get('/json', (req, res) => {
res.json({ message: 'This is JSON', status: 'success' });
});
// Send HTML
app.get('/html', (req, res) => {
res.send('<h1>This is HTML</h1>');
});
// Send with status code
app.get('/error', (req, res) => {
res.status(404).send('Not found');
});
// Redirect
app.get('/old-path', (req, res) => {
res.redirect('/new-path');
});
app.listen(3000);
Handling All HTTP Methods
Express supports all standard HTTP methods:
import express from 'express';
const app = express();
app.use(express.json());
app.get('/users', (req, res) => {
res.json({ message: 'Get all users' });
});
app.post('/users', (req, res) => {
res.json({ message: 'Create new user' });
});
app.put('/users/:id', (req, res) => {
res.json({ message: `Update user ${req.params.id}` });
});
app.delete('/users/:id', (req, res) => {
res.json({ message: `Delete user ${req.params.id}` });
});
app.listen(3000);
Handling 404 Errors
When a route doesn't exist, Express returns a 404 error by default. You can customize this:
import express from 'express';
const app = express();
app.get('/', (req, res) => {
res.send('Home');
});
// Catch all unmatched routes
app.use((req, res) => {
res.status(404).send('Page not found');
});
app.listen(3000);
The order matters. This "catch-all" route must be last, otherwise it will intercept all requests.
A Complete Example
Let's build a simple blog API:
import express from 'express';
const app = express();
app.use(express.json());
// Sample data
let posts = [
{ id: 1, title: 'First Post', content: 'Hello world' },
{ id: 2, title: 'Second Post', content: 'Another post' }
];
// GET all posts
app.get('/posts', (req, res) => {
res.json(posts);
});
// GET single post
app.get('/posts/:id', (req, res) => {
const post = posts.find(p => p.id === parseInt(req.params.id));
if (!post) {
return res.status(404).send('Post not found');
}
res.json(post);
});
// CREATE new post
app.post('/posts', (req, res) => {
const newPost = {
id: posts.length + 1,
title: req.body.title,
content: req.body.content
};
posts.push(newPost);
res.status(201).json(newPost);
});
// UPDATE post
app.put('/posts/:id', (req, res) => {
const post = posts.find(p => p.id === parseInt(req.params.id));
if (!post) {
return res.status(404).send('Post not found');
}
post.title = req.body.title || post.title;
post.content = req.body.content || post.content;
res.json(post);
});
// DELETE post
app.delete('/posts/:id', (req, res) => {
const index = posts.findIndex(p => p.id === parseInt(req.params.id));
if (index === -1) {
return res.status(404).send('Post not found');
}
const deleted = posts.splice(index, 1);
res.json(deleted);
});
app.listen(3000, () => {
console.log('Blog API running on port 3000');
});
This simple API lets you create, read, update, and delete posts.
Common Mistakes
Mistake 1: Forgetting middleware
// Wrong - won't parse JSON
app.post('/data', (req, res) => {
console.log(req.body); // undefined
});
// Correct
app.use(express.json());
app.post('/data', (req, res) => {
console.log(req.body); // has data
});
Mistake 2: Forgetting to return after sending response
app.get('/users/:id', (req, res) => {
if (!id) {
res.status(400).send('Invalid ID');
// BUG: continues executing below
}
res.send('User data');
});
// Better
app.get('/users/:id', (req, res) => {
if (!id) {
return res.status(400).send('Invalid ID');
}
res.send('User data');
});
Key Takeaways
Express simplifies building web servers with Node.js
Routes combine HTTP method, path, and handler function
GET requests fetch data, POST requests send data
URL parameters (:id) capture dynamic values
Query parameters (?key=value) pass optional filters
Middleware processes requests before they reach handlers
Always return after sending a response
Use appropriate HTTP status codes
Express makes building web applications enjoyable. These fundamentals are the foundation for all Express applications.
