Compatibility gaps and workarounds in Deno - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does Deno not support Node.js built-in modules directly?

Deno is a modern runtime for JavaScript and TypeScript. However, it does not support Node.js built-in modules like fs or path out of the box. Why is this the case?

A Deno uses a different module system and aims for browser compatibility, so it avoids Node.js-specific APIs.

B Deno does not support any file system operations at all.

C Deno only runs TypeScript, so Node.js modules are incompatible.

D Deno requires all modules to be installed via npm before use.

💡 Hint

Think about Deno's design goals and how it handles modules differently from Node.js.

Deno was designed to be secure and compatible with browser standards. It uses ES modules and does not include Node.js built-in modules to avoid legacy dependencies and security issues.

❓ component_behavior

intermediate

How does Deno handle npm packages that rely on Node.js built-ins?

You try to use an npm package in Deno that depends on Node.js built-in modules like crypto. What happens and how can you work around it?

A Deno ignores the built-in modules and runs the package without them.

B Deno automatically converts Node.js built-ins to browser APIs without errors.

C Deno requires you to rewrite the package code to remove all Node.js dependencies.

D Deno throws an error because the built-in module is missing; you can use compatibility shims or polyfills to fix this.

💡 Hint

Consider how Deno's runtime differs from Node.js and what tools exist to bridge gaps.

Deno does not include Node.js built-in modules by default. When npm packages rely on them, errors occur. Developers can use shims or polyfills to provide similar functionality.

🔧 Debug

advanced

Identify the cause of this Deno import error

You run this Deno script:

import { readFileSync } from "fs";
console.log(readFileSync("./data.txt", "utf8"));

What error will Deno show and why?

A SyntaxError: Unexpected token 'import' because Deno does not support ES modules.

B Error: Cannot find module 'fs' because Deno does not support Node.js built-in modules.

C TypeError: readFileSync is not a function because the import path is wrong.

D No error; the code runs and prints the file content.

💡 Hint

Think about Deno's module support and how it handles Node.js built-ins.

Deno does not include Node.js built-in modules like fs. Importing from "fs" causes a module not found error.

📝 Syntax

advanced

Which code snippet correctly imports a Node.js package in Deno using compatibility?

You want to use the npm package lodash in Deno. Which import statement is correct assuming you use Deno's npm compatibility?

A import _ from "lodash";

B const _ = require('lodash');

C import _ from "npm:lodash";

D import _ from "https://cdn.skypack.dev/lodash";

💡 Hint

Deno uses a special prefix to import npm packages.

Deno supports npm packages with the npm: prefix. Using import _ from "npm:lodash"; works correctly.

❓ state_output

expert

What is the output of this Deno script using a Node.js polyfill?

Given this Deno script using a polyfill for the Node.js path module:

import path from "https://deno.land/std@0.203.0/node/path.ts";

const fullPath = path.join("/home/user", "docs", "file.txt");
console.log(fullPath);

What will be printed when you run this script on a Unix-like system?

A /home/user/docs/file.txt

B \home\user\docs\file.txt

C Error: path.join is not a function

D /home/user/docs\file.txt

💡 Hint

Consider how the polyfill adapts Node.js path behavior on Unix systems.

The polyfill provides Node.js path module functionality. On Unix systems, path.join uses forward slashes.

Practice

1. Which statement best describes how Deno handles module imports compared to Node.js?

easy

A. Deno uses URL-based ES module imports instead of Node.js package imports.

B. Deno uses CommonJS require() for all modules like Node.js.

C. Deno imports modules only from local files, not URLs.

D. Deno automatically converts Node.js packages to ES modules.

Solution

1. Step 1: Understand Deno's import style

   Deno uses ES modules imported via URLs or local paths, unlike Node.js which uses package names with require().

2. Step 2: Compare with Node.js imports

   Node.js uses CommonJS require() or ES modules with package names resolved from node_modules, which Deno does not support by default.

3. Final Answer:

   Deno uses URL-based ES module imports instead of Node.js package imports. -> Option A

4. Quick Check:

   Import style difference = A [OK]

Hint: Remember: Deno imports from URLs, Node.js from packages [OK]

Common Mistakes:

• Thinking Deno supports require() like Node.js
• Assuming Deno imports only local files
• Believing Deno auto-converts Node packages

2. Which of the following is the correct way to import the "path" module in Deno?

easy

A. import path from "path";

B. const path = require("path");

C. import * as path from "https://deno.land/std/path/mod.ts";

D. import { path } from "node:path";

Solution

1. Step 1: Identify Deno's standard library import method

   Deno imports standard modules via URLs from its official repository, e.g., https://deno.land/std/path/mod.ts.

2. Step 2: Check each option

   import path from "path"; uses Node.js style import without URL, invalid in Deno. const path = require("path"); uses require(), not supported in Deno. import { path } from "node:path"; uses Node.js built-in module specifier, not valid in Deno.

3. Final Answer:

   import * as path from "https://deno.land/std/path/mod.ts"; -> Option C

4. Quick Check:

   Standard library import = D [OK]

Hint: Deno imports std modules via full URLs [OK]

Common Mistakes:

• Using require() instead of import
• Omitting the full URL for std modules
• Trying to import Node.js built-ins directly

3. What will be the output of this Deno code snippet?

import { readFileStr } from "https://deno.land/std/fs/mod.ts";

const data = await readFileStr("./example.txt");
console.log(data);

Assuming "example.txt" contains the text "Hello Deno!".

medium

A. undefined

B. "Hello Deno!"

C. SyntaxError due to await outside async

D. Error: Module not found

Solution

1. Step 1: Understand the code behavior

   The code imports readFileStr from Deno's standard fs module and reads the file content asynchronously.

2. Step 2: Check for syntax and runtime correctness

   The code uses top-level await, which Deno supports. The file exists with content "Hello Deno!" so readFileStr returns that string.

3. Final Answer:

   "Hello Deno!" -> Option B

4. Quick Check:

   File read content = A [OK]

Hint: Deno supports top-level await for async calls [OK]

Common Mistakes:

• Assuming await needs async function wrapper
• Confusing readFileStr with returning undefined
• Thinking module URL is invalid

4. You try to use the Node.js "crypto" module in Deno with import crypto from "crypto"; but get an error. What is the best way to fix this?

medium

A. Install Node.js crypto package via npm and import it.

B. Add a --allow-node-compat flag to Deno run command.

C. Change import to import * as crypto from "crypto";.

D. Use Deno's built-in Web Crypto API instead of Node.js crypto.

Solution

1. Step 1: Identify compatibility issue

   Deno does not support Node.js built-in modules like "crypto" directly, so importing "crypto" fails.

2. Step 2: Use Deno's alternative

   Deno provides the Web Crypto API natively, which covers most cryptographic needs securely and without extra packages.

3. Final Answer:

   Use Deno's built-in Web Crypto API instead of Node.js crypto. -> Option D

4. Quick Check:

   Use Web Crypto API = B [OK]

Hint: Use Deno's Web Crypto, not Node.js crypto module [OK]

Common Mistakes:

• Trying to import Node.js crypto directly
• Assuming npm packages work without compatibility layer
• Using wrong import syntax for Node.js modules

5. You want to use a popular Node.js library that depends on "fs" and "path" modules in your Deno project. Which approach best handles this compatibility gap?

hard

A. Use a compatibility layer like "deno_std/node" to shim Node.js modules.

B. Rewrite the library code to remove all Node.js dependencies.

C. Run the Node.js library in a separate Node.js process and communicate via IPC.

D. Import the Node.js modules directly using Deno's native support.

Solution

1. Step 1: Understand the problem

   Node.js libraries often rely on built-in modules like "fs" and "path" which Deno does not support natively.

2. Step 2: Identify Deno's workaround

   Deno provides a compatibility layer "deno_std/node" that shims many Node.js modules to allow such libraries to run with minimal changes.

3. Final Answer:

   Use a compatibility layer like "deno_std/node" to shim Node.js modules. -> Option A

4. Quick Check:

   Use compatibility shim = C [OK]

Hint: Use deno_std/node for Node.js module compatibility [OK]

Common Mistakes:

• Trying to import Node.js modules directly
• Assuming full rewrite is always needed
• Ignoring IPC as a complex alternative