Import and export modules

Concepts

  • import allows you to include and use modules held elsewhere, on your local file system or remotely.
  • Imports are URLs or file system paths.
  • export allows you to specify which parts of your module are accessible to users who import your module.

Overview

Deno by default standardizes the way modules are imported in both JavaScript and TypeScript using the ECMAScript 6 import/export standard.

It adopts browser-like module resolution, meaning that file names must be specified in full. You may not omit the file extension and there is no special handling of index.js.

```js, ignore import { add, multiply } from “./arithmetic.ts”;

  2. Dependencies are also imported directly, there is no package management
  3. overhead. Local modules are imported in exactly the same way as remote modules.
  4. As the examples show below, the same functionality can be produced in the same
  5. way with local or remote modules.
  7. ## Local Import
  9. In this example the `add` and `multiply` functions are imported from a local
  10. `arithmetic.ts` module.
  12. **Command:** `deno run local.ts`
  14. ```ts
  15. /**
  16.  * local.ts
  17.  */
  18. import { add, multiply } from "./arithmetic.ts";
  20. function totalCost(outbound: number, inbound: number, tax: number): number {
  21.   return multiply(add(outbound, inbound), tax);
  22. }
  24. console.log(totalCost(19, 31, 1.2));
  25. console.log(totalCost(45, 27, 1.15));
  27. /**
  28.  * Output
  29.  *
  30.  * 60
  31.  * 82.8
  32.  */

Remote Import

In the local import example above an add and multiply method are imported from a locally stored arithmetic module. The same functionality can be created by importing add and multiply methods from a remote module too.

In this case the Ramda module is referenced, including the version number. Also note a JavaScript module is imported directly into a TypeScript module, Deno has no problem handling this.

Command: deno run ./remote.ts

  1. /**
  2.  * remote.ts
  3.  */
  4. import {
  5.   add,
  6.   multiply,
  7. } from "https://x.nest.land/ramda@0.27.0/source/index.js";
  9. function totalCost(outbound: number, inbound: number, tax: number): number {
  10.   return multiply(add(outbound, inbound), tax);
  11. }
  13. console.log(totalCost(19, 31, 1.2));
  14. console.log(totalCost(45, 27, 1.15));
  16. /**
  17.  * Output
  18.  *
  19.  * 60
  20.  * 82.8
  21.  */

Export

In the local import example above the add and multiply functions are imported from a locally stored arithmetic module. To make this possible the functions stored in the arithmetic module must be exported.

To do this just add the keyword export to the beginning of the function signature as is shown below.

  1. /**
  2.  * arithmetic.ts
  3.  */
  4. export function add(a: number, b: number): number {
  5.   return a + b;
  6. }
  8. export function multiply(a: number, b: number): number {
  9.   return a * b;
  10. }

All functions, classes, constants and variables which need to be accessible inside external modules must be exported. Either by prepending them with the export keyword or including them in an export statement at the bottom of the file.