Nome di importazione della variabile ES6 in node.js?

è possibile importare qualcosa nel modulo fornendo il nome della variabile durante l'utilizzo dell'importazione ES6?

Cioè, voglio importare un modulo in fase di esecuzione a seconda dei valori forniti in una configurazione:

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

Non con l' importaffermazione.importe exportsono definiti in modo tale da essere analizzabili staticamente, quindi non possono dipendere dalle informazioni di runtime.

Stai cercando l' API del caricatore (polyfill) , ma non sono un po 'chiaro sullo stato delle specifiche:

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

Oltre alla risposta di Felix , noterò esplicitamente che questo non è attualmente consentito dalla grammatica ECMAScript 6 :

ImportDeclaration :

• import ImportClause FromClause;

• import ModuleSpecifier;

FromClause :

• da ModuleSpecifier

ModuleSpecifier :

• letterale stringa

Un ModuleSpecifier può essere solo un StringLiteral , non qualsiasi altro tipo di espressione come AdditiveExpression .

Sebbene questa non sia effettivamente un'importazione dinamica (ad es. Nella mia circostanza, tutti i file che sto importando di seguito verranno importati e raggruppati da webpack, non selezionato in fase di runtime), un modello che ho utilizzato che può aiutare in alcune circostanze è :

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

const templates = {
  Template1,
  Template2
};

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

o in alternativa:

// 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;

Non penso di poter tornare a un valore predefinito con la stessa facilità require(), il che genera un errore se provo a importare un percorso del modello costruito che non esiste.

Buoni esempi e confronti tra require e import possono essere trovati qui: http://www.2ality.com/2014/09/es6-modules-final.html

Eccellente documentazione sulla riesportazione da @iainastacio: http://exploringjs.com/es6/ch_modules.html#sec_all-exporting-styles

Sono interessato a ricevere feedback su questo approccio :)

C'è una nuova specifica chiamata importazione dinamica per i moduli ES. Fondamentalmente, chiami import('./path/file.js')e sei a posto. La funzione restituisce una promessa, che si risolve con il modulo se l'importazione è andata a buon fine.

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

Casi d'uso

I casi d'uso includono l' importazione di componenti basati su route per React, Vue ecc. E la possibilità di caricare i moduli in modo lento , una volta che sono richiesti durante il runtime.

Ulteriori informazioni

Ecco una spiegazione su Google Developers .

Compatibilità del browser (aprile 2020)

Secondo MDN è supportato da tutti i principali browser attuali (eccetto IE) e caniuse.com mostra il supporto dell'87% in tutta la quota di mercato globale. Anche in questo caso nessun supporto in IE o Edge non cromato.

Comprendo la domanda specificamente richiesta per ES6 importin Node.js, ma quanto segue potrebbe aiutare gli altri alla ricerca di una soluzione più generica:

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

Nota se stai importando un modulo ES6 e defaultdevi accedere all'esportazione, dovrai utilizzare uno dei seguenti:

let variableName = "es6.js";

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

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

Puoi anche utilizzare la destrutturazione con questo approccio che può aggiungere più familiarità alla sintassi con le altre importazioni:

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

Sfortunatamente, se vuoi accedere defaultoltre alla destrutturazione, dovrai eseguire questa operazione in più passaggi:

// 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;

puoi usare la notazione non ES6 per farlo. Questo è ciò che ha funzionato per me:

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

Mi piace meno questa sintassi, ma funziona:
invece di scrivere

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

usa questa sintassi:

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

L'importazione dinamica () (disponibile in Chrome 63+) farà il tuo lavoro. Ecco come:

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

Lo farei così

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...
}

chiamata da file

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