Efterhånden som vores applikation vokser sig større, stiger behovet for at splitte den op i flere filer, såkaldte “moduler”. Et modul kan indeholde en klasse eller et bibliotek af funktioner til et specifikt formål.
I mange år levede JavaScript uden nogen syntaks for moduler på sprogniveau. Det var ikke det helt store problem, da scripts ofte var små og simple – så der var ikke det store behov for det.
Men i takt med at scripts blev mere og mere komplekse, opfandt fællesskabet en række måder at organisere kode i moduler, samt specielle biblioteker til at indlæse moduler efter behov.
For at nævne nogle (af historiske grunde, da de ikke længere er så relevante):
- AMD – en af de helt gamle modulsystemer, oprindeligt implementeret af biblioteket require.js.
- CommonJS – et modulsystem skal til Node.js server.
- UMD – endnu et modulsystem, foreslået som et universelt system og kompatibelt med AMD og CommonJS.
Nu bliver alle disse langsomt en del af historien, men vi kan stadig finde dem i gamle scripts.
Moduler på sprogniveau så dagens lys i standarden i 2015. Den har gradvist udviklet sig siden og er nu understøttet i alle større browsere og i Node.js – så vil vil studere disse moderne moduler implementeret i JavaScript og lade de andre systemer i fred.
Hvad er et modul?
Et modul er bare en fil. Et script er ét modul. Det er så simpelt som det kan være.
Moduler kan hente hinanden og bruge specielle direktiver export og import til at bytte funktionalitet, kalde funktioner fra et modul i et andet:
exportnøgleordet mærker variabler og funktioner, der skal være tilgængelige fra uden for det nuværende modul.importtillader import af funktionalitet fra andre moduler.
For eksempel, hvis vi har en fil sayHi.js der eksporterer en funktion:
// 📁 sayHi.js
export function sayHi(user) {
alert(`Hej, ${user}!`);
}
…Så kan en anden fil importere og bruge den:
// 📁 main.js
import {sayHi} from './sayHi.js';
alert(sayHi); // function...
sayHi('John'); // Hej, John!
Direktivet import henter modulet med stien ./sayHi.js relativt til den nuværende fil. Den tildeler den eksporterede funktion sayHi til den tilsvarende variabel skrevet i de krøllede parenteser.
Lad os køre eksemplet i browseren.
Da moduler understøtter specielle nøgleord og funktioner, skal vi fortælle browseren, at et script skal behandles som et modul, ved at bruge attributten <script type="module">.
Som her:
export function sayHi(user) {
return `Hej, ${user}!`;
}<!doctype html>
<script type="module">
import {sayHi} from './say.js';
document.body.innerHTML = sayHi('John');
</script>Browseren henter og evaluerer automatisk det importerede modul (og dets importerede moduler hvis nødvendigt), for derefter at køre scriptet.
Hvis du forsøger at åbne en web-side som en fil lokalt (via file:// protocol), vil du opleve at import/export direktiverne ikke virker. Brug en lokal web-server, såsom static-server eller brug “live server” muligheden i din editor, såsom VS Code Live Server Extension til at teste moduler.
Fundamentale modul funktionaliteter
Hvad er forskellen mellem moduler og “normale” scripts?
Der er en række grundlæggende træk, som er gyldige både for browser og server-side JavaScript.
Altid “use strict”
Moduler arbejder altid i strict mode. Hvis du f.eks. forsøger at tildele en variabel uden at deklarere den først, vil det give en fejl.
<script type="module">
a = 5; // fejl, a er ikke deklareret
</script>
Scope på modul-niveau
Hvert modul har sit eget top-level scope. Med andre ord, top-level variable og funktioner fra et modul er ikke synlige i andre scripts.
I eksemplet nedenfor importeres to scripts, og hello.js forsøger at bruge user variablen deklareret i user.js. Det mislykkes, fordi det er et separat modul (du vil se fejlen i konsollen):
alert(user); // no such variable (each module has independent variables)let user = "John";<!doctype html>
<script type="module" src="user.js"></script>
<script type="module" src="hello.js"></script>Moduler skal bruge export til at fortælle, hvad der skal være tilgængeligt udenfor modulet og selv bruge import til det der er brug for udefra.
user.jsbør eksportere variablenuser.hello.jsbør importere den frauser.jsmodulet.
Med andre ord: Med moduler bruger vi import/export i stedet for at stole på globale variabler.
Her er den korrekte udgave af koden før:
import {user} from './user.js';
document.body.innerHTML = user; // Johnexport let user = "John";<!doctype html>
<script type="module" src="hello.js"></script>I browseren, hvis vi taler om HTML sider, eksisterer der også et uafhængigt top-level scope for hvert <script type="module">.
Her ser du to scripts på den samme side, begge med type="module". De ser ikke hinandens top-level variable, fordi de er separate moduler:
<script type="module">
// Variablen er kun synlig i dette module script
let user = "John";
</script>
<script type="module">
alert(user); // Error: user is not defined
</script>
I browseren, kan vi lave en variabel window-level global ved at eksplicit tildele den til en window egenskab, f.eks. window.user = "John".
Derefter vil alle scripts se den, både med type="module" og uden for det.
Det skal dog understreges, at den måde at oprette globale variable på “giver panderynker” hos andre udviklere. Så prøv at undgå det med mindre at det er nødvendigt.
Koden i et modul evalueres kun den første gang det importeres
Hvis det samme modulet importeres af flere andre moduler, evalueres dens kode kun én gang, når det importeres første gang. Derefter gives dens eksporteringer til alle yderligere importører.
Den ene evaluering har vigtige konsekvenser, som vi bør være opmærksomme på.
Lad os se et par eksempler.
Først, hvis det at eksekvere koden i et modul medfører sideeffekter, f.eks. visning af en besked, så vil import af det samme modul flere gange kun udløse sideeffekten én gang – første gang:
// 📁 alert.js
alert("Modulet er evalueret!");
// Importer det samme modul fra forskellige filer
// 📁 1.js
import `./alert.js`; // Modulet er evalueret!
// 📁 2.js
import `./alert.js`; // (viser intet)
Den anden gang modulet importeres, vises intet, fordi modulet allerede er blevet evalueret.
Der er en regel: top-level modul-kode skal bruges til initialisering, oprettelse af modulspecifikke insterne datastrukture. Hvis vi har behov for at gøre noget kaldbart flere gange – bør vi eksportere det som en funktion, som vi gjorde med sayHi ovenfor.
Lad os nu se et mere komplekst eksempel.
Lad os sige, at et modul eksporterer et objekt:
// 📁 admin.js
export let admin = {
name: "John"
};
Hvis dette modul importeres fra flere filer, evalueres modulet kun første gang, admin objektet oprettes, og derefter sendes det til alle yderligere importører.
Alle importører får præcis det samme admin objekt:
// 📁 1.js
import {admin} from './admin.js';
admin.name = "Pete";
// 📁 2.js
import {admin} from './admin.js';
alert(admin.name); // Pete
// Både 1.js og 2.js refererer til samme admin objekt
// Ændringer lavet i 1.js er synlige i 2.js
Som du kan se, når 1.js ændrer name egenskaben i det importerede admin, så kan 2.js se den nye admin.name.
Det er netop fordi modulet kun bliver eksekveret én gang. Eksporteringer genereres, og derefter deles de mellem importørerne, så hvis noget ændrer admin objektet, vil andre importører se det.
Sådan adfærd er faktisk meget praktisk, fordi den tillader os at konfigurere moduler.
Med andre ord kan moduler levere generisk funktionalitet, der har brug for opsætning – f.eks. noget der kræver autentifikation. Så kan det eksportere et konfigurationsobjekt, som det forventes, at den ydre kode tildele det.
Her er det klassiske mønster for at konfigurere moduler:
- Et modul eksporterer nogle metoder til konfiguration, f.eks. et konfigurationsobjekt.
- Ved første import initialiserer vi det og skriver til dets egenskaber. Det kan et top-level applikationsscript f.eks. gøre.
- Yderligere importeringer bruger modulet.
For eksempel kan admin.js modulet levere bestemte funktionaliteter (f.eks. autentifikation), men forvente, at legitimationsoplysningerne kommer ind i config objektet udefra:
// 📁 admin.js
export let config = { };
export function sayHi() {
alert(`Jeg er klar, ${config.user}!`);
}
Her eksporterer, admin.js selve objektet config (Her er det helt tomt, men det kan også indeholde standard egenskaber).
Så i init.js, det første script i vores app, importerer vi config og sætter config.user:
// 📁 init.js
import {config} from './admin.js';
config.user = "Pete";
…Nu er modulet admin.js konfigureret.
Yderligere importører kan kalde det, og det viser korrekt den nuværende bruger:
// 📁 another.js
import {sayHi} from './admin.js';
sayHi(); // Jeg er klar, Pete!
import.meta
Objektet import.meta indeholder informationen om det nuværende modul.
Dets indhold afhænger af miljøet. I browseren indeholder det URL’en for scriptet, eller en nuværende webpage URL hvis det er inde i HTML: