Deno shims for Node.js APIs

Introduction

Deno shims let you use Node.js features in Deno. They help your code work smoothly when switching between Deno and Node.js.

You want to run a Node.js library in Deno without changing much code.

You are migrating a project from Node.js to Deno and need compatibility.

You want to use Node.js APIs like 'path' or 'buffer' in your Deno app.

You want to share code between Node.js and Deno environments easily.

Syntax

Deno

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

Replace shimName with the Node.js API you want to use, like path or buffer.

Use these shims to access familiar Node.js modules in Deno.

Examples

This example uses the path shim to join folder and file names like in Node.js.

Deno

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

const fullPath = path.join("folder", "file.txt");
console.log(fullPath);

This example uses the Buffer shim to create a buffer from a string and print it.

Deno

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

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

Sample Program

This program uses the Deno shim for Node.js path to join folder and file names. It prints the combined path.

Deno

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

function showFilePath(folder, file) {
  return path.join(folder, file);
}

console.log(showFilePath("docs", "readme.md"));

Important Notes

Deno shims are not full replacements but cover many common Node.js APIs.

Always check if the shim supports the features you need before using it.

Using shims helps keep your code cross-platform between Deno and Node.js.

Summary

Deno shims let you use Node.js APIs in Deno easily.

They help when migrating or sharing code between Deno and Node.js.

Import shims from https://deno.land/std/node/ and use them like Node.js modules.

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