CKTIS / JavaScript
Modules laden en code splitsen
Modules vormen een afhankelijkheidsgraaf. Een statische import declareert een afhankelijkheid, terwijl `import()` code een module laat aanvragen tijdens het uitvoeren. Het opsplitsen van code in afzonderlijk geladen delen hangt af van de omgeving en de hulpmiddelen, niet alleen van JavaScript-syntaxis.
Versie: ECMAScript and Web APIs; exact feature edition and browser support reviewed per entry; Node 24 in repository does not prove browser API support
Syntax
// module.mjs
export const name = value;
// main.mjs
import { name } from "./module.mjs";
async function main() {
const namespace = await import("./module.mjs");
}
main().catch(console.error);Modules laden omvat het ophalen van een module en diens afhankelijkheden, het koppelen van imports aan exports en het uitvoeren van code. Statische import-declaraties staan op het hoogste niveau van een module; ze geven afhankelijkheden aan voordat de module-inhoud wordt uitgevoerd. Geïmporteerde namen zijn live-koppelingen naar exports, geen kopieën van hun waarden.
Dynamische import(specifier) is een expressie die ook in gewone scripts en binnen voorwaarden of functies beschikbaar is. De expressie geeft een Promise terug die na succesvol laden, koppelen en uitvoeren normaal gesproken het namespaceobject van de module met de exports als resultaat oplevert. Exporteert de module echter een aanroepbare waarde met de naam then, dan roept het resolutiemechanisme van de promise die waarde aan met functies voor resolutie en afwijzing. De uitkomst van de promise hangt dan af van die aanroep en hoeft dus niet het namespaceobject te zijn. Handel een afwijzing af met try/catch rond await of met .catch(). Het argument kan tijdens het uitvoeren worden berekend.
Code splitsen betekent dat een toepassing wordt voorbereid in delen die afzonderlijk kunnen worden geladen. import() biedt een laadpunt voor laden op verzoek, maar ECMAScript vereist geen afzonderlijke uitvoerbestanden of netwerkverzoeken. Hoe modulespecificatoren worden omgezet in verwijzingen naar concrete modules en hoe die modules worden opgehaald, hangt af van de host; het splitsen van uitvoerbestanden hangt af van de hulpmiddelen. Als een volgende import naar dezelfde module verwijst, wordt de code van die module niet opnieuw uitgevoerd. Zonder aanroepbare export met de naam then leveren beide geslaagde dynamische imports hetzelfde namespaceobject op.
Statische modules zijn geïntroduceerd in ES2015 en import() in ES2020. Dit is geen compatibiliteitstabel voor browsers: de taalspecificatie garandeert geen ondersteuning in een bepaalde browser, en Node 24 toont geen ondersteuning voor Web APIs aan. In het voorbeeld is main.mjs het startpunt en vragen beide aanroepen van import() dezelfde lokale module aan: math.mjs. Alleen die module wordt dynamisch geladen. Het voorbeeld laat niet zien hoe een bundler code opsplitst.
Voorbeelden
// math.mjs
export const double = value => value * 2;
// main.mjs
async function main() {
const first = await import("./math.mjs");
const second = await import("./math.mjs");
console.log(first.double(21));
console.log(first === second);
}
main().catch(console.error);Resultaat
42 true
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.