Routing patterns in Deno - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a basic GET route using Oak framework.

Deno

router.[1]('/home', (context) => {
  context.response.body = 'Welcome Home';
});

Drag options to blanks, or click blank then click option'

Aput

Bget

Cpost

Ddelete

Attempts:

3 left

💡 Hint

Common Mistakes

Using post instead of get for a GET route

Misspelling the method name

The get method defines a route that responds to GET requests.

2fill in blank

medium

Complete the code to extract a route parameter named 'id'.

Deno

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

Drag options to blanks, or click blank then click option'

Aid

Bname

Cuser

Dparam

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name than accessed in code

Forgetting the colon before the parameter name

The route parameter :id matches the URL segment and is accessed via context.params.id.

3fill in blank

hard

Fix the error in the middleware function to correctly pass control to the next handler.

Deno

router.get('/data', async (context, [1]) => {
  context.response.body = 'Data loaded';
  await next();
});

Drag options to blanks, or click blank then click option'

Arequest

Bctx

Chandler

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong parameter name and causing runtime errors

Not calling await next() to continue middleware chain

The second parameter is conventionally named next and is used to call the next middleware.

4fill in blank

hard

Fill both blanks to create a route that matches any HTTP method and responds with 'Hello'.

Deno

router.[1]('/hello', (context) => {
  context.response.body = '[2]';
});

Drag options to blanks, or click blank then click option'

Aall

Bget

Cpost

DHello

Attempts:

3 left

💡 Hint

Common Mistakes

Using get or post instead of all for all methods

Forgetting to set the response body

The all method matches all HTTP methods. The response body is set to 'Hello'.

5fill in blank

hard

Fill all three blanks to create a nested router with prefix '/api' and a GET route '/status' that returns JSON.

Deno

const apiRouter = new Router().[1]('/api');
apiRouter.[2]('/status', (context) => {
  context.response.body = { [3]: 'ok' };
});

Drag options to blanks, or click blank then click option'

Aprefix

Bget

C"status"

Dpost

Attempts:

3 left

💡 Hint

Common Mistakes

Using post instead of get for the route

Not using prefix to set the base path

Using unquoted keys in JSON response

The prefix method sets the base path for the router. The get method defines a GET route. The JSON key must be a string, so "status" is correct.

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