模块化es6规范
阮一峰Module 的语法
1.概述
历史上,JavaScript 一直没有模块(module)体系,无法将一个大程序拆分成互相依赖的小文件,再用简单的方法拼装起来。
在 ES6 之前,社区制定了一些模块加载方案,最主要的有 CommonJS 和 AMD 两种。前者用于服务器,后者用于浏览器。ES6 在语言标准的层面上,实现了模块功能,而且实现得相当简单,完全可以取代 CommonJS 和 AMD 规范,成为浏览器和服务器通用的模块解决方案。
ES6 模块的设计思想是尽量的静态化,使得编译时就能确定模块的依赖关系,以及输入和输出的变量。CommonJS 和 AMD 模块,都只能在运行时确定这些东西。比如,CommonJS 模块就是对象,输入时必须查找对象属性。
- // CommonJS模块
- let { stat, exists, readFile } = require('fs');
- // 等同于
- let _fs = require('fs');
- let stat = _fs.stat;
- let exists = _fs.exists;
- let readfile = _fs.readfile;
上面代码的实质是整体加载fs
模块(即加载fs
的所有方法),生成一个对象(_fs
),然后再从这个对象上面读取 3 个方法。这种加载称为“运行时加载”,因为只有运行时才能得到这个对象,导致完全没办法在编译时做“静态优化”。
ES6 模块不是对象,而是通过export
命令显式指定输出的代码,再通过import
命令输入。
- // ES6模块
- import { stat, exists, readFile } from 'fs';
上面代码的实质是从fs
模块加载 3 个方法,其他方法不加载。这种加载称为“编译时加载”或者静态加载,即 ES6 可以在编译时就完成模块加载,效率要比 CommonJS 模块的加载方式高。当然,这也导致了没法引用 ES6 模块本身,因为它不是对象。
由于 ES6 模块是编译时加载,使得静态分析成为可能。有了它,就能进一步拓宽 JavaScript 的语法,比如引入宏(macro)和类型检验(type system)这些只能靠静态分析实现的功能。
除了静态加载带来的各种好处,ES6 模块还有以下好处。
- 不再需要
UMD
模块格式了,将来服务器和浏览器都会支持 ES6 模块格式。目前,通过各种工具库,其实已经做到了这一点。 - 将来浏览器的新 API 就能用模块格式提供,不再必须做成全局变量或者
navigator
对象的属性。 - 不再需要对象作为命名空间(比如
Math
对象),未来这些功能可以通过模块提供。
2.严格模式
ES6 的模块自动采用严格模式,不管你有没有在模块头部加上"use strict";
。
严格模式主要有以下限制。
- 变量必须声明后再使用
- 函数的参数不能有同名属性,否则报错
- 不能使用
with
语句 - 不能对只读属性赋值,否则报错
- 不能使用前缀 0 表示八进制数,否则报错
- 不能删除不可删除的属性,否则报错
- 不能删除变量
delete prop
,会报错,只能删除属性delete global[prop]
eval
不会在它的外层作用域引入变量eval
和arguments
不能被重新赋值arguments
不会自动反映函数参数的变化- 不能使用
arguments.callee
- 不能使用
arguments.caller
- 禁止
this
指向全局对象 - 不能使用
fn.caller
和fn.arguments
获取函数调用的堆栈 - 增加了保留字(比如
protected
、static
和interface
)
其中,尤其需要注意this
的限制。ES6 模块之中,顶层的this
指向undefined
,即不应该在顶层代码使用this
。
3.export 命令
模块功能主要由两个命令构成:export
和import
。export
命令用于规定模块的对外接口,import
命令用于输入其他模块提供的功能。
一个模块就是一个独立的文件。该文件内部的所有变量,外部无法获取。如果你希望外部能够读取模块内部的某个变量,就必须使用export
关键字输出该变量。下面是一个 JS 文件,里面使用export
命令输出变量。
- // profile.js
- export var firstName = 'Michael';
- export var lastName = 'Jackson';
- export var year = 1958;
上面代码是profile.js
文件,保存了用户信息。ES6 将其视为一个模块,里面用export
命令对外部输出了三个变量。
export
的写法,除了像上面这样,还有另外一种。
- // profile.js
- var firstName = 'Michael';
- var lastName = 'Jackson';
- var year = 1958;
- export { firstName, lastName, year };
上面代码在export
命令后面,使用大括号指定所要输出的一组变量。它与前一种写法(直接放置在var
语句前)是等价的,但是应该优先考虑使用这种写法。因为这样就可以在脚本尾部,一眼看清楚输出了哪些变量。
export
命令除了输出变量,还可以输出函数或类(class)。
- export function multiply(x, y) {
- return x * y;
- };
上面代码对外输出一个函数multiply
。
通常情况下,export
输出的变量就是本来的名字,但是可以使用as
关键字重命名。
- function v1() { ... }
- function v2() { ... }
- export {
- v1 as streamV1,
- v2 as streamV2,
- v2 as streamLatestVersion
- };
上面代码使用as
关键字,重命名了函数v1
和v2
的对外接口。重命名后,v2
可以用不同的名字输出两次(无数次)。
需要特别注意的是,export
命令规定的是对外的接口,必须与模块内部的变量建立一一对应关系。
- // 报错
- export 1;
- // 报错
- var m = 1;
- export m;
上面两种写法都会报错,因为没有提供对外的接口。第一种写法直接输出 1,第二种写法通过变量m
,还是直接输出 1。1
只是一个值,不是接口。正确的写法是下面这样。
- // 写法一
- export var m = 1;
- // 写法二
- var m = 1;
- export {m};
- // 写法三
- var n = 1;
- export {n as m};
上面三种写法都是正确的,规定了对外的接口m
。其他脚本可以通过这个接口,取到值1
。它们的实质是,在接口名与模块内部变量之间,建立了一一对应的关系。
同样的,function
和class
的输出,也必须遵守这样的写法。
- // 报错
- function f() {}
- export f;
- // 正确
- export function f() {};
- // 正确
- function f() {}
- export {f};
另外,export
语句输出的接口,与其对应的值是动态绑定关系,即通过该接口,可以取到模块内部实时的值。
- export var foo = 'bar';
- setTimeout(() => foo = 'baz', 500);
上面代码输出变量foo
,值为bar
,500 毫秒之后变成baz
。
这一点与 CommonJS 规范完全不同。CommonJS 模块输出的是值的缓存,不存在动态更新,详见下文《Module 的加载实现》一节。
最后,export
命令可以出现在模块的任何位置,只要处于模块顶层就可以。如果处于块级作用域内,就会报错,下一节的import
命令也是如此。这是因为处于条件代码块之中,就没法做静态优化了,违背了 ES6 模块的设计初衷。
- function foo() {
- export default 'bar' // SyntaxError
- }
- foo()
上面代码中,export
语句放在函数之中,结果报错。
4.import命令
使用export
命令定义了模块的对外接口以后,其他 JS 文件就可以通过import
命令加载这个模块。
- import { firstName, lastName, year } from './profile.js';
- function setName(element) {
- element.textContent = firstName + ' ' + lastName;
- }
上面代码的import
命令,用于加载profile.js
文件,并从中输入变量。import
命令接受一对大括号,里面指定要从其他模块导入的变量名。大括号里面的变量名,必须与被导入模块(profile.js
)对外接口的名称相同。
如果想为输入的变量重新取一个名字,import
命令要使用as
关键字,将输入的变量重命名。
- import { lastName as surname } from './profile.js';
import
命令输入的变量都是只读的,因为它的本质是输入接口。也就是说,不允许在加载模块的脚本里面,改写接口。
- import {a} from './xxx.js'
- a = {}; // Syntax Error : 'a' is read-only;
上面代码中,脚本加载了变量a
,对其重新赋值就会报错,因为a
是一个只读的接口。但是,如果a
是一个对象,改写a
的属性是允许的。
- import {a} from './xxx.js'
- a.foo = 'hello'; // 合法操作
上面代码中,a
的属性可以成功改写,并且其他模块也可以读到改写后的值。不过,这种写法很难查错,建议凡是输入的变量,都当作完全只读,不要轻易改变它的属性。
import
后面的from
指定模块文件的位置,可以是相对路径,也可以是绝对路径,.js
后缀可以省略。如果只是模块名,不带有路径,那么必须有配置文件,告诉 JavaScript 引擎该模块的位置。
- import {myMethod} from 'util';
上面代码中,util
是模块文件名,由于不带有路径,必须通过配置,告诉引擎怎么取到这个模块。
注意,import
命令具有提升效果,会提升到整个模块的头部,首先执行。
- foo();
- import { foo } from 'my_module';
上面的代码不会报错,因为import
的执行早于foo
的调用。这种行为的本质是,import
命令是编译阶段执行的,在代码运行之前。
由于import
是静态执行,所以不能使用表达式和变量,这些只有在运行时才能得到结果的语法结构。
- // 报错
- import { 'f' + 'oo' } from 'my_module';
- // 报错
- let module = 'my_module';
- import { foo } from module;
- // 报错
- if (x === 1) {
- import { foo } from 'module1';
- } else {
- import { foo } from 'module2';
- }
上面三种写法都会报错,因为它们用到了表达式、变量和if
结构。在静态分析阶段,这些语法都是没法得到值的
最后,import
语句会执行所加载的模块,因此可以有下面的写法。
面代码仅仅执行lodash
模块,但是不输入任何值。
如果多次重复执行同一句import
语句,那么只会执行一次,而不会执行多次。
- import 'lodash';
- import 'lodash';
上面代码加载了两次lodash
,但是只会执行一次
- import { foo } from 'my_module';
- import { bar } from 'my_module';
- // 等同于
- import { foo, bar } from 'my_module';
上面代码中,虽然foo
和bar
在两个语句中加载,但是它们对应的是同一个my_module
实例。也就是说,import
语句是 Singleton 模式。
目前阶段,通过 Babel 转码,CommonJS 模块的require
命令和 ES6 模块的import
命令,可以写在同一个模块里面,但是最好不要这样做。因为import
在静态解析阶段执行,所以它是一个模块之中最早执行的。下面的代码可能不会得到预期结果。
- require('core-js/modules/es6.symbol');
- require('core-js/modules/es6.promise');
- import React from 'React';
5.模块的整体加载
除了指定加载某个输出值,还可以使用整体加载,即用星号(*
)指定一个对象,所有输出值都加载在这个对象上面。
下面是一个circle.js
文件,它输出两个方法area
和circumference
。
- // circle.js
- export function area(radius) {
- return Math.PI * radius * radius;
- }
- export function circumference(radius) {
- return 2 * Math.PI * radius;
- }
现在,加载这个模块。
- // main.js
- import { area, circumference } from './circle';
- console.log('圆面积:' + area(4));
- console.log('圆周长:' + circumference(14));
上面写法是逐一指定要加载的方法,整体加载的写法如下。
- import * as circle from './circle';
- console.log('圆面积:' + circle.area(4));
- console.log('圆周长:' + circle.circumference(14));
注意,模块整体加载所在的那个对象(上例是circle
),应该是可以静态分析的,所以不允许运行时改变。下面的写法都是不允许的。
- import * as circle from './circle';
- // 下面两行都是不允许的
- circle.foo = 'hello';
- circle.area = function () {};
6 export default 命令
下面比较一下默认输出和正常输出
- // 第一组
- export default function crc32() { // 输出
- // ...
- }
- import crc32 from 'crc32'; // 输入
- // 第二组
- export function crc32() { // 输出
- // ...
- };
- import {crc32} from 'crc32'; // 输入
- // 正确
- export var a = 1;
- // 正确
- var a = 1;
- export default a;
- // 错误
- export default var a = 1;
正是因为export default
命令其实只是输出一个叫做default
的变量,所以它后面不能跟变量声明语句。
- // 正确
- export default 42;
- // 报错
- export 42;
面代码中,后一句报错是因为没有指定对外的接口,而前一句指定对外接口为default
。
有了export default
命令,输入模块时就非常直观了,以输入 lodash 模块为例。
如果想在一条import
语句中,同时输入默认方法和其他接口,可以写成下面这样。
- import _, { each, forEach } from 'lodash';
- export default function (obj) {
- // ···
- }
- export function each(obj, iterator, context) {
- // ···
- }
- export { each as forEach };
上面代码的最后一行的意思是,暴露出forEach
接口,默认指向each
接口,即forEach
和each
指向同一个方法。
export default
也可以用来输出类。
- // MyClass.js
- export default class { ... }
- // main.js
- import MyClass from 'MyClass';
- let o = new MyClass();
7.Module 的加载实现
HTML 网页中,浏览器通过<script>
标签加载 JavaScript 脚本
- <!-- 页面内嵌的脚本 -->
- <script type="application/javascript">
- // module code
- </script>
- <!-- 外部脚本 -->
- <script type="application/javascript" src="path/to/myModule.js">
- </script>
上面代码中,由于浏览器脚本的默认语言是 JavaScript,因此type="application/javascript"
可以省略。
默认情况下,浏览器是同步加载 JavaScript 脚本,即渲染引擎遇到<script>
标签就会停下来,等到执行完脚本,再继续向下渲染。如果是外部脚本,还必须加入脚本下载的时间。
如果脚本体积很大,下载和执行的时间就会很长,因此造成浏览器堵塞,用户会感觉到浏览器“卡死”了,没有任何响应。这显然是很不好的体验,所以浏览器允许脚本异步加载,下面就是两种异步加载的语法
- <script src="path/to/myModule.js" defer></script>
- <script src="path/to/myModule.js" async></script>
上面代码中,<script>
标签打开defer
或async
属性,脚本就会异步加载。渲染引擎遇到这一行命令,就会开始下载外部脚本,但不会等它下载和执行,而是直接执行后面的命令。
defer
与async
的区别是:defer
要等到整个页面在内存中正常渲染结束(DOM 结构完全生成,以及其他脚本执行完成),才会执行;async
一旦下载完,渲染引擎就会中断渲染,执行这个脚本以后,再继续渲染。一句话,defer
是“渲染完再执行”,async
是“下载完就执行”。另外,如果有多个defer
脚本,会按照它们在页面出现的顺序加载,而多个async
脚本是不能保证加载顺序的
加载规则
浏览器加载 ES6 模块,也使用<script>
标签,但是要加入type="module"
属性。
- <script type="module" src="./foo.js"></script>
上面代码在网页中插入一个模块foo.js
,由于type
属性设为module
,所以浏览器知道这是一个 ES6 模块。
浏览器对于带有type="module"
的<script>
,都是异步加载,不会造成堵塞浏览器,即等到整个页面渲染完,再执行模块脚本,等同于打开了<script>
标签的defer
属性。
- <script type="module" src="./foo.js"></script>
- <!-- 等同于 -->
- <script type="module" src="./foo.js" defer></script>
如果网页有多个<script type="module">
,它们会按照在页面出现的顺序依次执行。
<script>
标签的async
属性也可以打开,这时只要加载完成,渲染引擎就会中断渲染立即执行。执行完成后,再恢复渲染。
- <script type="module" src="./foo.js" async></script>
一旦使用了async
属性,<script type="module">
就不会按照在页面出现的顺序执行,而是只要该模块加载完成,就执行该模块。
ES6 模块也允许内嵌在网页中,语法行为与加载外部脚本完全一致。
- <script type="module">
- import utils from "./utils.js";
- // other code
- </script>
举例来说,jQuery 就支持模块加载。
- <script type="module">
- import $ from "./jquery/src/jquery.js";
- $('#message').text('Hi from jQuery!');
- </script>
对于外部的模块脚本(上例是foo.js
),有几点需要注意。
- 代码是在模块作用域之中运行,而不是在全局作用域运行。模块内部的顶层变量,外部不可见。
- 模块脚本自动采用严格模式,不管有没有声明
use strict
。 - 模块之中,可以使用
import
命令加载其他模块(.js
后缀不可省略,需要提供绝对 URL 或相对 URL),也可以使用export
命令输出对外接口。 - 模块之中,顶层的
this
关键字返回undefined
,而不是指向window
。也就是说,在模块顶层使用this
关键字,是无意义的。 - 同一个模块如果加载多次,将只执行一次。
下面是一个示例模块。
- import utils from 'https://example.com/js/utils.js';
- const x = 1;
- console.log(x === window.x); //false
- console.log(this === undefined); // tru
利用顶层的this
等于undefined
这个语法点,可以侦测当前代码是否在 ES6 模块之中。
- const isNotModuleScript = this !== undefined;
ES6 模块与 CommonJS 模块的差异
- CommonJS 模块输出的是一个值的拷贝,ES6 模块输出的是值的引用。
- CommonJS 模块是运行时加载,ES6 模块是编译时输出接口。
第二个差异是因为 CommonJS 加载的是一个对象(即module.exports
属性),该对象只有在脚本运行完才会生成。而 ES6 模块不是对象,它的对外接口只是一种静态定义,在代码静态解析阶段就会生成。
ES6 模块的运行机制与 CommonJS 不一样。JS 引擎对脚本静态分析的时候,遇到模块加载命令import
,就会生成一个只读引用。等到脚本真正执行时,再根据这个只读引用,到被加载的那个模块里面去取值。换句话说,ES6 的import
有点像 Unix 系统的“符号连接”,原始值变了,import
加载的值也会跟着变。因此,ES6 模块是动态引用,并且不会缓存值,模块里面的变量绑定其所在的模块。
- // lib.js
- export let counter = 3;
- export function incCounter() {
- counter++;
- }
- // main.js
- import { counter, incCounter } from './lib';
- console.log(counter); //
- incCounter();
- console.log(counter); //
上面代码说明,ES6 模块输入的变量counter
是活的,完全反应其所在模块lib.js
内部的变化。
再举一个出现在export
一节中的例子。
- // m1.js
- export var foo = 'bar';
- setTimeout(() => foo = 'baz', 500);
- // m2.js
- import {foo} from './m1.js';
- console.log(foo);
- setTimeout(() => console.log(foo), 500);
上面代码中,m1.js
的变量foo
,在刚加载时等于bar
,过了 500 毫秒,又变为等于baz
。
让我们看看,m2.js
能否正确读取这个变化。
上面代码表明,ES6 模块不会缓存运行结果,而是动态地去被加载的模块取值,并且变量总是绑定其所在的模块。
由于 ES6 输入的模块变量,只是一个“符号连接”,所以这个变量是只读的,对它进行重新赋值会报错。
- // lib.js
- export let obj = {};
- // main.js
- import { obj } from './lib';
- obj.prop = 123; // OK
- obj = {}; // TypeError
上面代码中,main.js
从lib.js
输入变量obj
,可以对obj
添加属性,但是重新赋值就会报错。因为变量obj
指向的地址是只读的,不能重新赋值,这就好比main.js
创造了一个名为obj
的const
变量。
最后,export
通过接口,输出的是同一个值。不同的脚本加载这个接口,得到的都是同样的实例。
- // mod.js
- function C() {
- this.sum = 0;
- this.add = function () {
- this.sum += 1;
- };
- this.show = function () {
- console.log(this.sum);
- };
- }
- export let c = new C();
上面的脚本mod.js
,输出的是一个C
的实例。不同的脚本加载这个模块,得到的都是同一个实例。
模块化es6规范的更多相关文章
- 1. 模块化的引入与导出 (commonJS规范 和ES6规范)
node组件导出模块 node一般用commonJS规范 可以通过module.exports导出自己写的模块 这样其他的js文件就可以引用并使用这个模块 module.exports = { log ...
- JavaSript模块化-AMD规范与CMD规范
JavaScript模块化 在了解AMD,CMD规范前,先来简单地了解下什么是模块化,模块化开发. 模块化是指在解决某一个复杂问题或者一系列的杂糅问题时,依照一种分类的思维把问题进行系统性的分解以之处 ...
- JavaScript模块化---AMD规范
JavaSript模块化 在了解AMD,CMD规范前,还是需要先来简单地了解下什么是模块化,模块化开发? 模块化是指在解决某一个复杂问题或者一系列的杂糅问题时,依照一种分类的思维把问 题进行系 ...
- javascript模块化编程规范
一.javascript模块化编程规范: 二.关于commenjs规范和AMD规范: 根本不同:前者用于服务器端同步加载模块:后者是客户端异步加载模块. 同点:两者都有一个全局函数require(), ...
- Javascript模块化编程-规范[2]
实现Javascript模块化,固然很重要,但是怎样才能实现国际上都能认可的模块化呢?模块化编程规范随应运而生. 目前Javascript模块化规范主要有两种:CommonJS和AMD. Common ...
- 根据 Promise/A+ 和 ES6 规范,实现 Promise(附详细测试)
Promise 源码 https://github.com/lfp1024/promise promise-a-plus const PENDING = 'PENDING' const REJECTE ...
- js 模块化的规范
The Module Pattern,模块模式,也译为模组模式,是一种通用的对代码进行模块化组织与定义的方式.这里所说的模块(Modules),是指实现某特定功能的一组方法和代码.许多现 ...
- 前端学习(三十五)模块化es6(笔记)
RequireJs:一.安装.下载 官网: requirejs.org Npm: npm i requirejs二.使用 以前的开发方式的问题: 1).js 是阻塞加 ...
- 我也谈 javascript 模块化 -AMD规范
最近,读了很多有关js模块化编程方面的文章,自己也有些小小的理解,不过,还是得借助别人的总结,在这个基础上谈一谈自己的理解吧!参考:http://www.ruanyifeng.com/blog/201 ...
随机推荐
- 解题报告:luogu P1144 最短路计数
题目链接:P1144 最短路计数 很简单的一道\(dfs\),然而我又跑了一遍\(dij\)和排序,时间复杂度是\(O(nlog n)\) 注意:\(1\).搜索时向\(dis[j]=dis[cur] ...
- dstat 监控命令详解
一.工具介绍 dstat的man手册对于该工具的解释: dstat - versatile tool for generating system resource statistics 系统资源多用途 ...
- 嵊州普及Day4T4
题意:求最长上升序列长度和方案数. 思路:经典DP,不需什么别的东西,加一个数组储蓄程序数即可,原题300000可能N2会有问题,但问题不大. 见代码: #include<iostream> ...
- OSX10.10 Yosemite安装Metasploit
安装环境 操作时间: 2015/6/8 操作系统: OSX Yosemite 10.10.3 Metasploit版本: v4.11.0-dev [core:4.11.0.pre.dev api:1. ...
- 使用自己定义的DIV的滚动条
基本思路: 让DIV浮动起来,利用postion:fixed/absolute,设定height:100% var $card=$("#cardDetail"); $ca ...
- APP自动化测试获取包名的两种方法
获取包名的两种方法: 一.通过aapt获取 1.进入aapt.exe所在路径 2.在地址栏输入cmd回车,打开dos命令窗口. 3.在命令窗口输入 aapt dump badging 拖入apk 回车 ...
- YUV图解 (YUV444, YUV422, YUV420, YV12, NV12, NV21)
背景: 最近在研究音视频,了解YUV这样的格式对于音视频开发比较重要. 虽然这篇文章大部分是转载别人的,但是经过了校对以后,重新排版并补充了一部分内容 概览: 之所以提出yuv格式的原因,是为了解 ...
- oracle根据一张表更新另外一张表
知道是两张表进行更新,之前作过mysql的,直接就写了: update a,b set a.code = b.code wehre a.id = b.id 然后就报错了,上网查了下知道oracle不能 ...
- 006.Oracle数据库 , DISTINCT去掉重复项重复内容
/*Oracle数据库查询日期在两者之间*/ SELECT DISTINCT OCCUR_DATE FROM LM_FAULT WHERE ( ( OCCUR_DATE >= to_date( ...
- 数据库连接需要dll
连接oracle引用: Oracle.ManagedDataAccess.dll和Oracle.ManagedDataAccess.EntityFramework.dll, 连接sqlserver 连 ...