es6模块如何导入? [英] How can an es6 module import itself?
问题描述
我有一个名为 fooModule
的模块。在本模块中,我导入 fooModule
(本身):
import *作为fooModule从'./fooModule';
导出函数logFoo(){
console.log(fooModule)
}
当调用 logFoo()
时,我可以看到fooModule的所有导出。
这是如何工作的?
循环依赖对于声明性导入/导出没有问题。在你的情况下,圆圈的最小长度是: - )
解决方案是, import
将值导入到变量中,但是它将一个变量引用导出到导出的变量中。有关可变变量的示例,请查看此处,并在这个问题用于确切的术语。
它对于模块命名空间对象是一样的 - 它们的属性只是解析为实际导出变量的getter。 >
所以当你的模块被加载和评估时,会出现以下步骤:
- 静态分析
export
和import
声明以构建依赖图 - 模块范围已创建
- 由于模块唯一的依赖关系本身就已经被初始化了,所以不必等待
-
fooModule
变量被创建并实例化为具有模块导出名称的对象,该模块已知为[logFoo]
。fooModule.logFoo
属性成为一个getter,它将评估模块范围中的logFoo
变量(如果您已经使用export {A as B}
,然后fooModule.B
将解析为A
,但在你的情况下,这两个名字是一样的)。 - 模块范围中的变量声明创建变量,在你的情况下
logFoo
,并且函数声明被初始化(即logFoo
获得分配的功能) - 模块代码运行你的情况下没有任何反应)
现在当你在一个模块中调用 logFoo
导入它, fooModule
将引用包含 logFoo
的命名空间。没有魔法: - )
I have a module called fooModule
. Inside this module, I import fooModule
(itself):
import * as fooModule from './fooModule';
export function logFoo() {
console.log(fooModule)
}
When logFoo()
is called, I can see all of the exports of the fooModule.
How does this work?
Circular dependencies are no problem for declarative imports/exports. In your case, the circle is of minimal length though :-)
The solution is that an import
does not import a value into a variable, but that it makes a variable a reference to the exported variable. Have a look here for an example of a mutable variable, and at this question for exact terminology.
And it's the same for module namespace objects - their properties are just getters that resolve to the actual exported variable.
So when your module is loaded and evaluated, the following steps occur:
- The source is statically analysed for
export
andimport
declarations to build a dependency graph - The module scope is created
- Since the only dependency of your module is itself, and that already is getting initialised, it doesn't need to wait for it
- The
fooModule
variable is created and instantiated to an object with the exported names of the module, which are known to be["logFoo"]
. ThefooModule.logFoo
property becomes a getter that will evaluate to thelogFoo
variable in the module scope (if you had usedexport {A as B}
, thenfooModule.B
would resolve toA
, but in your case both names are the same). - The variable declarations in the module scope create the variables, in your case
logFoo
, and function declarations are initialised (i.e.logFoo
gets assigned the function) - The module code is run (in your case, nothing happens)
Now when you call logFoo
in a module that imports it, fooModule
will refer to the namespace that contains logFoo
. No magic :-)
这篇关于es6模块如何导入?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!