ES6基础语法之模块化介绍

ES6 引入了模块化， ES6 的模块化分为导出（export） @与导入（import）两个模块。

ES6模块化特点：

（1）ES6 的模块自动开启严格模式，不管你有没有在模块头部加上 use strict;。

（2） 模块中可以导入和导出各种类型的变量，如函数，对象，字符串，数字，布尔值，类等。

（3） 每个模块都有自己的上下文，每一个模块内声明的变量都是局部变量，不会污染全局作用域。

（4） 每一个模块只加载一次（是单例的）， 若再去加载同目录下同文件，直接从内存中读取。

一、export与import基本使用

export 命令用于导出， import 命令 用于导入：

module1.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "孙悟空";
let sex = "男";
export {name,sex};

test1.js

// import { name,sex } from "../export/module1.js";
// console.log(name); //孙悟空
// console.log(sex);  //男
//或导入部分变量
import { sex } from "../export/module1.js";
console.log(sex);  //男

Demo01.html

<!--
    module1.js:模块代码,通过export暴露变量
    test1.js:导入module1.js提供的变量
    Demo01.html:引入test1.js内容
-->
<script type="module" src="import/test1.js"></script>

二、网页中直接import模块

module1.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "孙悟空";
let sex = "男";
export {name,sex};

HTML:

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>网页中import模块</title>
	</head>
	<body>
		<h1>姓名:<span id="spanName"></span></h1>
		<h1>性别:<span id="spanSex"></span></h1>
	</body>
</html>
<!--
 module1.js:模块代码,通过export暴露变量
 Demo02.html:导入module1.js提供的变量
 -->
<script type="module">
	import {name,sex} from "./export/module1.js";
	document.getElementById("spanName").innerHTML = name;
	document.getElementById("spanSex").innerHTML = sex;
</script>

三、as的使用

（1）as在export中的用法：变量使用别名,隐藏模块内部的变量

module2.js：

let name = "孙悟空";
let sex = "男";
export {name as expName,sex as expSex};

HTML:

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>as在export中的用法</title>
	</head>
	<body>
		<h1>姓名:<span id="spanName"></span></h1>
		<h1>性别:<span id="spanSex"></span></h1>
	</body>
</html>
<!--
 module2.js:模块代码,通过export暴露变量(变量使用别名,隐藏模块内部的变量)
 Demo03.html:导入module2.js提供的变量
 -->
<script type="module">
	import {expName,expSex} from "./export/module2.js";
	document.getElementById("spanName").innerHTML = expName;
	document.getElementById("spanSex").innerHTML = expSex;
</script>

（2）as在import中的用法：导入多个模块的变量,使用as解决命名冲突。

module1.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "孙悟空";
let sex = "男";
export {name,sex};

module3.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "猪八戒";
let sex = "男";
export {name,sex};

HTML:

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>as在import中的用法</title>
	</head>
	<body>
		<h1>姓名:<span id="spanName1"></span></h1>
		<h1>性别:<span id="spanSex1"></span></h1>
		<hr />
		<h1>姓名:<span id="spanName2"></span></h1>
		<h1>性别:<span id="spanSex2"></span></h1>
	</body>
</html>
<!--
 module1.js:模块代码(暴露name,sex)
 module3.js:模块代码(暴露name,sex)
 Demo04.html:导入两个模块的变量,使用as解决命名冲突
 -->
<script type="module">
	import {name as name1,sex as sex1} from "./export/module1.js";
	import {name as name2,sex as sex2} from "./export/module3.js";
	document.getElementById("spanName1").innerHTML = name1;
	document.getElementById("spanSex1").innerHTML = sex1;
	document.getElementById("spanName2").innerHTML = name2;
	document.getElementById("spanSex2").innerHTML = sex2;
</script>

四、导入模块中的函数和类

（1）导入模块中的函数

module4.js

// function Add(...items)
// {
// 	let sum = 0;
// 	for(let item of items)
// 	{
// 		sum += item;
// 	}
// 	return sum;
// }
// export{Add};
//或
export function Add(...items)
{
	let sum = 0;
	for(let item of items)
	{
		sum += item;
	}
	return sum;
};

HTML

<script type="module">
	//导入函数
	import {Add} from './export/module4.js';
	let result = Add(1,2,3,4,5);
	console.log(result); //15
</script>

（2）导入模块中的类：

module4.js

// class Student
// {
// 	constructor(stuno,stuname)
// 	{
// 		this.stuno = stuno;
// 		this.stuname = stuname;
// 	}
// 	sayHi()
// 	{
// 		console.log("大家好,我是"+this.stuname+",我的学号是"+this.stuno);
// 	}
// }
// export {Student};
//或
export class Student
{
	constructor(stuno,stuname)
	{
		this.stuno = stuno;
		this.stuname = stuname;
	}
	sayHi()
	{
		console.log("大家好,我是"+this.stuname+",我的学号是"+this.stuno);
	}
}

HTML

<script type="module">
	//导入类
	import {Student} from './export/module4.js';
	let stu = new Student("001","孙悟空");
	stu.sayHi();
</script>

五、import的特点

module5.js

let name = "孙悟空";
let sex = "男";
let emp = {name:"孙悟空",sex:"男"};
export {name,sex,emp};

HTML

<script type="module">
	//只读特点
	//import {name,sex,emp} from './export/module5.js';
	//(1)普通类型的值不能改变
	// name = "猪八戒"; //报错
	// sex = "男";//报错
	//(2)不能直接改变对象
	//emp = {name:"猪八戒",sex:"男"};
	//(3)可以改变变量的属性值
	// emp.name = "猪八戒";
	// emp.sex = "男";

	//单例特点
	//(1)下面两句import只会执行一次
	//import {name,sex,emp} from './export/module5.js';
	//import {name,sex,emp} from './export/module5.js';
	//(2)下面两句import相当于 import {name,sex} from './export/module5.js';
	// import {name} from './export/module5.js';
	// import {sex} from './export/module5.js';

	//静态特点
	//(1)不支持表达式
	//import {"na"+"me"} from './export/module5.js'; //报错
	//(2)不支持动态导入,以下代码也会报错
	// if(true)
	// 	import {name,sex} from './export/module5.js';
	// else
	// 	import {emp} from './export/module5.js';
</script>

六、模块的整体import加载

module5.js

let name = "孙悟空";
let sex = "男";
let emp = {name:"孙悟空",sex:"男"};
export {name,sex,emp};

HTML

<script type="module">
	//加载module5中所有暴露出来的内容
	import * as test from './export/module5.js';
	console.log(test.name);
	console.log(test.emp.name);
</script>

七、export default命令

使用import命令的时候，用户需要知道所要加载的变量名或函数名，否则无法加载，export default 向外暴露的

成员，可以使用任意变量来接收，解决上述问题。

export default 命令特点:

（1）在一个文件或模块中，export、import 可以有多个，export default 仅有一个。

（2）export default 中的 default 是对应的导出接口变量。

（3）导入导出不需要{}符号。

（4）export default 向外暴露的成员，可以使用任意变量来接收。

（1）export default导出变量

module6.js

//export default导出变量不需要var

//export var a = 10; // 正确

// 正确
var a = 10;
export default a;

// 错误
//export default var a = 10;

HTML

<script type="module">
	//接受默认变量
	import b from './export/module6.js'; //此处可以用任意变量(b)来接受
	console.log(b);
</script>

（2）export default导出函数

module6.js

function Add(...items)
{
	let sum = 0;
	for(let item of items)
	{
		sum += item;
	}
	return sum;
}
//此处Add不需要{}
export default Add

HTML

<script type="module">
	//接受默认函数
	import sum from './export/module6.js'; //此处可以用任意变量(sum)来接受
	let result = sum(1,2,3,4,5);
	console.log(result);
</script>

八、export与import的复合写法

export 与 import 可以在同一模块使用，我们称为复合使用。

（1）复合使用的基本语法

module1.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "孙悟空";
let sex = "男";
export {name,sex};

module7.js

//复合使用的语法
let emp = {name:"猪八戒",sex:"男"};

export { name, sex } from './module1.js';
// //上面的export等于如下：
// // import { name, sex } from './module1.js';
// // export { name, sex };

export {emp}

HTML

<script type="module">
	//导入module7,在module7中导出module1内容
	import {name,sex,emp} from "./export/module7.js";
	console.log(name);
	console.log(emp.name);
</script>

（2）复合写法实现接口改名

module1.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "孙悟空";
let sex = "男";
export {name,sex};

module7.js

//复合写法实现接口改名
let emp = {name:"猪八戒",sex:"男"};
export { name as myname, sex as mysex } from './module1.js';
export {emp}

HTML

<script type="module">
	//导入改名后的变量
	// import {myname,mysex,emp} from "./export/module7.js";
	// console.log(myname);
	// console.log(emp.name);
</script>

（3）转换为默认接口

module1.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "孙悟空";
let sex = "男";
export {name,sex};

module7.js

// 转换为默认接口
let emp = {name:"猪八戒",sex:"男"};
export {name as default,sex} from './module1.js';
export {emp}

HTML

<script type="module">
	//导入修改成默认接口的name,使用abc接收
	import abc from "./export/module7.js";
	import {sex,emp} from "./export/module7.js";
	console.log(abc);
	console.log(emp.name);
</script>

（4）默认接口转换为命名接口

module6.js

function Add(...items)
{
	let sum = 0;
	for(let item of items)
	{
		sum += item;
	}
	return sum;
}
//此处Add不需要{}
export default Add

module7.js

//将默认接口转换为命名接口
export {default as sum} from './module6.js';

HTML

<script type="module">
	//导入默认接口转换成的sum接口
	import {sum} from "./export/module7.js";
	let result = sum(1,2,3,4,5);
	console.log(result);
</script>

（5）导出所有接口

module1.js

// export let name = "孙悟空";
// export let sex = "男";
//或
let name = "孙悟空";
let sex = "男";
export {name,sex};

module7.js

//导出所有
export * from './module1.js'

HTML

<script type="module">
	//接收导出的所有接口
	import {name,sex} from "./export/module7.js";
	console.log(name);
	console.log(sex);
</script>

到此这篇关于ES6基础语法之模块化的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持我们。

赞 (0)

相关推荐

  • ES6新特性：使用export和import实现模块化详解

    ES6新特性：使用export和import实现模块化详解

    在ES6前, 前端就使用RequireJS或者seaJS实现模块化, requireJS是基于AMD规范的模块化库,  而像seaJS是基于CMD规范的模块化库,  两者都是为了为了推广前端模块化的工具, 更多有关AMD和CMD的区别, 后面参考给了几个链接: 现在ES6自带了模块化, 也是JS第一次支持module, 在很久以后 ,我们可以直接作用import和export在浏览器中导入和导出各个模块了, 一个js文件代表一个js模块: 现代浏览器对模块(module)支持程度不同, 目前都是

  • ES6中module模块化开发实例浅析

    本文实例讲述了ES6中module模块化开发.分享给大家供大家参考,具体如下: 多人开发JavaScript时伴随着命名冲突等问题,先后有了模拟块级作用域.命名空间.模块化开发等方法. 之前,模块化开发一直是由第三方库来模拟的,比较知名的有AMD规范和CMD规范. 两个规范分别对应requirejs和seajs. 而现在,ES6提出了自己的模块化统一标准. 一个ES6的模块是一个包含了js代码的文件.ES6里没有所谓的module关键字,一个模块就是一个普通的脚本文件,除了以下两个区别: 1.

  • ES6模块化的import和export用法方法总结

    ES6之前已经出现了js模块加载的方案,最主要的是CommonJS和AMD规范.commonjs主要应用于服务器,实现同步加载,如nodejs.AMD规范应用于浏览器,如requirejs,为异步加载.同时还有CMD规范,为同步加载方案如seaJS. ES6在语言规格的层面上,实现了模块功能,而且实现得相当简单,完全可以取代现有的CommonJS和AMD规范,成为浏览器和服务器通用的模块解决方案. ES6模块主要有两个功能:export和import export用于对外输出本模块(一个文件可以

  • ES6使用export和import实现模块化的方法

    在ES6前, 前端就使用RequireJS或者seaJS实现模块化, requireJS是基于AMD规范的模块化库,  而像seaJS是基于CMD规范的模块化库,  两者都是为了为了推广前端模块化的工具, 更多有关AMD和CMD的区别, 后面参考给了几个链接: 现在ES6自带了模块化, 也是JS第一次支持module, 在很久以后 ,我们可以直接作用import和export在浏览器中导入和导出各个模块了, 一个js文件代表一个js模块: 现代浏览器对模块(module)支持程度不同, 目前都是

  • ES6知识点整理之模块化的应用详解

    本文实例讲述了ES6知识点整理之模块化的应用.分享给大家供大家参考,具体如下: 目前浏览器还不能完全支持模块化,需要引入很多编译环境,下面在nodejs中来模拟ES6中的模块化 nodejs中针对模块化演示的配置 环境的安装:$ npm install --save babel-cli babel-preset-node6 运行:$ ./node_modules/.bin/babel-node.js --presets node6 ./your_script.js 添加.babelrc文件, 编

  • ES6基础语法之模块化介绍

    ES6 引入了模块化, ES6 的模块化分为导出(export) @与导入(import)两个模块. ES6模块化特点: (1)ES6 的模块自动开启严格模式,不管你有没有在模块头部加上 use strict;. (2) 模块中可以导入和导出各种类型的变量,如函数,对象,字符串,数字,布尔值,类等. (3) 每个模块都有自己的上下文,每一个模块内声明的变量都是局部变量,不会污染全局作用域. (4) 每一个模块只加载一次(是单例的), 若再去加载同目录下同文件,直接从内存中读取. 一.export

  • ES6基础语法之函数介绍

    一.函数参数的扩展 ES6支持参数的默认值: function fn(name,age,sex="男") { console.log(`大家好,我是${name},性别${sex},今年${age}岁!`); } fn("刘德华",45); //大家好,我是刘德华,性别男,今年45岁! 传递undefined,取默认值: function fn(name,sex="男",age) { console.log(`大家好,我是${name},性别${

  • ES6基础语法之class类介绍

    一.class基本语法 JavaScript 语言中,编写一个学生类,代码如下:(prototype可以个对象添加属性和方法) function Student(stuno,stuname) { this.stuno = stuno; this.stuname = stuname; } Student.prototype.stusex = ""; Student.prototype.sayHi = function() { console.log("大家好,我是"+

  • ES6基础语法之Map和Set对象

    一.Map对象 Map 对象保存键值对.任何值(对象或者原始值) 都可以作为一个键或一个值. Map中的键值是有序的. let myMap = new Map(); myMap.set("23","乔丹"); myMap.set("33","皮蓬"); let name = myMap.get("33"); console.log(name); //皮蓬 let has = myMap.has("

  • ES6基础语法之数组拓展

    一.Array.of() 将参数中所有值作为元素形成数组: console.log(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4] 参数的值可以为不同的类型: console.log(Array.of(1, '2', true)); // [1, '2', true] 参数为空时返回空数组: console.log(Array.of()); // [] 注意: let arr1 = new Array(10); //是一个长度为10的空数组 let arr2 = A

  • ES6基础语法之字符串扩展

    一.字符串的遍历 JS中遍历字符串: var str = "hello,world"; for(var i = 0;i<str.length;i++) { console.log(str[i]); } ES6扩展的遍历字符串方法: let str = "hello,world"; for(let c of str) { console.log(c); } 二.字符串识别.重复.补全 字符串识别: ES6 之前判断字符串是否包含子串,用 indexOf 方法,E

  • ES6基础语法之对象用法

    一.对象和属性和方法 JavaScript中对象: var person={name:"Jack",age:20}; 或: var name = "jack"; var age = 20; var person = {name:name,age:age}; console.log(person.age); //20 ES6中的简洁表示: let [name,age]=["jack",20]; let person = {name,age}; //

  • JavaScript基础语法与数据类型介绍

    JavaScript基础语法与数据类型介绍

    目录 一.JavaScript语法 1.区分大小写 2.标识符 3.注释 4.变量 二.JavaScript的数据类型 1.Undefined类型 2.Null类型 3.Boolean类型 4.Number 5.String类型 6.Object类型 三.typeof操作符 一.JavaScript语法 1.区分大小写 ECMAScript中的一切,包括变量.函数名和操作符都是区分大小写的.例如:text和Text表示两种不同的变量. 2.标识符 所谓标识符,就是指变量.函数.属性的名字,或者函

  • Scala函数式编程专题--scala基础语法介绍

    上次我们介绍了函数式编程的好处,并使用scala写了一个小小的例子帮助大家理解,从这里开始我将真正开始介绍scala编程的一些内容. 这里会先重点介绍scala的一些语法.当然,这里是假设你有一些java或者python的基础,毕竟大部分人不会将scala当作第一门学习编程的语言. 不过这些语法知识记不住也没关系,本身语法这种东西就应该在使用中被记住.这里写这篇的目的也只是梳理一遍,方便大家对语法有个初步的印象,后面可以随时查询. PS:所使用的版本是scala 2.11.8,那我们开始吧 一.

  • Kotlin 基础语法详细介绍

    Kotlin 基础语法详细介绍 基础语法 定义包名 包名的定义应当在源文件的头部 package my.demo import java.util.* // ... 文件路径和包名并不要求匹配,源文件可以被放置在文件系统任意位置 参考:包 定义函数 函数有两个Int类型参数和Int类型返回值: fun sum(a: Int, b: Int): Int { return a + b } 函数体中只有一个表达式并且作为函数的返回值: fun sum(a: Int, b: Int) = a + b 函

随机推荐