Deno shims for Node.js APIs - Step-by-Step Execution

Concept Flow - Deno shims for Node.js APIs

Start Deno script

↓

Import Node.js shim module

↓

Shim provides Node.js API

↓

Use Node.js API in Deno

↓

Deno translates calls to native APIs

↓

Script runs with Node.js compatibility

↓

End

Deno loads a shim module that mimics Node.js APIs, allowing Deno scripts to use Node.js functions by translating them to Deno's native capabilities.

Execution Sample

Deno

import { Buffer } from "https://deno.land/std/node/buffer.ts";

const buf = Buffer.from("hello");
console.log(buf.toString());

This code imports the Node.js Buffer shim in Deno, creates a buffer from a string, and prints it back as a string.

Execution Table

Step	Action	Evaluation	Result
1	Import Buffer from Node.js shim	Buffer module loaded	Buffer object available
2	Call Buffer.from("hello")	Create buffer with bytes of 'hello'	Buffer instance with bytes [104,101,108,108,111]
3	Call buf.toString()	Convert buffer bytes to string	"hello"
4	console.log output	Print string to console	hello

💡 Script ends after printing 'hello' to console

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
Buffer	undefined	Buffer module loaded	Buffer module loaded	Buffer module loaded
buf	undefined	Buffer instance with bytes [104,101,108,108,111]	Same buffer instance	Same buffer instance

Key Moments - 2 Insights

Why do we import Buffer from a URL instead of using Node.js directly?

Deno does not have Node.js built-in. The shim module (step 1) provides a compatible Buffer API by implementing it in Deno.

Does the Buffer object behave exactly like Node.js Buffer?

The shim aims to be compatible but may have some differences. The execution table shows basic usage works as expected.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'buf' after step 2?

A String 'hello'

B Undefined

C Buffer instance with bytes [104,101,108,108,111]

D Buffer module

💡 Hint

Check the 'Result' column in row for step 2 in execution_table

At which step is the string 'hello' printed to the console?

A Step 3

B Step 4

C Step 2

D Step 1

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table rows

If we did not import the Buffer shim, what would happen when calling Buffer.from?

A It would throw an error because Buffer is undefined

B It would print 'hello' directly

C It would create a buffer anyway

D It would fallback to Deno native buffer automatically

💡 Hint

Refer to variable_tracker 'Buffer' initial value and step 1 in execution_table

Concept Snapshot

Deno shims for Node.js APIs allow Deno to use Node.js modules.
Import shim modules from URLs like std/node.
Use Node.js APIs (e.g., Buffer) as usual.
Deno translates calls to native implementations.
This enables compatibility without Node.js runtime.

Full Transcript

This visual execution shows how Deno uses shims to provide Node.js APIs. First, the Buffer module is imported from Deno's standard library shim. Then, Buffer.from creates a buffer from a string. Calling toString on the buffer converts it back to the original string. Finally, console.log prints the string. The variable tracker shows Buffer is undefined before import and becomes available after. The buffer variable holds the bytes of the string. Key moments clarify why import is needed and compatibility notes. The quiz tests understanding of variable states and output timing.

Practice

1. What is the main purpose of Deno shims for Node.js APIs?

easy

A. To convert Deno code into Node.js code automatically

B. To allow using Node.js modules and APIs in Deno environment

C. To replace Deno's runtime with Node.js runtime

D. To compile TypeScript code into JavaScript

Solution

1. Step 1: Understand what shims do

   Deno shims provide compatibility layers that mimic Node.js APIs inside Deno.

2. Step 2: Identify the purpose of these shims

   The main goal is to let developers use Node.js modules and APIs in Deno without rewriting code.

3. Final Answer:

   To allow using Node.js modules and APIs in Deno environment -> Option B

4. Quick Check:

   Deno shims = Node.js API compatibility [OK]

Hint: Shims let Deno run Node.js code easily [OK]

Common Mistakes:

• Thinking shims convert code automatically
• Confusing runtime replacement with API compatibility
• Assuming shims compile TypeScript

2. Which is the correct way to import the Node.js 'path' module shim in Deno?

easy

A. import path from 'https://deno.land/std/node/path.ts';

B. import { path } from 'https://deno.land/std/node/path.ts';

C. import * as path from 'https://deno.land/std/node/path.ts';

D. import path from 'node:path';

Solution

1. Step 1: Check Deno shim import style

   Deno shims for Node.js modules are imported as namespaces using * as syntax.

2. Step 2: Match the correct import statement

   Only import * as path from 'https://deno.land/std/node/path.ts'; correctly imports the shim as a namespace.

3. Final Answer:

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

4. Quick Check:

   Namespace import = import * as [OK]

Hint: Use 'import * as' for Node.js shims in Deno [OK]

Common Mistakes:

• Using default import syntax which is invalid here
• Trying named import when module exports namespace
• Using 'node:path' which is Node.js native, not Deno shim

3. What will be the output of this Deno code using Node.js 'path' shim?

import * as path from 'https://deno.land/std/node/path.ts';
console.log(path.basename('/foo/bar/baz.txt'));

medium

A. 'baz.txt'

B. '/foo/bar/baz.txt'

C. 'baz'

D. SyntaxError

Solution

1. Step 1: Understand path.basename behavior

   The basename function returns the last part of a path, including extension.

2. Step 2: Apply to given path string

   For '/foo/bar/baz.txt', the basename is 'baz.txt'.

3. Final Answer:

   'baz.txt' -> Option A

4. Quick Check:

   path.basename('/foo/bar/baz.txt') = 'baz.txt' [OK]

Hint: basename returns last filename with extension [OK]

Common Mistakes:

• Expecting the full path as output
• Confusing basename with dirname
• Syntax errors from wrong import (not here)

4. Identify the error in this Deno code using Node.js 'fs' shim:

import { readFileSync } from 'https://deno.land/std/node/fs.ts';
const data = readFileSync('./file.txt', 'utf8');
console.log(data);

medium

A. readFileSync does not accept encoding as second argument in Deno shim

B. The import path is incorrect, should be 'https://deno.land/std/node/fs.ts'

C. readFileSync is asynchronous and cannot be used like this

D. No error, code works as expected

Solution

1. Step 1: Verify the import

   Named import { readFileSync } from Deno's std/node/fs.ts is valid as functions are named exports.

2. Step 2: Check readFileSync arguments

   The function accepts encoding as a string ('utf8') as second argument, matching Node.js API.

3. Final Answer:

   No error, code works as expected -> Option D

4. Quick Check:

   readFileSync(path, 'utf8') valid [OK]

Hint: Named imports and string encoding work in Deno fs shim [OK]

Common Mistakes:

• Believing encoding must always be an options object
• Confusing with Deno's native synchronous APIs
• Overlooking that fs shim closely mimics Node.js

5. You want to use the Node.js 'events' module shim in Deno to create an event emitter. Which code snippet correctly creates an emitter and listens for a 'ping' event?

hard

A. import * as events from 'https://deno.land/std/node/events.ts';
const emitter = new events.EventEmitter();
emitter.addListener('ping', () => console.log('pong'));
emitter.emit('ping');

B. import events from 'https://deno.land/std/node/events.ts';
const emitter = new events.EventEmitter();
emitter.on('ping', () => console.log('pong'));
emitter.emit('ping');

C. import EventEmitter from 'https://deno.land/std/node/events.ts';
const emitter = new EventEmitter();
emitter.on('ping', () => console.log('pong'));
emitter.emit('ping');

D. import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.on('ping', () => console.log('pong'));
emitter.emit('ping');

Solution

1. Step 1: Check correct import style for 'events' shim

   The 'events' module shim exports as a namespace, so import * as events is correct.

2. Step 2: Verify usage of EventEmitter and event methods

   Creating emitter with new events.EventEmitter() and using addListener or on works; here addListener is used correctly.

3. Step 3: Confirm emit triggers listener

   Calling emitter.emit('ping') triggers the listener printing 'pong'.

4. Final Answer:

   import * as events from 'https://deno.land/std/node/events.ts'; const emitter = new events.EventEmitter(); emitter.addListener('ping', () => console.log('pong')); emitter.emit('ping'); -> Option A

5. Quick Check:

   Namespace import + EventEmitter + addListener = correct [OK]

Hint: Use namespace import and new events.EventEmitter() [OK]

Common Mistakes:

• Using default import which is invalid
• Importing from 'node:events' which is Node.js native
• Confusing on() and addListener() usage with wrong import