Importname der ES6-Variablen in node.js?

Ist es möglich, während des ES6-Imports etwas in ein Modul mit Variablennamen zu importieren?

Dh ich möchte ein Modul zur Laufzeit importieren, abhängig von den in einer Konfiguration angegebenen Werten:

import something from './utils/' + variableName;

Nicht mit der importAussage. importundexport sind so definiert, dass sie statisch analysierbar sind, sodass sie nicht von Laufzeitinformationen abhängen können.

Sie suchen nach der Loader-API (Polyfill) , aber ich bin mir über den Status der Spezifikation etwas unklar:

System.import('./utils/' + variableName).then(function(m) {
  console.log(m);
});

Zusätzlich zu Felix 'Antwort werde ich ausdrücklich darauf hinweisen, dass dies derzeit in der ECMAScript 6-Grammatik nicht zulässig ist :

Importdeklaration :

• import ImportClause FromClause;

• import ModuleSpecifier;

FromClause :

• von ModuleSpecifier

ModuleSpecifier :

• StringLiteral

Ein ModuleSpecifier kann nur ein StringLiteral sein , keine andere Art von Ausdruck wie ein AdditiveExpression .

Obwohl dies eigentlich kein dynamischer Import ist (z. B. werden unter meinen Umständen alle Dateien, die ich unten importiere, von einem Webpack importiert und gebündelt, das zur Laufzeit nicht ausgewählt wurde), ist ein von mir verwendetes Muster, das unter bestimmten Umständen hilfreich sein kann ::

import Template1 from './Template1.js';
import Template2 from './Template2.js';

const templates = {
  Template1,
  Template2
};

export function getTemplate (name) {
  return templates[name];
}

oder alternativ:

// index.js
export { default as Template1 } from './Template1';
export { default as Template2 } from './Template2';


// OtherComponent.js
import * as templates from './index.js'
...
// handy to be able to fall back to a default!
return templates[name] || templates.Template1;

Ich glaube nicht, dass ich mit so einfach auf einen Standard zurückgreifen kann require(), was einen Fehler auslöst, wenn ich versuche, einen konstruierten Vorlagenpfad zu importieren, der nicht existiert.

Gute Beispiele und Vergleiche zwischen Anforderung und Import finden Sie hier: http://www.2ality.com/2014/09/es6-modules-final.html

Hervorragende Dokumentation zum erneuten Exportieren aus @iainastacio: http://exploringjs.com/es6/ch_modules.html#sec_all-exporting-styles

Ich bin interessiert, Feedback zu diesem Ansatz zu hören :)

Es gibt eine neue Spezifikation, die als dynamischer Import für ES-Module bezeichnet wird. Grundsätzlich rufen Sie einfach an import('./path/file.js')und können loslegen. Die Funktion gibt ein Versprechen zurück, das mit dem Modul aufgelöst wird, wenn der Import erfolgreich war.

async function importModule() {
   try {
      const module = await import('./path/module.js');
   } catch (error) {
      console.error('import failed');
   }
}

Anwendungsfälle

Anwendungsfälle umfassen routenbasierte Komponentenimport für React, Vue usw. und die Möglichkeit, Module zu verzögern , sobald sie zur Laufzeit benötigt werden.

Weitere Informationen

Hier ist eine Erklärung zu Google Developers .

Browserkompatibilität (April 2020)

Laut MDN wird es von jedem aktuellen großen Browser (außer IE) unterstützt und caniuse.com zeigt eine Unterstützung von 87% über den globalen Marktanteil. Wieder keine Unterstützung in IE oder Nicht-Chrom-Edge.

Ich verstehe die Frage, die speziell für ES6 importin Node.js gestellt wurde, aber das Folgende könnte anderen helfen, nach einer allgemeineren Lösung zu suchen:

let variableName = "es5.js";
const something = require(`./utils/${variableName}`);

Hinweis: Wenn Sie ein ES6-Modul importieren und auf den defaultExport zugreifen müssen , müssen Sie eine der folgenden Optionen verwenden:

let variableName = "es6.js";

// Assigning
const defaultMethod = require(`./utils/${variableName}`).default;

// Accessing
const something = require(`./utils/${variableName}`);
something.default();

Sie können bei diesem Ansatz auch die Destrukturierung verwenden, um die Syntax mit Ihren anderen Importen besser vertraut zu machen:

// Destructuring 
const { someMethod } = require(`./utils/${variableName}`);    
someMethod();

Wenn Sie sowohl Zugriff defaultals auch Destrukturierung wünschen , müssen Sie dies leider in mehreren Schritten ausführen:

// ES6 Syntax
Import defaultMethod, { someMethod } from "const-path.js";

// Destructuring + default assignment
const something = require(`./utils/${variableName}`);

const defaultMethod = something.default;    
const { someMethod, someOtherMethod } = something;

Sie können dazu die Nicht-ES6-Notation verwenden. Das hat bei mir funktioniert:

let myModule = null;
if (needsToLoadModule) {
  myModule = require('my-module').default;
}

Ich mag diese Syntax weniger, aber sie funktioniert:
anstatt zu schreiben

import memberName from "path" + "fileName"; 
// this will not work!, since "path" + "fileName" need to be string literal

Verwenden Sie diese Syntax:

let memberName = require("path" + "fileName");

Der dynamische Import () (verfügbar in Chrome 63+) erledigt Ihre Aufgabe. Hier ist wie:

let variableName = 'test.js';
let utilsPath = './utils/' + variableName;
import(utilsPath).then((module) => { module.something(); });

Ich würde es so machen

function load(filePath) {
     return () => System.import(`${filePath}.js`); 
     // Note: Change .js to your file extension
}

let A = load('./utils/' + variableName)

// Now you can use A in your module

./utils/test.js

export default () => {
  doSomething...
}

Aufruf aus Datei

const variableName = 'test';
const package = require(`./utils/${variableName}`);
package.default();