Nome de importação da variável ES6 em node.js?

é possível importar algo para o módulo fornecendo o nome da variável ao usar a importação ES6?

Ou seja, quero importar algum módulo em um tempo de execução, dependendo dos valores fornecidos em uma configuração:

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

Não com a importdeclaração. importe exportsão definidos de forma que sejam estaticamente analisáveis, de forma que não possam depender de informações de tempo de execução.

Você está procurando a API do carregador (polyfill) , mas não estou certo sobre o status da especificação:

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

Além da resposta de Felix , observarei explicitamente que isso não é permitido atualmente pela gramática ECMAScript 6 :

ImportDeclaration :

• import ImportClause FromClause;

• import ModuleSpecifier;

FromClause :

• de ModuleSpecifier

ModuleSpecifier :

• StringLiteral

Um ModuleSpecifier pode ser apenas um StringLiteral , não qualquer outro tipo de expressão como uma AdditiveExpression .

Embora esta não seja realmente uma importação dinâmica (por exemplo, no meu caso, todos os arquivos que estou importando abaixo serão importados e agrupados pelo webpack, não selecionados em tempo de execução), um padrão que tenho usado que pode ajudar em algumas circunstâncias é :

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

const templates = {
  Template1,
  Template2
};

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

ou alternativamente:

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

Não acho que posso voltar a um padrão tão facilmente com o require(), o que gera um erro se eu tentar importar um caminho de modelo construído que não existe.

Bons exemplos e comparações entre exigir e importar podem ser encontrados aqui: http://www.2ality.com/2014/09/es6-modules-final.html

Excelente documentação sobre reexportação de @iainastacio: http://exploringjs.com/es6/ch_modules.html#sec_all-exporting-styles

Estou interessado em ouvir feedback sobre essa abordagem :)

Há uma nova especificação chamada importação dinâmica para módulos ES. Basicamente, você apenas liga import('./path/file.js')e está pronto para continuar. A função retorna uma promessa, que resolve com o módulo se a importação foi bem-sucedida.

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

Casos de uso

Os casos de uso incluem a importação de componentes com base em rota para React, Vue etc. e a capacidade de carregar módulos lentamente , uma vez que são necessários durante o tempo de execução.

Outras informações

Aqui está uma explicação sobre o Google Developers .

Compatibilidade do navegador (abril de 2020)

De acordo com o MDN, ele é compatível com todos os principais navegadores atuais (exceto o IE) e caniuse.com mostra 87% de suporte em toda a participação de mercado global. Novamente sem suporte no IE ou Edge sem cromo.

Eu entendo a pergunta feita especificamente para ES6 importem Node.js, mas o seguinte pode ajudar outras pessoas que procuram uma solução mais genérica:

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

Observe que se você estiver importando um módulo ES6 e precisar acessar a defaultexportação, precisará usar um dos seguintes:

let variableName = "es6.js";

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

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

Você também pode usar a desestruturação com essa abordagem, o que pode adicionar mais familiaridade de sintaxe com suas outras importações:

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

Infelizmente, se você deseja acessar defaulte também desestruturar, precisará realizar isso em várias etapas:

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

você pode usar a notação não ES6 para fazer isso. Isto é o que funcionou para mim:

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

Gosto menos dessa sintaxe, mas funciona: em
vez de escrever

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

use esta sintaxe:

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

A importação dinâmica () (disponível no Chrome 63+) fará o seu trabalho. Veja como:

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

Eu faria assim

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

chamada do arquivo

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