Migrating a Node.js project to Deno - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Deno's module import system

Which of the following import statements is valid in Deno for importing a module from a URL?

A const serve = require('http').serve;

B import { serve } from 'https://deno.land/std@0.177.0/http/server.ts';

C import express from 'express';

D import * as http from 'node:http';

💡 Hint

Deno uses URL imports instead of Node.js package names.

Deno imports modules directly from URLs or local files. Option B correctly imports the serve function from Deno's standard library using a URL. Option B and C use Node.js style imports which are not valid in Deno. Option B tries to import a Node.js built-in module which is not available in Deno.

❓ component_behavior

intermediate

File system permissions in Deno

What will happen if you run this Deno script without any permission flags? ```ts const data = await Deno.readTextFile('example.txt'); console.log(data); ```

Deno

const data = await Deno.readTextFile('example.txt');
console.log(data);

A The script will read and print the file content successfully.

B The script will prompt the user to grant file access.

C The script will silently fail and print nothing.

D The script will throw a runtime error about missing read permissions.

💡 Hint

Deno requires explicit permission flags for file system access.

Deno enforces security by requiring explicit permission flags. Without --allow-read, reading files causes a runtime error. It does not prompt or silently fail.

📝 Syntax

advanced

Converting CommonJS require to ES module import

Which import statement correctly replaces this Node.js require statement in Deno? ```js const path = require('path'); ```

Deno

const path = require('path');

A import * as path from 'https://deno.land/std/path/mod.ts';

B import * as path from 'path';

C const path = await import('path');

D import { path } from 'https://deno.land/std/path/mod.ts';

💡 Hint

Deno uses ES module imports from URLs for standard libraries.

Option A correctly imports the entire path module from Deno's standard library URL. Option A is invalid because 'path' is not a built-in module in Deno. Option A is invalid syntax for static imports. Option A tries to import a named export 'path' which does not exist; the module exports functions directly.

🔧 Debug

advanced

Fixing a runtime error caused by Node.js globals in Deno

Given this code snippet migrated from Node.js to Deno: ```ts console.log(__dirname); ``` What error will this produce in Deno and why?

Deno

console.log(__dirname);

A ReferenceError: __dirname is not defined because Deno does not support Node.js globals.

B undefined because __dirname is not initialized.

C It prints the current directory path as in Node.js.

D SyntaxError due to invalid variable usage.

💡 Hint

Deno does not have Node.js global variables like __dirname.

Deno does not define Node.js globals such as __dirname. Accessing it causes a ReferenceError. To get the current directory, Deno uses import.meta.url and URL parsing.

❓ state_output

expert

Output of a Deno script using top-level await and dynamic import

What is the output of this Deno script? ```ts const modulePath = 'https://deno.land/std@0.177.0/fmt/colors.ts'; const colors = await import(modulePath); console.log(colors.red('Hello Deno')); ```

Deno

const modulePath = 'https://deno.land/std@0.177.0/fmt/colors.ts';
const colors = await import(modulePath);
console.log(colors.red('Hello Deno'));

A SyntaxError due to top-level await usage

B Hello Deno (printed as plain text without color)

C Hello Deno (printed in red color in the terminal)

D RuntimeError: Cannot import module from URL

💡 Hint

Deno supports top-level await and dynamic imports from URLs.

Deno supports top-level await in modules and dynamic imports from URLs. The colors.red function returns the string wrapped in ANSI escape codes for red color. The output will appear red in terminals that support colors.

Practice

1. Which of the following is a key difference when migrating a Node.js project to Deno?

easy

A. Deno uses CommonJS modules by default.

B. Deno uses URL imports instead of npm packages.

C. Deno requires no code changes from Node.js.

D. Deno automatically grants all permissions to the code.

Solution

1. Step 1: Understand module import differences

   Node.js uses npm packages imported by name, while Deno uses direct URL imports.

2. Step 2: Check permission handling and module system

   Deno requires explicit permission grants and uses ES modules, not CommonJS.

3. Final Answer:

   Deno uses URL imports instead of npm packages. -> Option B

4. Quick Check:

   Module import style = D [OK]

Hint: Remember: Deno imports modules via URLs, not npm names. [OK]

Common Mistakes:

• Assuming Deno uses npm packages directly
• Thinking Deno grants permissions automatically
• Believing Node.js code runs unchanged in Deno

2. Which syntax correctly imports the lodash library in Deno?

easy

A. import _ from 'https://cdn.skypack.dev/lodash';

B. const _ = require('lodash');

C. import _ from 'lodash';

D. import _ from 'npm:lodash';

Solution

1. Step 1: Identify Deno import style

   Deno imports modules using URLs, not package names or require().

2. Step 2: Check each option

   import _ from 'https://cdn.skypack.dev/lodash'; uses a valid URL import from a CDN, which is correct for Deno.

3. Final Answer:

   import _ from 'https://cdn.skypack.dev/lodash'; -> Option A

4. Quick Check:

   URL import syntax = C [OK]

Hint: Use full URLs for imports in Deno, not package names. [OK]

Common Mistakes:

• Using require() which is Node.js only
• Importing by package name without URL
• Using npm: prefix which Deno does not support

3. What will be the output when running this Deno script?

import { readFileStr } from 'https://deno.land/std/fs/mod.ts';
const data = await readFileStr('./file.txt');
console.log(data.trim());

Assuming file.txt contains " Hello Deno \n".

medium

A. Error: readFileStr is not a function

B. Hello Deno

C. undefined

D. oneD olleH

Solution

1. Step 1: Understand readFileStr usage

   The function readFileStr was deprecated and removed in recent versions of Deno std library. Using it will cause an error.

2. Step 2: Analyze output

   Since readFileStr is not a function, the script will throw an error.

3. Final Answer:

   Error: readFileStr is not a function -> Option A

4. Quick Check:

   Function availability = D [OK]

Hint: Use Deno.readTextFile or Deno.readTextFileSync instead of deprecated readFileStr. [OK]

Common Mistakes:

• Expecting original spaces without trim()
• Confusing readFileStr with non-existent function
• Ignoring await causing undefined

4. You migrated a Node.js script to Deno but get this error: PermissionDenied: read access to './data.json' is not allowed. How do you fix it?

medium

A. Install the missing npm package for file access.

B. Change the file path to an absolute path.

C. Run the script with deno run --allow-read flag.

D. Use require() instead of import.

Solution

1. Step 1: Understand Deno's permission model

   Deno requires explicit permission flags to access files for security.

2. Step 2: Apply correct permission flag

   Using --allow-read grants read access to files, fixing the error.

3. Final Answer:

   Run the script with deno run --allow-read flag. -> Option C

4. Quick Check:

   Permission error fix = A [OK]

Hint: Add --allow-read flag to grant file read permission. [OK]

Common Mistakes:

• Ignoring permission flags in Deno
• Trying to fix path instead of permissions
• Using Node.js require() which Deno disallows

5. You have this Node.js code snippet using the 'fs' module:

const fs = require('fs');
const data = fs.readFileSync('./info.txt', 'utf8');
console.log(data);

How should you rewrite it in Deno to read the file synchronously?

hard

A. const data = Deno.readFile('./info.txt'); console.log(data);

B. const data = await Deno.readTextFile('./info.txt'); console.log(data);

C. import fs from 'https://deno.land/std/fs/mod.ts'; const data = fs.readFileSync('./info.txt');

D. const data = Deno.readTextFileSync('./info.txt'); console.log(data);

Solution

1. Step 1: Identify synchronous file read in Deno

   Deno provides readTextFileSync() for synchronous text file reading.

2. Step 2: Compare options

   const data = Deno.readTextFileSync('./info.txt'); console.log(data); correctly uses readTextFileSync and logs the data synchronously.

3. Final Answer:

   const data = Deno.readTextFileSync('./info.txt'); console.log(data); -> Option D

4. Quick Check:

   Synchronous file read in Deno = A [OK]

Hint: Use Deno.readTextFileSync for sync file reading like Node's readFileSync. [OK]

Common Mistakes:

• Using await with synchronous functions
• Trying to import Node.js fs module in Deno
• Using readFile which returns Uint8Array, not string