Apakah mungkin untuk meneruskan opsi ke impor ES6?

Bagaimana Anda menerjemahkan ini:

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

ke ES6?

Tidak ada cara untuk melakukan ini dengan satu importpernyataan, itu tidak memungkinkan untuk doa.

Jadi Anda tidak akan menyebutnya secara langsung, tetapi pada dasarnya Anda dapat melakukan hal yang sama seperti yang biasa dilakukan oleh ekspor default:

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

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

Atau, jika Anda menggunakan pemuat modul yang mendukung janji monadik , Anda mungkin dapat melakukan sesuatu seperti

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

Dengan importoperator baru itu mungkin

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

atau

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

namun Anda mungkin tidak ingin impor dinamis tetapi impor statis.

Konsep

Inilah solusi saya menggunakan ES6

Sangat sesuai dengan respons @ Bergi, ini adalah "templat" yang saya gunakan ketika membuat impor yang memerlukan parameter yang diloloskan untuk classdeklarasi. Ini digunakan pada kerangka isomorfik yang saya tulis, sehingga akan bekerja dengan transpiler di browser dan di node.js (saya gunakan Babeldengan 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();

Di atas akan ditampilkan foodalam konsol

EDIT

Contoh Dunia Nyata

Sebagai contoh dunia nyata, saya menggunakan ini untuk lulus dalam namespace untuk mengakses kelas dan instance lain dalam suatu kerangka kerja. Karena kita hanya membuat fungsi dan meneruskan objek sebagai argumen, kita dapat menggunakannya dengan suka suka deklarasi kelas:

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

Impornya sedikit lebih rumit dan automagicaldalam kasus saya mengingat bahwa ini adalah keseluruhan kerangka kerja, tetapi pada dasarnya inilah yang terjadi:

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

Saya harap ini membantu!

Membangun jawaban @ Bergi untuk menggunakan modul debug menggunakan es6 adalah sebagai berikut

// 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!');

Saya yakin Anda bisa menggunakan modul loader ES6. http://babeljs.io/docs/learn-es6/

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

Anda hanya perlu menambahkan 2 baris ini.

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

Saya telah mendarat di utas ini mencari yang agak mirip dan ingin mengusulkan semacam solusi, setidaknya untuk beberapa kasus (tapi lihat Catatan di bawah).

Gunakan kasing

Saya memiliki modul, yang menjalankan beberapa logika instantiation segera setelah memuat. Saya tidak suka menyebut init logic ini di luar modul (yang sama dengan panggilan new SomeClass(p1, p2)atau new ((p1, p2) => class SomeClass { ... p1 ... p2 ... })dan sejenisnya).

Saya suka bahwa logika init ini akan berjalan sekali, semacam aliran instantiasi tunggal, tetapi sekali per beberapa konteks parametrized tertentu.

Contoh

service.js memiliki ruang lingkup yang sangat mendasar:

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

Modul A melakukan:

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

Modul B melakukan:

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

Sejauh ini bagus: layanan tersedia untuk kedua modul tetapi diinisialisasi hanya sekali.

Masalah

Bagaimana membuatnya berjalan sebagai contoh lain dan init itu sendiri sekali lagi dalam konteks lain, katakanlah di Modul C?

Larutan?

Inilah yang saya pikirkan: gunakan parameter kueri. Dalam layanan kami akan menambahkan yang berikut:

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

Modul C akan melakukan:

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

modul akan diimpor kembali, itu logika init dasar akan berjalan dan kita akan lihat di konsol:

initialized in context special

Catatan: Saya sendiri menyarankan untuk TIDAK berlatih pendekatan ini banyak, tetapi meninggalkannya sebagai pilihan terakhir. Mengapa? Modul yang diimpor lebih dari satu kali lebih merupakan pengecualian daripada aturan, jadi itu adalah perilaku yang tidak terduga dan dengan demikian dapat membingungkan konsumen atau bahkan menghancurkan paradigma 'singleton' sendiri, jika ada.

Inilah pendapat saya tentang pertanyaan ini menggunakan modul debug sebagai contoh;

Pada halaman npm modul ini, Anda memiliki ini:

var debug = wajib ('debug') ('http')

Pada baris di atas, sebuah string diteruskan ke modul yang diimpor, untuk membangun. Inilah cara Anda melakukan hal yang sama di ES6

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

Semoga ini bisa membantu seseorang di luar sana.