Я не думаю, что это возможно, но, как правило, разрешение имен модулей зависит от загрузчиков модулей, поэтому может быть реализация загрузчика, которая поддерживает это.

А пока вы можете использовать промежуточный "файл модуля" в lib/things/index.js, который просто содержит

export * from 'ThingA';
export * from 'ThingB';
export * from 'ThingC';

и это позволит вам сделать

import {ThingA, ThingB, ThingC} from 'lib/things';

Просто вариант темы, уже представленной в ответе, но как насчет этого:

In a Thing,

export default function ThingA () {}

In things/index.js,

export {default as ThingA} from './ThingA'
export {default as ThingB} from './ThingB'
export {default as ThingC} from './ThingC'

Затем потреблять все в другом месте,

import * as things from './things'
things.ThingA()

Или потреблять только некоторые вещи,

import {ThingA,ThingB} from './things'

Текущие ответы предлагают обходной путь, но меня беспокоило, почему этого не существует, поэтому я создал плагин babel, который делает это.

Установите его, используя:

npm i --save-dev babel-plugin-wildcard

затем добавьте его в свой .babelrc с помощью:

{
    "plugins": ["wildcard"]
}

см. репо для получения подробной информации об установке.

Это позволяет вам делать это:

import * as Things from './lib/things';

// Do whatever you want with these :D
Things.ThingA;
Things.ThingB;
Things.ThingC;

опять же, репо содержит дополнительную информацию о том, что именно он делает, но это позволяет избежать создание index.js файлов, а также происходит во время компиляции, чтобы избежать выполнения readdirs во время выполнения.

Также с более новой версией вы можете сделать то же самое, что и ваш пример:

 import { ThingsA, ThingsB, ThingsC } from './lib/things/*';

работает так же, как указано выше.

Отличные гугли-мугли! Это было труднее, чем нужно.

Экспорт одного плоского по умолчанию

Это прекрасная возможность использовать spread ( ... в { ...Matters, ...Contacts } ниже:

// imports/collections/Matters.js
export default {           // default export
  hello: 'World',
  something: 'important',
};

// imports/collections/Contacts.js
export default {           // default export
  hello: 'Moon',
  email: '[email protected]',
};

// imports/collections/index.js
import Matters from './Matters';      // import default export as var 'Matters'
import Contacts from './Contacts';

export default {  // default export
  ...Matters,     // spread Matters, overwriting previous properties
  ...Contacts,    // spread Contacts, overwriting previosu properties
};

// imports/test.js
import collections from './collections';  // import default export as 'collections'

console.log(collections);

Затем, чтобы запустить код, скомпилированный babel из командная строка (из корня проекта /):

$ npm install --save-dev @babel/core @babel/cli @babel/preset-env @babel/node 
(trimmed)

$ npx babel-node --presets @babel/preset-env imports/test.js 
{ hello: 'Moon',
  something: 'important',
  email: '[email protected]' }

Экспорт одного древовидного значения по умолчанию

Если вы не хотите перезаписывать свойства, измените:

// imports/collections/index.js
import Matters from './Matters';     // import default as 'Matters'
import Contacts from './Contacts';

export default {   // export default
  Matters,
  Contacts,
};

И вывод будет:

$ npx babel-node --presets @babel/preset-env imports/test.js
{ Matters: { hello: 'World', something: 'important' },
  Contacts: { hello: 'Moon', email: '[email protected]' } }

Экспорт нескольких именованных экспортов без значения по умолчанию

Если вы посвятили себя DRY, синтаксис импорта также изменится:

// imports/collections/index.js

// export default as named export 'Matters'
export { default as Matters } from './Matters';  
export { default as Contacts } from './Contacts'; 

Это создает 2 именованных экспорта без экспорта по умолчанию. Затем измените:

// imports/test.js
import { Matters, Contacts } from './collections';

console.log(Matters, Contacts);

И вывод:

$ npx babel-node --presets @babel/preset-env imports/test.js
{ hello: 'World', something: 'important' } { hello: 'Moon', email: '[email protected]' }

Импортировать все именованные экспорты

// imports/collections/index.js

// export default as named export 'Matters'
export { default as Matters } from './Matters';
export { default as Contacts } from './Contacts';

// imports/test.js

// Import all named exports as 'collections'
import * as collections from './collections';

console.log(collections);  // interesting output
console.log(collections.Matters, collections.Contacts);

Обратите внимание на деструктуризацию import { Matters, Contacts } from './collections'; в предыдущем пример.

$ npx babel-node --presets @babel/preset-env imports/test.js
{ Matters: [Getter], Contacts: [Getter] }
{ hello: 'World', something: 'important' } { hello: 'Moon', email: '[email protected]' }

На практике

Учитывая эти исходные файлы:

/myLib/thingA.js
/myLib/thingB.js
/myLib/thingC.js

Создание /myLib/index.js для объединения всех файлов сводит на нет цель импорта / экспорта. Было бы проще сделать все глобальным в первую очередь, чем сделать все глобальным с помощью импорта / экспорта через «файлы-оболочки» index.js.

Если вам нужен конкретный файл, import thingA from './myLib/thingA'; в ваших собственных проектах.

Создание «файла-оболочки» с экспортом для модуля имеет смысл только в том случае, если вы упаковываете пакет для npm или в многолетнем проекте с несколькими командами.

Сделали это так далеко? Дополнительные сведения см. В документации.

Кроме того, ура для Stackoverflow, наконец, поддерживающего три символа в качестве разметки кода.

Теперь вы можете использовать async import ():

import fs = require('fs');

а потом:

fs.readdir('./someDir', (err, files) => {
 files.forEach(file => {
  const module = import('./' + file).then(m =>
    m.callSomeMethod();
  );
  // or const module = await import('file')
  });
});

Подобно принятому вопросу, но позволяет масштабировать без необходимости добавлять новый модуль в индексный файл каждый раз, когда вы его создаете:

./modules/moduleA.js

export const example = 'example';
export const anotherExample = 'anotherExample';

./modules/index.js

// require all modules on the path and with the pattern defined
const req = require.context('./', true, /.js$/);

const modules = req.keys().map(req);

// export all modules
module.exports = modules;

./example.js

import { example, anotherExample } from './modules'

Я использовал их несколько раз (в частности, для создания массивных объектов, разделяющих данные на множество файлов (например, узлы AST)), чтобы создать их, я сделал крошечный скрипт (который я только что добавил в npm, чтобы все остальные можно использовать).

Использование (в настоящее время вам нужно использовать babel для использования файла экспорта):

$ npm install -g folder-module
$ folder-module my-cool-module/

Создает файл, содержащий:

export {default as foo} from "./module/foo.js"
export {default as default} from "./module/default.js"
export {default as bar} from "./module/bar.js"
...etc

Затем вы можете просто использовать файл:

import * as myCoolModule from "my-cool-module.js"
myCoolModule.foo()

Просто другой подход к ответу @Bergi

// lib/things/index.js
import ThingA from './ThingA';
import ThingB from './ThingB';
import ThingC from './ThingC';

export default {
 ThingA,
 ThingB,
 ThingC
}

Использует

import {ThingA, ThingB, ThingC} from './lib/things';

Вы также можете использовать require:

const moduleHolder = []

function loadModules(path) {
  let stat = fs.lstatSync(path)
  if (stat.isDirectory()) {
    // we have a directory: do a tree walk
    const files = fs.readdirSync(path)
    let f,
      l = files.length
    for (var i = 0; i < l; i++) {
      f = pathModule.join(path, files[i])
      loadModules(f)
    }
  } else {
    // we have a file: load it
    var controller = require(path)
    moduleHolder.push(controller)
  }
}

Затем используйте свой moduleHolder с динамически загружаемыми контроллерами:

  loadModules(DIR) 
  for (const controller of moduleHolder) {
    controller(app, db)
  }

Если вы используете webpack. При этом файлы импортируются автоматически и экспортируются как пространство имен api.

Таким образом, нет необходимости обновлять каждый добавленный файл.

import camelCase from "lodash-es";
const requireModule = require.context("./", false, /\.js$/); // 
const api = {};

requireModule.keys().forEach(fileName => {
  if (fileName === "./index.js") return;
  const moduleName = camelCase(fileName.replace(/(\.\/|\.js)/g, ""));
  api[moduleName] = {
    ...requireModule(fileName).default
  };
});

export default api;

Для пользователей Typescript;

import { camelCase } from "lodash-es"
const requireModule = require.context("./folderName", false, /\.ts$/)

interface LooseObject {
  [key: string]: any
}

const api: LooseObject = {}

requireModule.keys().forEach(fileName => {
  if (fileName === "./index.ts") return
  const moduleName = camelCase(fileName.replace(/(\.\/|\.ts)/g, ""))
  api[moduleName] = {
    ...requireModule(fileName).default,
  }
})

export default api

Это не совсем то, о чем вы просили, но с помощью этого метода я могу перебирать componentsList в других моих файлах и использовать такие функции, как componentsList.map(...), которые я считаю очень полезными!

import StepOne from './StepOne';
import StepTwo from './StepTwo';
import StepThree from './StepThree';
import StepFour from './StepFour';
import StepFive from './StepFive';
import StepSix from './StepSix';
import StepSeven from './StepSeven';
import StepEight from './StepEight';

const componentsList= () => [
  { component: StepOne(), key: 'step1' },
  { component: StepTwo(), key: 'step2' },
  { component: StepThree(), key: 'step3' },
  { component: StepFour(), key: 'step4' },
  { component: StepFive(), key: 'step5' },
  { component: StepSix(), key: 'step6' },
  { component: StepSeven(), key: 'step7' },
  { component: StepEight(), key: 'step8' }
];

export default componentsList;

Мне удалось взять подход пользователя atilkan и немного его изменить:

Для пользователей Typescript;

require.context('@/folder/with/modules', false, /\.ts$/).keys().forEach((fileName => {
    import('@/folder/with/modules' + fileName).then((mod) => {
            (window as any)[fileName] = mod[fileName];
            const module = new (window as any)[fileName]();

            // use module
});

}));

если вы не экспортируете значения по умолчанию в A, B, C, а просто экспортируете {}, это возможно

// things/A.js
export function A() {}

// things/B.js
export function B() {}

// things/C.js
export function C() {}

// foo.js
import * as Foo from ./thing
Foo.A()
Foo.B()
Foo.C()