Importing from URLs in Deno - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean to import modules from URLs in Deno?

In Deno, you can load code modules directly from web addresses (URLs) instead of local files. This means your program fetches the code from the internet when it runs.

beginner

How do you write an import statement to load a module from a URL in Deno?

Use the syntax: <code>import { something } from "https://example.com/module.ts";</code> This tells Deno to get the module from that web address.

intermediate

Why does Deno cache modules imported from URLs?

Deno saves the downloaded modules on your computer so it doesn't fetch them again every time. This makes your program start faster and work offline after the first run.

intermediate

What happens if the URL of an imported module changes after caching?

Deno will keep using the cached version until you manually clear the cache or run with flags to reload. This avoids unexpected changes but means you must update the cache to get new code.

advanced

Can you import modules from URLs in Node.js the same way as in Deno?

No. Node.js does not support importing modules directly from URLs by default. Deno was designed with this feature to simplify module sharing over the web.

How do you import a module from a URL in Deno?

A import x from './mod.ts';

B require('https://example.com/mod.ts');

C load('https://example.com/mod.ts');

D import { x } from "https://example.com/mod.ts";

Deno uses ES module syntax with import statements and supports URLs directly.

What does Deno do after downloading a module from a URL?

A Caches it locally for reuse

B Deletes it immediately

C Runs it without saving

D Sends it back to the server

Deno caches modules locally to avoid repeated downloads and improve performance.

If a remote module changes, how can you force Deno to update it?

A Restart your computer

B Clear the cache or use --reload flag

C Nothing, it updates automatically

D Change the import URL

Using the --reload flag or clearing cache forces Deno to fetch the latest module version.

Which of these is NOT true about importing from URLs in Deno?

A Deno requires local files only

B Modules are fetched over HTTP or HTTPS

C You can import JavaScript or TypeScript modules

D Modules are cached after first download

Deno supports importing modules from URLs, not just local files.

Why might importing from URLs be useful?

A It only works offline

B It makes programs slower

C It allows sharing code easily over the internet

D It prevents caching

Importing from URLs lets developers share and reuse code without manual downloads.

Explain how importing modules from URLs works in Deno and why caching is important.

Think about how Deno gets and saves code from the internet.

Describe the benefits and potential challenges of importing modules from URLs in Deno.

Consider both convenience and maintenance aspects.

Practice

1. What is the main benefit of importing modules from URLs in Deno?

easy

A. You can use code directly from the web without installing it locally.

B. It makes your code run faster than local imports.

C. It automatically updates your code to the latest version.

D. It disables caching to always fetch fresh code.

Solution

1. Step 1: Understand URL imports in Deno

   Deno allows importing modules directly from web URLs, so you don't need to install packages locally.

2. Step 2: Identify the main benefit

   This feature simplifies using external code by fetching it on demand without manual installs.

3. Final Answer:

   You can use code directly from the web without installing it locally. -> Option A

4. Quick Check:

   Importing from URLs = No local install needed [OK]

Hint: Remember: URL imports mean no local installs needed [OK]

Common Mistakes:

• Thinking URL imports always update to latest code
• Believing URL imports disable caching
• Assuming URL imports make code run faster

2. Which of the following is the correct syntax to import a module from a URL in Deno?

easy

A. import { serve } from "https://deno.land/std/http/server.ts";

B. require("https://deno.land/std/http/server.ts");

C. import serve from "./server.ts";

D. load { serve } from "https://deno.land/std/http/server.ts";

Solution

1. Step 1: Recall Deno import syntax

   Deno uses ES module syntax with import { ... } from "url"; to import from URLs.

2. Step 2: Check each option

   import { serve } from "https://deno.land/std/http/server.ts"; uses correct ES module import syntax with a URL. require("https://deno.land/std/http/server.ts"); uses Node.js style require, which Deno does not use. import serve from "./server.ts"; imports locally, not from URL. load { serve } from "https://deno.land/std/http/server.ts"; uses invalid keyword load.

3. Final Answer:

   import { serve } from "https://deno.land/std/http/server.ts"; -> Option A

4. Quick Check:

   Correct import syntax = import { serve } from "https://deno.land/std/http/server.ts"; [OK]

Hint: Deno uses ES import syntax, not require or load [OK]

Common Mistakes:

• Using require() instead of import
• Trying to import local files with URL syntax
• Using invalid keywords like load

3. What will happen when you run this Deno code snippet?

import { serve } from "https://deno.land/std/http/server.ts";

console.log(typeof serve);

medium

A. "object"

B. "undefined"

C. Runtime error: Module not found

D. "function"

Solution

1. Step 1: Understand what is imported

   The serve function is exported from the URL module as a function.

2. Step 2: Check the typeof operator on serve

   Since serve is a function, typeof serve returns the string "function".

3. Final Answer:

   "function" -> Option D

4. Quick Check:

   typeof serve = "function" [OK]

Hint: Imported functions have typeof 'function' in JS/TS [OK]

Common Mistakes:

• Expecting 'undefined' if module loads correctly
• Thinking import causes runtime error
• Confusing function with object type

4. Identify the error in this Deno import statement:

import { serve } from "https://deno.land/std/http/server";

medium

A. URL must start with http:// not https://.

B. Using curly braces {} around serve is incorrect.

C. Missing file extension ".ts" in the URL.

D. Cannot import from URLs in Deno.

Solution

1. Step 1: Check URL correctness

   Deno requires full file paths including extensions for URL imports, so missing ".ts" causes error.

2. Step 2: Validate other parts

   Curly braces are correct for named imports. HTTPS is supported. Deno supports URL imports.

3. Final Answer:

   Missing file extension ".ts" in the URL. -> Option C

4. Quick Check:

   File extension required in URL imports [OK]

Hint: Always include file extensions in Deno URL imports [OK]

Common Mistakes:

• Omitting file extensions in import URLs
• Thinking HTTPS is unsupported
• Misunderstanding import syntax with braces

5. You want to ensure your Deno project always uses the same version of a library imported from a URL. Which practice helps achieve this?

hard

A. Disable Deno's cache to force fresh downloads every run.

B. Use a versioned URL like "https://deno.land/std@0.203.0/http/server.ts".

C. Manually download and import local copies only.

D. Import from the base URL without version to get latest updates.

Solution

1. Step 1: Understand versioning in URL imports

   Using versioned URLs locks the imported code to a specific release, ensuring stability.

2. Step 2: Evaluate options

   Use a versioned URL like "https://deno.land/std@0.203.0/http/server.ts". uses a versioned URL, which is best practice. Import from the base URL without version to get latest updates. fetches latest, risking breaking changes. Manually download and import local copies only. is manual and not URL import. Disable Deno's cache to force fresh downloads every run. disables caching, causing inefficiency.

3. Final Answer:

   Use a versioned URL like "https://deno.land/std@0.203.0/http/server.ts". -> Option B

4. Quick Check:

   Versioned URLs = stable imports [OK]

Hint: Lock versions in URL to keep imports stable [OK]

Common Mistakes:

• Using unversioned URLs expecting stability
• Disabling cache wastes time and bandwidth
• Confusing manual local imports with URL imports