Routing patterns in Deno - Performance & Optimization

Performance: Routing patterns

MEDIUM IMPACT

Routing patterns affect how quickly a web app can respond to URL changes and serve the right content, impacting page load and interaction speed.

Handling URL requests to serve pages or data

Deno

import { serve } from "https://deno.land/std/http/server.ts";

const routes = new Map([
  ["/home", () => new Response("Home Page")],
  ["/about", () => new Response("About Page")],
  ["/contact", () => new Response("Contact Page")],
]);

serve((req) => {
  const url = new URL(req.url);
  const handler = routes.get(url.pathname);
  return handler ? handler() : new Response("Not Found", { status: 404 });
});

Using a Map for direct route lookup avoids multiple checks, speeding up route matching.

📈 Performance GainSingle hash lookup per request reduces CPU time and improves response speed.

Handling URL requests to serve pages or data

Deno

import { serve } from "https://deno.land/std/http/server.ts";

serve(async (req) => {
  const url = new URL(req.url);
  if (url.pathname === "/home") {
    return new Response("Home Page");
  } else if (url.pathname === "/about") {
    return new Response("About Page");
  } else if (url.pathname === "/contact") {
    return new Response("Contact Page");
  } else {
    return new Response("Not Found", { status: 404 });
  }
});

Using multiple if-else checks for routing causes linear search through routes on every request, slowing response as routes grow.

📉 Performance CostTriggers multiple string comparisons per request, increasing CPU time and delaying response.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Multiple if-else route checks	N/A (server-side)	N/A	N/A	[X] Bad
Map-based direct route lookup	N/A (server-side)	N/A	N/A	[OK] Good
Manual string parsing for dynamic routes	N/A (server-side)	N/A	N/A	[X] Bad
Precompiled pattern matching library	N/A (server-side)	N/A	N/A	[OK] Good

Rendering Pipeline

Routing patterns affect the server's request handling before rendering. Efficient routing reduces CPU time spent parsing URLs and selecting handlers, speeding up response generation and improving interaction responsiveness.

→Request Handling

→JavaScript Execution

→Response Generation

⚠️ BottleneckJavaScript Execution during route matching

Core Web Vital Affected

INP

Routing patterns affect how quickly a web app can respond to URL changes and serve the right content, impacting page load and interaction speed.

Optimization Tips

1Use direct lookups like Map for static routes to speed up matching.

2Use precompiled patterns or routing libraries for dynamic routes to reduce string parsing.

3Avoid long chains of if-else or manual string operations in routing logic.

Performance Quiz - 3 Questions

Which routing pattern improves response speed by avoiding multiple string comparisons?

A Using a Map for direct route lookup

B Using multiple if-else statements

C Parsing URL strings manually each time

D Using nested switch-case statements

DevTools: Performance

How to check: Record a profile while making requests to different routes. Look at CPU time spent in JavaScript functions related to routing.

What to look for: Lower CPU time and fewer function calls in route matching indicate better routing performance.

Practice

1. What is the main purpose of routing patterns in a Deno web application?

easy

A. To store data in a database

B. To style the webpage with colors and fonts

C. To connect URLs to specific code that runs when those URLs are visited

D. To manage user authentication only

Solution

1. Step 1: Understand routing role

   Routing connects web addresses (URLs) to the code that should run when those addresses are accessed.

2. Step 2: Compare options

   Only To connect URLs to specific code that runs when those URLs are visited describes this connection. Other options describe unrelated tasks like styling or data storage.

3. Final Answer:

   To connect URLs to specific code that runs when those URLs are visited -> Option C

4. Quick Check:

   Routing = URL to code connection [OK]

Hint: Routing links URLs to code that runs on visit [OK]

Common Mistakes:

• Confusing routing with styling or database tasks
• Thinking routing only manages user login
• Believing routing changes page colors

2. Which of the following is the correct way to define a static route using Oak in Deno?

easy

A. router.get('/home', (ctx) => { ctx.response.body = 'Welcome'; });

B. router.route('/home', (ctx) => { ctx.body = 'Welcome'; });

C. router.add('/home', (ctx) => { ctx.response.body = 'Welcome'; });

D. router.get('/home', (ctx) => { return 'Welcome'; });

Solution

1. Step 1: Recall Oak routing syntax

   Oak uses router.get(path, handler) to define GET routes. The handler sets ctx.response.body for response content.

2. Step 2: Check each option

   router.get('/home', (ctx) => { ctx.response.body = 'Welcome'; }); matches correct syntax. router.route('/home', (ctx) => { ctx.body = 'Welcome'; }); uses non-existent method 'route'. router.add('/home', (ctx) => { ctx.response.body = 'Welcome'; }); uses 'add' which is invalid. router.get('/home', (ctx) => { return 'Welcome'; }); returns string instead of setting ctx.response.body.

3. Final Answer:

   router.get('/home', (ctx) => { ctx.response.body = 'Welcome'; }); -> Option A

4. Quick Check:

   Oak static route uses router.get and ctx.response.body [OK]

Hint: Use router.get and set ctx.response.body for static routes [OK]

Common Mistakes:

• Using wrong router method like route or add
• Returning string instead of setting ctx.response.body
• Forgetting to set response body

3. Given this Oak route code in Deno:

router.get('/user/:id', (ctx) => {
  const id = ctx.params.id;
  ctx.response.body = `User ID is ${id}`;
});

// Request URL: /user/42

What will be the response body when visiting /user/42?

medium

A. "User ID is :id"

B. "User ID is 42"

C. "User ID is undefined"

D. "User ID is /user/42"

Solution

1. Step 1: Understand dynamic route parameter

   The route uses ':id' as a placeholder. When URL is '/user/42', ctx.params.id becomes '42'.

2. Step 2: Check response body construction

   The response body uses template string to insert id value, so it becomes 'User ID is 42'.

3. Final Answer:

   "User ID is 42" -> Option B

4. Quick Check:

   Dynamic param ':id' = '42' in response [OK]

Hint: Dynamic params fill ctx.params with URL parts [OK]

Common Mistakes:

• Using literal ':id' instead of param value
• Forgetting to access ctx.params.id
• Assuming undefined if param missing

4. Identify the error in this Oak routing code snippet:

router.get('/post/:postId', (ctx) => {
  const postId = ctx.request.params.postId;
  ctx.response.body = `Post: ${postId}`;
});

medium

A. ctx.response.body cannot be a template string

B. Missing async keyword in handler

C. Route path should not have colon before postId

D. ctx.request.params is undefined; should use ctx.params

Solution

1. Step 1: Check how to access route params in Oak

   Route parameters are accessed via ctx.params, not ctx.request.params.

2. Step 2: Verify other parts

   Async is not required here. Colon before postId is correct for dynamic routes. Template strings are valid for response body.

3. Final Answer:

   ctx.request.params is undefined; should use ctx.params -> Option D

4. Quick Check:

   Use ctx.params for route parameters [OK]

Hint: Use ctx.params, not ctx.request.params for route params [OK]

Common Mistakes:

• Accessing params from ctx.request instead of ctx
• Thinking async is mandatory for all handlers
• Removing colon from dynamic route path

5. You want to create a Deno Oak route that matches URLs like /product/123/review/456 where 123 is the product ID and 456 is the review ID. Which route pattern correctly captures both IDs as parameters?

hard

A. router.get('/product/:productId/review/:reviewId', (ctx) => { /* ... */ });

B. router.get('/product/:productId/:reviewId/review', (ctx) => { /* ... */ });

C. router.get('/product/review/:productId/:reviewId', (ctx) => { /* ... */ });

D. router.get('/product/:productId/review', (ctx) => { /* ... */ });

Solution

1. Step 1: Analyze URL structure

   The URL has 'product', then product ID, then 'review', then review ID in order.

2. Step 2: Match route pattern to URL

   router.get('/product/:productId/review/:reviewId', (ctx) => { /* ... */ }); matches this pattern exactly with dynamic segments ':productId' and ':reviewId' in correct places.

3. Step 3: Check other options

   router.get('/product/:productId/:reviewId/review', (ctx) => { /* ... */ }); misplaces ':reviewId' before 'review' segment. router.get('/product/review/:productId/:reviewId', (ctx) => { /* ... */ }); swaps order. router.get('/product/:productId/review', (ctx) => { /* ... */ }); misses review ID parameter.

4. Final Answer:

   router.get('/product/:productId/review/:reviewId', (ctx) => { /* ... */ }); -> Option A

5. Quick Check:

   Dynamic segments match URL parts in order [OK]

Hint: Match URL parts exactly; use :param for dynamic segments [OK]

Common Mistakes:

• Swapping order of dynamic segments and static parts
• Omitting one of the dynamic parameters
• Placing parameters in wrong URL positions