Separating routes into files in Express - Step-by-Step Execution

Concept Flow - Separating routes into files

Create main app file

↓

Create route file

↓

Export router from route file

↓

Import router in main app

↓

Use router with app.use()

↓

Start server and handle requests

This flow shows how to split routes into separate files, export them, and use them in the main Express app.

Execution Sample

Express

const express = require('express');
const app = express();
const userRoutes = require('./routes/users');
app.use('/users', userRoutes);
app.listen(3000);

Main app imports user routes from a separate file and uses them under '/users' path.

Execution Table

Step	Action	File	Result
1	Create main app file with express app	app.js	Express app instance created
2	Create route file with express.Router()	routes/users.js	Router instance created with routes
3	Export router from route file	routes/users.js	Router exported
4	Import router in main app	app.js	Router imported as userRoutes
5	Use router with app.use('/users', userRoutes)	app.js	Routes under '/users' path registered
6	Start server with app.listen(3000)	app.js	Server listening on port 3000
7	Request to '/users/profile'	app.js + routes/users.js	Router handles request and sends response
8	Request to '/users/settings'	app.js + routes/users.js	Router handles request and sends response
9	Request to '/other'	app.js	No matching route, 404 or default response

💡 Server runs indefinitely until stopped; requests handled by registered routers.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
app	undefined	Express app instance	Express app instance	Express app with userRoutes registered	Running server
userRoutes	undefined	Router instance	Router instance	Router instance	Router used for '/users' routes

Key Moments - 3 Insights

Why do we use express.Router() in a separate file instead of app directly?

Using express.Router() lets us group related routes in one file and export them. This keeps code organized. See execution_table step 2 and 3 where router is created and exported.

What does app.use('/users', userRoutes) do exactly?

It tells Express to use all routes defined in userRoutes under the '/users' path prefix. So '/users/profile' calls the profile route inside userRoutes. See execution_table step 5.

What happens if a request does not match any route?

Express returns a 404 or default response because no route handled the request. See execution_table step 9 where '/other' has no matching route.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after step 3?

A Router imported in main app

B Router exported from route file

C Server started and listening

D Routes registered under '/users'

💡 Hint

Check the 'Result' column for step 3 in the execution_table.

At which step does the main app start listening for requests?

A Step 5

B Step 4

C Step 6

D Step 2

💡 Hint

Look for 'Server listening on port 3000' in the execution_table.

If we change app.use('/users', userRoutes) to app.use('/api', userRoutes), what changes in the execution?

A Routes will be under '/api' instead of '/users'

B Router will not be imported

C Server will not start

D No routes will work

💡 Hint

Refer to step 5 in execution_table where the path prefix is set.

Concept Snapshot

Separate routes into files using express.Router().
Export router from route file.
Import router in main app.
Use app.use('/path', router) to mount routes.
Keeps code organized and modular.
Server handles requests via mounted routers.

Full Transcript

This lesson shows how to organize Express routes by separating them into different files. First, you create a main app file that initializes the Express app. Then, you create a route file where you use express.Router() to define related routes. You export this router from the route file. In the main app file, you import the router and use app.use() to mount it under a specific path prefix like '/users'. This way, requests to '/users/profile' or '/users/settings' are handled by the routes defined in the separate file. The server listens on a port and handles requests accordingly. This approach keeps your code clean and easier to maintain.