3522vip-澳门新葡亰平台官网-www.3522vip.com

3522vip☞(www.rivieraquest.com)能够为大家带来真正的真钱享受,澳门新葡亰平台官网开创业内先河,注册,开户,登录开始体验不同的娱乐世界,全国第一家以娱乐产品为主体对象的专业平台,菲律宾全资子公司成立,天天免费68周周再送168。

3522vip > web前端 > 全面解析ECMAScript 5和ECMAScript 6模块系统

原标题:全面解析ECMAScript 5和ECMAScript 6模块系统

浏览次数:61 时间:2019-12-22

在任何一个大型应用中模块化是很常见的。ES6的模块为JavaScript提供了这个特性,并且为这些模块提供了许多选择方法来导出和引入对象。Ravi Kiran 在《Modules in ECMAScript 6 (ES6)》一文中主要讨论了ES6模块系统。以下为该文章的简译内容:无论使用何种编程语言开发大型应用,最关键的特性就是代码模块化。这个概念在不同的编程语言里有着不同的命名,在C里为头部文件,C 和C#里为命名空间,Java中为包,名称不一样但解决的是同一问题。正如《ECMAScript 6 – New language improvements in JavaScript》系列文章中第一篇所提到的那样,最初JavaScript并不是用来编写大量代码的,比如创建大型框架、App应用等。就在我们因为JavaScript缺少对模块的支持而编写大量代码时,开源开发者提出了一些标准,如CommoneJs模块模型、异步模块定义以及一些库,来实现模块化。在过去几年里,这些库获得了广泛关注,并成功应用到多个企业规模级的应用程序中。ES6为JavaScript带来了模块特性。浏览器实现这一特性还需要一段时间,因为它们必须定义一个方法来动态下载文件。在浏览器支持该特性以前,我们可以使用编译器,如 Traceur、6to5、ES6 Module Loader以及其它可以让ES6模块转换成ES5的转码器。JavaScript模块系统的现状CommonJS模块系统CommonJs是一个由开源开发者组成的团队,主要围绕JavaScript实现一些API及开展研发实践。该团队提出了一个JavaScript模块规范。每个文件都可当作一个模块,并且每个文件可以访问两个对象:require和export。require用来接收字符串,并返回该模块输出的对象。export对象用来导出该模块的方法和变量。require方法返回的就是export对象。模块同步加载。服务器端JavaScript引擎Node.js就是用的这个模块系统。异步模块定义AMD是一个采用异步方式加载依赖模块的模块系统。如果模块在不同文件中,它们将采用XHR进行加载。某一模块将等其所依赖的模块一一加载后才会被执行。AMD模块必须是一个函数,并作为参数传入define函数中。函数的返回值将传输给所有依赖的模块,所获得返回值又将作为参数传给模块方法。Require.js库中实现了AMD。TypeScript模块TypeScript,作为JavaScript的超集,也提供了一个模块系统。当它被编译时,便开始使用JavaScript模块模式。TypeScript模块使用module关键字定义,任何被输出的对象必须使用export关键字定义。import关键字用来将其它模块加载入模块中,并捕捉该模块导出的对象。TypeScript模块是同步加载的。ES6模块系统ES6模块系统启发于上述现有模块系统,它具有以下特性:使用export关键词导出对象。这个关键字可以无限次使用;使用import关键字将其它模块导入某一模块中。它可用来导入任意数量的模块;支持模块的异步加载;为加载模块提供编程支持。接下来让我们通过具体编程方法看看每一个特性。导出对象在现有的模块系统中,每个JavaScript代码文件在ES6中都是一个模块。只有模块中的对象需要被外部调用时,模块才会输出对象,其余则都是模块的私有对象。该处理方式将细节进行封装,仅导出必要的功能。从模块里导出对象,ES6为我们提供了不同方法,见下面的讨论。内联导出ES6模块里的对象可在创建它们的声明中导出。一个模块中可无数次使用export,所有的对象将被一起导出。请看下面的例子:

ECMAScript 5模块系统


export class Employee{ constructor(id, name, dob){ this.id = id; this.name=name; this.dob= dob; } getAge(){ return (new Date()).getYear() - this.dob.getYear(); }}export function getEmployee(id, name, dob){ return new Employee(id, name, dob);}var emp = new Employee(1, "Rina", new Date(1987, 1, 22));

1、CommonJS模块系统(require和export)

CommonJs是一个由开源开发者组成的团队,主要围绕JavaScript实现一些API及开展研发实践。该团队提出了一个JavaScript模块规范。每个文件都可当作一个模块,并且每个文件可以访问两个对象:require和export。require用来接收字符串(模块名),并返回该模块输出的对象。export对象用来导出该模块的方法和变量。require方法返回的就是export对象。模块同步加载。服务器端JavaScript引擎Node.js就是用的这个模块系统。

1. 模块

案例中的模块导出了两个对象: Employee类,getEmployee函数。因对象emp未被导出,所以其仍为模块私有。导出一组对象尽管内联导出很有效,但在大规模模块中,它就很难发挥作用了,因为我们可能无法追踪到模块导出来的对象。在这种情况下,更好的办法是,在模块的末尾单独进行导出声明,以导出该模块中的全部对象。使用单独导出声明重写上一案例中的模块,结果如下:

2、AMD异步模块定义(define)

AMD是一个采用异步方式加载依赖模块的模块系统。如果模块在不同文件中,它们将采用XHR进行加载。某一模块将等其所依赖的模块一一加载后才会被执行。AMD模块必须是一个函数,并作为参数传入define函数中。函数的返回值将传输给所有依赖的模块,所获得返回值又将作为参数传给模块方法。Require.js库中实现了AMD。

模块的特性

  1. ES6的模块自动采用严格模式;
  2. 在ES6模块中,顶层的this的值是undefined,不应该在顶层代码使用this;
  3. export语句输出的接口与其对应的值是动态绑定关系,即通过该接口,可以获取到模块内部实时的值;这一点与CommonJS规范完全不同,CommonJS模块输出的是值的缓存,不存在动态更新;
  4. export 和 import 命令可以并且只能出现在模块顶层的任意位置;如果export 和 import 命令处于块级作用域内,就会报错;这是因为如果export 和 import 命令处于代码块之中,就没法做静态优化了,违背了ES6模块的设计初衷;
  5. 因为:export default命令的本质是:将该命令后面的值,赋给default变量,然后输出一个叫做default的量;
    所以:
    1. 可以直接将一个值写在export default之后;
    2. export default之后不能跟变量声明语句;
  6. import后面的from指定模块文件的位置,可以是相对路径或者绝对路径,.js后缀也可以省略;如果from后面指定的不是路径,只是一个模块名字,那么必须有配置文件能使JavaScript引擎找到该模块的位置;
  7. import命令具有提升效果,会提升到整个模块的顶部,首先执行。这种行为的本质是:import命令是编译阶段执行的,所以它会在所有代码运行之前执行;
  8. 由于import语句是在编译阶段执行,所以import语句中不能包含表达式、变量等只能在运行时才能得到结果的语法结构;
  9. 如果有相同的多条import语句,那么只会执行一次同一条import语句;
  10. 由于 ES6 输入的模块变量,只是一个“符号连接”,所以这个变量是只读的,对它进行重新赋值会报错;
  11. 在 Node 环境中,使用import命令加载 CommonJS 模块,Node 会自动将module.exports属性,当作模块的默认输出,即等同于export default;
  12. 采用require命令加载 ES6 模块时,ES6 模块的所有输出接口,会成为输入对象的属性。
  13. ES6模块与CommonJS模块的区别:
  • CommonJS 模块输出的是一个值的拷贝,ES6 模块输出的是值的引用。
  • CommonJS 模块是运行时加载,ES6 模块是编译时输出接口。
  • ES6 模块之中,顶层的this指向undefined;CommonJS 模块的顶层this指向当前模块。
class Employee{ constructor(id, name, dob){ this.id = id; this.name=name; this.dob= dob; } getAge(){ return (new Date()).getYear() - this.dob.getYear(); }}function getEmployee(id, name, dob){ return new Employee(id, name, dob);}var x = new Employee(1, "Rina", new Date(1987, 1, 22));export {Employee, getEmployee};

3、TypeScript同步加载模块(export module、import)

TypeScript,作为JavaScript的超集,也提供了一个模块系统。当它被编译时,便开始使用JavaScript模块模式。TypeScript模块使用module关键字定义,任何被输出的对象必须使用export关键字定义。import关键字用来将其它模块加载入模块中,并捕捉该模块导出的对象。TypeScript模块是同步加载的。

模块导入和导出的各种写法

在导出时,重命名对象也是可以的。如下例所示,Employee在导出时名字改为了Associate,函数GetEmployee改名为getAssociate。

ES6模块系统

ES6模块系统启发于上述现有模块系统,它具有以下特性:
1、使用export关键词导出对象。这个关键字可以无限次使用;
2、使用import关键字将其它模块导入某一模块中。它可用来导入任意数量的模块;
3、支持模块的异步加载;
4、为加载模块提供编程支持。
接下来让我们通过具体编程方法看看每一个特性。
导出对象
在现有的模块系统中,每个JavaScript代码文件在ES6中都是一个模块。只有模块中的对象需要被外部调用时,模块才会输出对象,其余则都是模块的私有对象。该处理方式将细节进行封装,仅导出必要的功能。
从模块里导出对象,ES6为我们提供了不同方法,见下面的讨论。
内联导出
ES6模块里的对象可在创建它们的声明中导出。一个模块中可无数次使用export,所有的对象将被一起导出。请看下面的例子:
<pre>export class Employee {
constructor(id, name, dob){
this.id = id;
this.name=name;
this.dob= dob;
}
getAge(){
return (new Date()).getYear() - this.dob.getYear();
}
}
export function getEmployee(id, name, dob) {
return new Employee(id, name, dob);
}
var emp = new Employee(1, "Rina", new Date(1994, 9, 15)); </pre>

案例中的模块导出了两个对象: Employee类,getEmployee函数。因对象emp未被导出,所以其仍为模块私有。
导出一组对象
尽管内联导出很有效,但在大规模模块中,它就很难发挥作用了,因为我们可能无法追踪到模块导出来的对象。在这种情况下,更好的办法是,在模块的末尾单独进行导出声明,以导出该模块中的全部对象。
使用单独导出声明重写上一案例中的模块,结果如下:
<pre>class Employee {
constructor(id, name, dob){
this.id = id;
this.name=name;
this.dob= dob;
}
澳门新葡亰平台官网,getAge(){
return (new Date()).getYear() - this.dob.getYear();
}
}
function getEmployee(id, name, dob) {
return new Employee(id, name, dob);
}
var x = new Employee(1, "Rina", new Date(1994, 9, 15));
export {Employee, getEmployee};</pre>
在导出时,重命名对象也是可以的。如下例所示,Employee在导出时名字改为了Associate,函数GetEmployee改名为getAssociate。
<pre>export {
Associate as Employee,
getAssociate as getEmployee
}; </pre>
Default导出
使用关键字default,可将对象标注为default对象导出。default关键字在每一个模块中只能使用一次。它既可以用于内联导出,也可以用于一组对象导出声明中。
下面案例展示了在组导出语句中使用default:
<pre>export default {
Employee,
getEmployee
}; </pre>
导入模块
现有模块可以使用关键字import导入到其它模块。一个模块可以被导入任意数量的模块中。下文展示了导入模块的不同方式。
无对象导入
如果模块包含一些逻辑要执行,且不会导出任何对象,此类对象也可以被导入到另一模块中。如下面案例所示:
<pre>import './module1.js';</pre>
** 导入默认对象**
采用Default导出方式导出对象,该对象在import声明中将直接被分配给某个引用,如下例中的“d”。
<pre>import d from './module1.js'; </pre>
** 导入命名的对象**
正如以上讨论的,一个模块可以导出许多命名对象。如果另一模块想导入这些命名对象,需要在导入声明中一一列出这些对象。举个例子:
<pre>import {Employee, getEmployee} from './module1.js'; </pre>
当然也可在同一个声明中导入默认对象和命名对象。这种情况下,默认对象必须定义一个别名,如下例。
<pre>import {default as d, Employee} from './module1.js'; </pre>

** 导入所有对象**
以上几种情况,只有import声明中列举的对象才会被导入并被使用,而其它对象则无法在导入模块中使用。当然,这就要求用户了解哪些对象可以导出并加以利用。如果模块导出大量对象,另一模块想引入所有导出的对象,就必须使用如下声明:
<pre>import * as allFromModule1 from './module1.js'; </pre>
allFromModule1这一别名将指向所有从module1导出的对象。在导入模块中,它们作为属性可被访问。
可编程式的按需导入
如果想基于某些条件或等某个事件发生后再加载需要的模块,可通过使用加载模块的可编程API(programmatic API)来实现。使用System.import方法,可按程序设定加载模块。这是一个异步的方法,并返回Promise。
该方法的语法示例如下:
<pre>System.import('./module1.js')
.then(function(module1){
//use module1
}, function(e){
//handle error
}); </pre>

如果模块加载成功且将导出的模块成功传递给回调函数,Promise将会通过。如果模块名称有误或由于网络延迟等原因导致模块加载失败,Promise将会失败。
结论
任何一个大型应用中,模块化十分必要。ES6模块为JavaScript提供了该特性,这些模块提供了众多选择来导出和引入对象。我很期待该特性被浏览器支持的那一天,到时我们无需加载任何第三方库即可创建、加载JavaScript模块。目前流行的客户端MVC框架Angular.js在其2.0版本(目前还在开发中)中就使用了ES6的模块化。
让我们开始使用模块系统,从而让我们的代码更具组织和可读性。

导出

有以下几种导出方法:

  1. 导出声明:
    直接在(变量、函数、类型、类型别名、接口)声明前添加export关键字;
    示例如下:

    export const numberRegexp = /^[0-9] $/;
    
    export class ZipCodeValidator implements StringValidator {
        isAcceptable(s: string) {
                return s.length === 5 && numberRegexp.test(s);
        }
    }
    
  2. 导出语句:
    导出语句可以把需要导出的实例一块导出,也可以对导出的部分重新命名;
    示例如下:

    export const numberRegexp = /^[0-9] $/;
    
    class ZipCodeValidator implements StringValidator {
        isAcceptable(s: string) {
                return s.length === 5 && numberRegexp.test(s);
            }
    }
    
    export { ZipCodeValidator,numberRegexp };
    export { ZipCodeValidator as mainValidator };
    
  3. 重新导出:
    我们经常会去扩展其它模块,并且只导出那个模块的部分内容。 重新导出功能并不会在当前模块导入那个模块或定义一个新的局部变量;
    示例如下:

    // 导出原先的类但做了重命名
    export {ZipCodeValidator as RegExpBasedZipCodeValidator} from "./ZipCodeValidator";
    
  4. 默认导出:
    每个模块都可以有一个default导出。 默认导出使用default关键字标记;并且一个模块只能够有一个default导出。 需要使用一种特殊的导入形式来导入default导出。标记为默认导出的实体可以省略名字;
    示例如下:

    export default function (s: string) {
        return s.length === 5 && numberRegexp.test(s);
    }
    
export { Associate as Employee, getAssociate as getEmployee };

导入

模块的导入操作与导出一样简单。 可以使用以下import形式之一来导入其它模块中的导出内容:

  1. 导入一个模块中的某个导出内容,也可对于进行重命名::
    格式如下:

    import { 要导出的内容的名字 } from "模块路径";
    import { 要导出的内容的名字 as 新名字 } from "模块路径";
    

    示例如下:

    import { ZipCodeValidator as ZCV } from "./ZipCodeValidator";
    let myValidator = new ZCV();
    
  2. 将整个模块导入到一个变量,并通过它来访问模块的导出部分:
    格式如下:

    import * as 新名字 from "模块路径";
    

    示例如下:

    import * as validator from "./ZipCodeValidator";
    let myValidator = new validator.ZipCodeValidator();
    
  3. 导出默认的导出项:
    每个模块都可以有一个default导出。 默认导出使用default关键字标记;并且一个模块只能够有一个default导出。
    导出默认的导邮项目的格式如下:

    import 自定义名字 from "模块路径";
    

    示例如下:

    import JQ from "JQuery";
    
    JQ("button.continue").html( "Next Step..." );
    
  4. 具有副作用的导入模块:
    格式如下:

    import "模块路径";
    

    此种导入,相当于把相应模块的代码插入到了本模块;

Default导出使用关键字default,可将对象标注为default对象导出。default关键字在每一个模块中只能使用一次。它既可以用于内联导出,也可以用于一组对象导出声明中。下面案例展示了在组导出语句中使用default:

export = 和 import = require()

CommonJS和AMD都有一个exports对象的概念,它包含了一个模块的所有导出内容。
它们也支持把exports替换为一个自定义对象。 默认导出就好比这样一个功能;然而,它们却并不相互兼容。 TypeScript模块支持export =语法以支持传统的CommonJS和AMD的工作流模型。
export =语法定义一个模块的导出对象。 它可以是类,接口,命名空间,函数或枚举。
若要导入一个使用了export =的模块时,必须使用TypeScript提供的特定语法import module = require("module")。
示例如下:
ZipCodeValidator.ts

let numberRegexp = /^[0-9] $/;
class ZipCodeValidator {
    isAcceptable(s: string) {
            return s.length === 5 && numberRegexp.test(s);
    }
}
export = ZipCodeValidator;

Test.ts

import zip = require("./ZipCodeValidator");

// Some samples to try
let strings = ["Hello", "98052", "101"];

// Validators to use
let validator = new zip();

// Show whether each string passed each validator
strings.forEach(s => {
  console.log(`"${ s }" - ${ validator.isAcceptable(s) ? "matches" : "does not match" }`);
  });

export default { Employee, getEmployee};

2. 别名

格式:

import 新名字 = x.y.z;

这是一种简化命名空间操作的方法是使用import q = x.y.z给常用的对象起一个短的名字。 不要与用来加载模块的import x = require('name')语法弄混了,这里的语法是为指定的符号创建一个别名。 你可以用这种方法为任意标识符创建别名,也包括导入的模块中的对象。
示如如下:

namespace Shapes {
    export namespace Polygons {
            export class Triangle { }
     export class Square { }
    }
}

import polygons = Shapes.Polygons;
let sq = new polygons.Square(); // Same as "new Shapes.Polygons.Square()"

注意:
我们并没有使用require关键字,而是直接使用导入符号的限定名赋值。 这与使用var相似,但它还适用于类型和导入的具有命名空间含义的符号。 重要的是,对于值来讲,import会生成与原始符号不同的引用,所以改变别名的var值并不会影响原始变量的值。


导入模块现有模块可以使用关键字import导入到其它模块。一个模块可以被导入任意数量的模块中。下文展示了导入模块的不同方式。无对象导入如果模块包含一些逻辑要执行,且不会导出任何对象,此类对象也可以被导入到另一模块中。如下面案例所示:

3. 函数语法

  1. 函数类型的表示:

    (参数列表)=>返回值类型
    
  2. 函数的定义:

    function 函数名字(参数列表):返回类型 {
        代码
    }
    
  3. 箭头函数的定义:

    (参数列表):返回类型=>{
        代码
    }
    

import './module1.js';

4. TypeScript语法特性:

  1. TypeScript的类型注释是可选的,可有可无;并且TypeScript编译器具有类型推断功能;
  2. 函数的参数列表中的可选参数必须放在必须参数的后面;
  3. 函数的参数列表中的默认参数值参数不必非得放在必须参数的后面,它可以放在参数列表的任何位置;当默认值参数不是放在必须参数的后面时,用户必须通过给默认值参数传入undefined来使用默认值参数的默认值;当默认参值参数放在必须参数后面时,默认值参数是可选的,在调用函数时,可以省略默认值参数;
  4. 剩余参数必须是数组类型,并且必须放在能数列表中的最后一个;
  5. 在TypeScript里,类的成员默认为public;
  6. 只读属性必须在声明时或构造函数里被初始化;
  7. 使用存取器时,编译器必须设置为输出ECMAScript 5或更高;不支持降级到ECMAScript 3;
  8. 只带有get不带有set的存取器自动被推断为readonly;这在从代码生成.d.ts文件时是有帮助的,因为利用这个属性的用户会看到不允许够改变它的值;

导入默认对象采用Default导出方式导出对象,该对象在import声明中将直接被分配给某个引用,如下例中的“d”。

5. 接口

  1. 当把对象字面量赋值给变量或作为参数传递的时候,该对象字面量不能存在任何“目标类型”(变量类型或者参数类型)不包含的属性时;
  2. 对于函数类型的类型检查来说,函数的参数名不需要与接口里定义的名字相匹配;
import d from './module1.js';

导入命名的对象正如以上讨论的,一个模块可以导出许多命名对象。如果另一模块想导入这些命名对象,需要在导入声明中一一列出这些对象。举个例子:

import {Employee, getEmployee} from './module1.js';

当然也可在同一个声明中导入默认对象和命名对象。这种情况下,默认对象必须定义一个别名,如下例。

import {default as d, Employee} from './module1.js';

导入所有对象以上几种情况,只有import声明中列举的对象才会被导入并被使用,而其它对象则无法在导入模块中使用。当然,这就要求用户了解哪些对象可以导出并加以利用。如果模块导出大量对象,另一模块想引入所有导出的对象,就必须使用如下声明:

import * as allFromModule1 from './module1.js';

allFromModule1这一别名将指向所有从module1导出的对象。在导入模块中,它们作为属性可被访问。可编程式的按需导入如果想基于某些条件或等某个事件发生后再加载需要的模块,可通过使用加载模块的可编程API来实现。使用System.import方法,可按程序设定加载模块。这是一个异步的方法,并返回Promise。该方法的语法示例如下:

System.import('./module1.js') .then(function(module1){ //use module1 }, function(e){ //handle error });

如果模块加载成功且将导出的模块成功传递给回调函数,Promise将会通过。如果模块名称有误或由于网络延迟等原因导致模块加载失败,Promise将会失败。ES6模块使用现状到目前为止,所有浏览器还不能自然支持ES6模块,所以在浏览器加载之前,我们需要使用转译器将代码转换成ES5。直到现在,我一直使用Traceur作为我的转译器,建议大家使用相同的工具将模块代码转化为浏览器可识别的代码。让我们看看编译ES6模块的几种不同的方法。使用Traceur动态编译ES6模块当浏览器加载脚本后,我们可以使用Traceur的客户端库动态编译ES6模块。使用该方法,运行模块无需运行任何命令。我们要做得就是,在页面上加载Traceur库,及添加代码脚本来运行WebPageTranscoder。

script new traceur.WebPageTranscoder(document.location.href).run();/script

现在,我们就可以在script标签内,将类型指定成模块,以此导入任何一个ES6文件。

script type="module" import './modules/import1.js';/script

类型指定为模块的任何脚本标签将被ES6客户端库获取并处理。上面代码块中的导入语句将发送AJAX请求,捕获相应的JavaScript文件,并载入它。如果模块内部引用了另一个模块,单独的AJAX请求将发出,以加载与引用模块相对应的文件。使用Traceur命令编译ES6模块使用Traceur命令可以将ES6模块编译成AMD或者CommonJS模块。这个方法有两大优点。1.模块完成编译,浏览器不必执行额外动作;2.如果应用已经使用ES5及AMD模块系统构建了一半,程序的另一半也可以使用ES6,并被编译为这些模块系统中的任何一个,而不是立即把整个应用编译成ES6。为了使用编译完成的AMD/CommonJs的模块,我们需要包含支持模块系统的库。我个人比较倾向AMD,所以我将在这里介绍一下它。CommonJS模块的步骤和这个差不多。下面这句命令是用来让包含ES6模块的文件夹编译成AMD,并把它们存储在一个单独的文件夹:

traceur --dir modules es5Modules --modules=amd

使用CommonJs,你需要在上面命令中使用commonjs代替modules。在这里,modules指的是包含ES6的文件夹,es5Modules指的是输出目录。如果查看es5Modules文件夹下的任何文件,你将看到该AMD定义块。require.js支持AMD,所以我们可以在HTML页面中,使用script引入require.js,并用data-main属性指明开始文件,就像下面这样:

script src="bower_components/requirejs/require.js" data-main="es5Modules/import2.js"/script

使用Traceur Grunt Task编译ES6模块使用命令编译模块很累而且更容易出错。我们可以使用grunt-traceur自动化编译过程。此时,你需要安装NPM包。

npm intall grunt-traceur –save

Grunt任务所需数据与提供给命令的数据一样。下面是任务的一些配置:

traceur: { options: { modules: "amd" }, custom: { files: [{ expand: true, cwd: 'modules', src: ['*.js'], dest: 'es5Modules' }] }}

现在你可以在控制台里使用下面的命令来运行上面的Grunt任务:

grunt traceur

正如你所看见的那样,它和我们使用命令所产生的效果是一样的。结论任何一个大型应用中,模块化十分必要。ES6模块为JavaScript提供了该特性,这些模块提供了众多选择来导出和引入对象。我很期待该特性被浏览器支持的那一天,到时我们无需加载任何第三方库即可创建、加载JavaScript模块。目前流行的客户端MV*框架Angular.js在其2.0版本中就使用了ES6的模块化。让我们开始使用模块系统,从而让我们的代码更具组织和可读性。原文链接:Modules in ECMAScript 6 (ES6)

本文由3522vip发布于web前端,转载请注明出处:全面解析ECMAScript 5和ECMAScript 6模块系统

关键词: 3522vip

上一篇:W3C首次发布SVG标记、SVG轮廓标准工作草案

下一篇:没有了