Czy można przekazać opcje do importu ES6?

Jak to tłumaczysz:

var x = require('module')(someoptions);

do ES6?

Nie ma sposobu, aby to zrobić za pomocą jednej importinstrukcji, nie pozwala na wywołania.

Więc nie nazwałbyś tego bezpośrednio, ale zasadniczo możesz zrobić to samo, co commonjs robi z domyślnymi eksportami:

// module.js
export default function(options) {
    return {
        // actual module
    }
}

// main.js
import m from 'module';
var x = m(someoptions);

Alternatywnie, jeśli używasz modułu ładującego, który obsługuje monadyczne obietnice, możesz być w stanie zrobić coś takiego

System.import('module').ap(someoptions).then(function(x) {
    …
});

Z nowym importoperatorem może się to stać

const promise = import('module').then(m => m(someoptions));

lub

const x = (await import('module'))(someoptions)

jednak prawdopodobnie nie chcesz dynamicznego importu, ale statyczny.

Pojęcie

Oto moje rozwiązanie przy użyciu ES6

Bardzo dobrze wpisuje się w odpowiedź @ Bergi, jest to „szablon”, którego używam podczas tworzenia importu, który wymaga przekazania parametrów class deklaracji. Jest to używane w izomorficznym frameworku, który piszę, więc będzie działać z transpilerem w przeglądarce i node.js (używam Babelz Webpack):

./MyClass.js

export default (Param1, Param2) => class MyClass {
    constructor(){
        console.log( Param1 );
    }
}

./main.js

import MyClassFactory from './MyClass.js';

let MyClass = MyClassFactory('foo', 'bar');

let myInstance = new MyClass();

Powyższe zostanie wyświetlone foow konsoli

EDYTOWAĆ

Przykład z prawdziwego świata

W przypadku rzeczywistego przykładu używam tego do przekazywania przestrzeni nazw w celu uzyskania dostępu do innych klas i instancji w ramach. Ponieważ po prostu tworzymy funkcję i przekazujemy obiekt jako argument, możemy go użyć z naszą deklaracją klasy taką jak:

export default (UIFramework) => class MyView extends UIFramework.Type.View {
    getModels() {
        // ...
        UIFramework.Models.getModelsForView( this._models );
        // ...
    }
}

Import jest nieco bardziej skomplikowany iw automagicalmoim przypadku jest to cały framework, ale zasadniczo dzieje się tak:

// ...
getView( viewName ){
    //...
    const ViewFactory = require(viewFileLoc);
    const View = ViewFactory(this);
    return new View();
}
// ...

Mam nadzieję, że to pomoże!

Opierając się na @ BERGI za odpowiedź używać moduł debugowania za pomocą ES6 byłby następujący

// original
var debug = require('debug')('http');

// ES6
import * as Debug from 'debug';
const debug = Debug('http');

// Use in your code as normal
debug('Hello World!');

Uważam, że można użyć modułów ładujących es6. http://babeljs.io/docs/learn-es6/

System.import("lib/math").then(function(m) {
  m(youroptionshere);
});

Musisz tylko dodać te 2 linie.

import xModule from 'module';
const x = xModule('someOptions');

Wylądowałem w tym wątku, szukając czegoś podobnego i chciałbym zaproponować rodzaj rozwiązania, przynajmniej w niektórych przypadkach (ale zobacz uwagę poniżej).

Przypadek użycia

Mam moduł, który uruchamia logikę instancji natychmiast po załadowaniu. Ja nie jak nazwać tę startowy logikę zewnątrz modułu (który jest taki sam jak zaproszenia new SomeClass(p1, p2)lubnew ((p1, p2) => class SomeClass { ... p1 ... p2 ... }) i podobne).

Podoba mi się, że ta logika init uruchomi się raz, rodzaj pojedynczego przepływu instancji, ale raz dla określonego sparametryzowanego kontekstu.

Przykład

service.js ma w swoim podstawowym zakresie:

let context = null;                  // meanwhile i'm just leaving this as is
console.log('initialized in context ' + (context ? context : 'root'));

Moduł A robi:

import * as S from 'service.js';     // console has now "initialized in context root"

Moduł B robi:

import * as S from 'service.js';     // console stays unchanged! module's script runs only once

Jak dotąd dobrze: usługa jest dostępna dla obu modułów, ale została zainicjowana tylko raz.

Problem

Jak sprawić, by działał jako kolejna instancja i ponownie zainicjował się w innym kontekście, na przykład w module C?

Rozwiązanie?

Właśnie o tym myślę: użyj parametrów zapytania. W usłudze dodalibyśmy:

let context = new URL(import.meta.url).searchParams.get('context');

Moduł C zrobiłby:

import * as S from 'service.js?context=special';

moduł zostanie ponownie zaimportowany, uruchomi się jego podstawowa logika init i zobaczymy w konsoli:

initialized in context special

Uwaga: sam radziłbym NIE ćwiczyć zbyt często tego podejścia, ale zostawić je w ostateczności. Czemu? Moduł zaimportowany więcej niż jeden raz jest raczej wyjątkiem niż regułą, więc jest to nieco nieoczekiwane zachowanie i jako takie może zmylić konsumentów lub nawet złamać własne paradygmaty „singleton”, jeśli takie istnieją.

Oto moje podejście do tego pytania na przykładzie modułu debugowania;

Na stronie npm tego modułu masz to:

var debug = require ('debug') ('http')

W powyższej linii ciąg jest przekazywany do modułu, który jest importowany w celu skonstruowania. Oto jak zrobiłbyś to samo w ES6

import {debug as Debug} from 'debug' const debug = Debug ('http');

Mam nadzieję, że to komuś pomoże.