手机作网站服务器,dw 做静态网站,收银会员卡管理系统,东莞凤岗镇Node.js 的基础教学 之 exports 和 module.exports#xff1a;https://zhuanlan.zhihu.com/p/82057593
浅谈 JavaScript、ES5、ES6#xff1a;https://www.cnblogs.com/lovesong/p/4908871.html 1、为什么有模块概念 理想情况下#xff0c;开发者只需要实现核心的业务逻辑https://zhuanlan.zhihu.com/p/82057593
浅谈 JavaScript、ES5、ES6https://www.cnblogs.com/lovesong/p/4908871.html 1、为什么有模块概念 理想情况下开发者只需要实现核心的业务逻辑其他都可以加载别人已经写好的模块。
但是Javascript 不是一种模块化编程语言在es6以前它是不支持 类(class)所以也就没有 模块(module)了。 2、require 时代 Javascript 社区做了很多努力在现有的运行环境中实现 模块 的效果。 原始写法
模块就是实现特定功能的一组方法。只要把不同的函数以及记录状态的变量简单地放在一起就算是一个模块。
function m1(){//...
}
function m2(){//...
}
上面的函数 m1() 和 m2()组成一个模块。使用的时候直接调用就行了。
这种做法的缺点很明显污染 了全局变量无法保证不与其他模块发生变量名冲突而且模块成员之间看不出直接关系。 对象写法
为了解决上面的缺点可以把模块写成一个对象所有的模块成员都放到这个对象里面
var module1 new Object({_count: 0,m1: function () {//...},m2: function () {//...}
});
上面的函数 m1() 和 m2(都封装在 module1 对象里。使用的时候就是调用这个对象的属性module1.m1();
这样的写法会暴露所有模块成员内部状态可以被外部改写。比如外部代码可以直接改变内部计数器的值module1._ count 1; 立即执行函数写法
使用 立即执行函数Immediately-Invoked Function ExpressionIIFE可以达到不暴露私有成员的目的
var module (function () {var _count 0;var m1 function () {alert(_count)}var m2 function () {alert(_count 1)}return {m1: m1,m2: m2}
})()
使用上面的写法外部代码无法读取内部的 _count 变量console.info(module._count); // undefined
module 就是 Javascript 模块的基本写法。 nodejs 模块机制
Nodejs 的模块机制 及 require 用法https://www.cnblogs.com/typttxs/p/12196649.html
Nodejs 中提供了 exports 和 require 两个对象
exports 是 模块公开的接口。require 用于 从外部获取一个模块的接口即 获取模块的 exports 对象。
有关 exports 和 module.exports 的区别
正常对外暴露 属性或者方法使用 exports如需要暴露 对象类似class包含了很多属性和方法就使用 module.exports
具体可以参考 --- Node.js 模块系统https://www.runoob.com/nodejs/nodejs-module-system.html
hello.js
exports.world function() {console.log(Hello World);
}
main.js代码 require 引入了当前目录下的 hello.js 文件使用了模块 exports 出来的对象或者方法
var hello require(./hello);
hello.world(); hello.js 中通过 exports 对象将 world 作为模块的访问接口在 main.js 内通过 require 加载这个模块然后就可以直接访问 hello.js 里的 exports 对象的成员函数了。 修改 hello.js 和 main.js
//hello.js
function Hello() { var name; this.setName function(thyName) { name thyName; }; this.sayHello function() { console.log(Hello name); };
};
module.exports Hello;
直接获取对象
//main.js
var Hello require(./hello);
hello new Hello();
hello.setName(BYVoid);
hello.sayHello();
模块接口的唯一变化是使用 module.exports Hello 代替了exports.world function(){}。
在外部引用该模块时其接口对象就是要输出的 Hello 对象本身而不是原先的 exports。 exports 可以理解为 module.exports 的一个 快捷方式。。。 require 查找机制
Node.js 的 require 方法中的文件查找策略如下 从文件模块缓存中加载
尽管原生模块与文件模块的优先级不同但是都会优先从文件模块的缓存中加载已经存在的模块。
从原生模块加载
原生模块的优先级仅次于文件模块缓存的优先级。require 方法在解析文件名之后优先检查模块是否在原生模块列表中。以http模块为例尽管在目录下存在一个 http/http.js/http.node/http.json 文件require(http) 都不会从这些文件中加载而是从原生模块中加载。
原生模块也有一个缓存区同样也是优先从缓存区加载。如果缓存区没有被加载过则调用原生模块的加载方式进行加载和执行。
从文件加载
当文件模块缓存中不存在而且不是原生模块的时候Node.js 会解析 require 方法传入的参数并从文件系统中加载实际的文件加载过程中的包装和编译细节在前一节中已经介绍过这里我们将详细描述查找文件模块的过程其中也有一些细节值得知晓。
require方法接受以下几种参数的传递
http、fs、path等原生模块。./mod或../mod相对路径的文件模块。/pathtomodule/mod绝对路径的文件模块。mod非原生模块的文件模块。
下面是一个完整的在路径 Y 下执行 require(X) 语句执行顺序
1. 如果 X 是内置模块a. 返回内置模块b. 停止执行
2. 如果 X 以 / 开头a. 设置 Y 为文件根路径
3. 如果 X 以 ./ 或 / or ../ 开头a. LOAD_AS_FILE(Y X)b. LOAD_AS_DIRECTORY(Y X)
4. LOAD_NODE_MODULES(X, dirname(Y))
5. 抛出异常 not foundLOAD_AS_FILE(X)
1. 如果 X 是一个文件, 将 X 作为 JavaScript 文本载入并停止执行。
2. 如果 X.js 是一个文件, 将 X.js 作为 JavaScript 文本载入并停止执行。
3. 如果 X.json 是一个文件, 解析 X.json 为 JavaScript 对象并停止执行。
4. 如果 X.node 是一个文件, 将 X.node 作为二进制插件载入并停止执行。LOAD_INDEX(X)
1. 如果 X/index.js 是一个文件, 将 X/index.js 作为 JavaScript 文本载入并停止执行。
2. 如果 X/index.json 是一个文件, 解析 X/index.json 为 JavaScript 对象并停止执行。
3. 如果 X/index.node 是一个文件, 将 X/index.node 作为二进制插件载入并停止执行。LOAD_AS_DIRECTORY(X)
1. 如果 X/package.json 是一个文件,a. 解析 X/package.json, 并查找 main 字段。b. let M X (json main 字段)c. LOAD_AS_FILE(M)d. LOAD_INDEX(M)
2. LOAD_INDEX(X)LOAD_NODE_MODULES(X, START)
1. let DIRSNODE_MODULES_PATHS(START)
2. for each DIR in DIRS:a. LOAD_AS_FILE(DIR/X)b. LOAD_AS_DIRECTORY(DIR/X)NODE_MODULES_PATHS(START)
1. let PARTS path split(START)
2. let I count of PARTS - 1
3. let DIRS []
4. while I 0,a. if PARTS[I] node_modules CONTINUEb. DIR path join(PARTS[0 .. I] node_modules)c. DIRS DIRS DIRd. let I I - 1
5. return DIRS 3、主流模块规范 在es6以前还没有提出一套官方的规范从社区和框架推广程度而言目前通行的 javascript 模块规范有两种CommonJS 和 AMD CommonJS 规范 2009年美国程序员Ryan Dahl创造了node.js 项目将 javascript 语言用于服务器端编程。
这标志 Javascript模块化编程 正式诞生。前端的复杂程度有限没有模块也是可以的但是在服务器端一定要有模块与操作系统和其他应用程序互动否则根本没法编程。
node 编程中最重要的思想之一就是模块而正是这个思想让JavaScript的大规模工程成为可能。模块化编程在js界流行也是基于此随后在浏览器端requirejs 和 seajs 之类的工具包也出现了可以说在对应规范下require 统治了ES6之前的所有模块化编程即使现在在 ES6 module 被完全实现之前还是这样。 在 CommonJS 中 暴露模块使用 module.exports 和 exports 。 exports 可以理解为 module.exports 的一个 快捷方式 很多人不明白暴露对象为什么会有两个后面会介绍区别
在 CommonJS 中有一个全局性方法 require()用于加载模块。假定有一个数学模块 math.js就可以像下面这样加载。
var math require(math);
然后就可以调用模块提供的方法
var math require(math);
math.add( 2,3); // 5
正是由于 CommonJS 使用的 require 方式的推动才有了后面的 AMD、CMD 也采用的 require 方式来引用模块的风格 AMD 规范 有了服务器端模块以后很自然地大家就想要客户端模块。而且最好两者能够兼容一个模块不用修改在服务器和浏览器都可以运行。
但是由于一个重大的局限使得 CommonJS 规范不适用于浏览器环境。还是上面的代码如果在浏览器中运行会有一个很大的问题
var math require(math);
math.add( 2,3); // 5
第二行 math.add(2, 3)在第一行 require(‘math’) 之后运行因此必须等 math.js 加载完成。也就是说如果加载时间很长整个应用就会停在那里等。 这对服务器端不是一个问题因为所有的模块都存放在本地硬盘可以同步加载完成等待时间就是硬盘的读取时间。但是对于浏览器这却是一个大问题因为模块都放在服务器端等待时间取决于网速的快慢可能要等很长时间浏览器处于”假死”状态。因此浏览器端的模块不能采用 同步加载synchronous只能采用 异步加载asynchronous。这就是AMD规范诞生的背景。 AMD是 Asynchronous Module Definition 的缩写意思就是 异步模块定义。它采用异步方式加载模块模块的加载不影响它后面语句的运行。所有依赖这个模块的语句都定义在一个回调函数中等到加载完成之后这个回调函数才会运行。 模块必须采用特定的 define() 函数来定义。用法define(id?, dependencies?, factory)
id字符串模块名称 (可选)dependencies 是我们要载入的依赖模块(可选)使用相对路径。,注意是数组格式factory 工厂方法返回一个模块函数
如果一个模块不依赖其他模块那么可以直接定义在 define() 函数之中。示例
// math.js
define(function () {var add function (x, y) {return x y;};return {add: add};
});
如果这个模块还依赖其他模块那么 define() 函数的第一个参数必须是一个数组指明该模块的依赖性。
define([Lib], function (Lib) {function foo() {Lib.doSomething();}return {foo: foo};
});
上面代码中当 require() 函数加载上面这个模块的时候就会先加载 Lib.js 文件。
AMD 也采用 require() 语句加载模块但是不同于 CommonJS它要求两个参数require([module], callback);
第一个参数 [module]是一个数组里面的成员就是要加载的模块第二个参数 callback则是加载成功之后的回调函数。
如果将前面的代码改写成AMD形式就是下面这样
require([math], function (math) {math.add(2, 3);
});
math.add() 与 math 模块加载不是同步的浏览器不会发生假死。所以很显然AMD 比较适合浏览器环境。
目前主要有两个 Javascript 库实现了AMD规范require.js 和 curl.js。 CMD 规范 CMD (Common Module Definition) 是 seajs 推崇的规范CMD 则是依赖就近用的时候再 require。它写起来是这样的
define(function (require, exports, module) {var clock require(clock);clock.start();
});
CMD 与 AMD一样也是采用特定的 define() 函数来定义用 require 方式来引用模块define(id?, dependencies?, factory)
id字符串模块名称(可选)dependencies 是我们要载入的依赖模块(可选)使用相对路径。注意是数组格式factory 工厂方法返回一个模块函数
define(hello, [jquery], function (require, exports, module) {// 模块代码
});
如果一个模块不依赖其他模块那么可以直接定义在 define() 函数之中。
define(function (require, exports, module) {// 模块代码
}); 注意带 id 和 dependencies 参数的 define 用法不属于 CMD 规范而属于 Modules/Transport 规范。 CMD 与 AMD 区别
AMD 和 CMD 最大的区别是对依赖模块的执行时机处理不同而不是加载的时机或者方式不同二者皆为异步加载模块。
AMD 依赖前置js可以方便知道依赖模块是谁立即加载CMD就近依赖需要使用把模块变为字符串解析一遍才知道依赖了那些模块这也是很多人诟病CMD的一点牺牲性能来带来开发的便利性实际上解析模块用的时间短到可以忽略。4、现阶段的标准 ES6 标准发布后module 成为标准标准使用是以 export 指令导出接口以 import 引入模块但是在我们一贯的 node 模块中我们依然采用的是 CommonJS 规范使用 require 引入模块使用 module.exports 导出接口。export 导出模块
export 语法声明用于导出函数、对象、指定文件或模块的原始值。 注意 在 node 中使用的是 exports 不是 export。不要混淆了ES6 标准发布后module 成为标准标准使用是以 export 导出接口以 import 引入模块export 有两种模块导出方式
命名式导出名称导出命名式导出每个模块可以多个默认导出定义式导出默认导出每个模块仅一个。
export { name1, name2, …, nameN };
export { variable1 as name1, variable2 as name2, …, nameN };
export let name1, name2, …, nameN; // also var
export let name1 …, name2 …, …, nameN; // also var, constexport default expression;
export default function (…) { … } // also class, function*
export default function name1(…) { … } // also class, function*
export { name1 as default, … };export * from …;
export { name1, name2, …, nameN } from …;
export { import1 as name1, import2 as name2, …, nameN } from …;
name1… nameN导出的“标识符”。导出后可以通过这个“标识符”在另一个模块中使用import引用default设置模块的默认导出。设置后import不通过“标识符”而直接引用默认导入继承模块并导出继承模块所有的方法和属性as重命名导出“标识符”from从已经存在的模块、脚本文件…导出命名式导出
模块可以通过 export 前缀关键词声明导出对象导出对象可以是多个。这些导出对象用名称进行区分称之为命名式导出。
export { myFunction }; // 导出一个已定义的函数
export const foo Math.sqrt(2); // 导出一个常量
还可以使用 * 和 from 关键字来实现的模块的继承
export * from article;
模块导出时可以指定模块的导出成员。导出成员可以认为是类中的公有对象而非导出成员可以认为是类中的私有对象
var name IT笔录;
var domain http://itbilu.com;export {name, domain}; // 相当于导出 {name:name,domain:domain}
模块导出时我们可以使用 as 关键字对导出成员进行重命名
var name IT笔录;
var domain http://itbilu.com;export {name as siteName, domain};
注意下面的语法有严重错误的情况
// 错误演示
export 1; // 绝对不可以var a 100;
export a;
export 在导出接口的时候必须与模块内部的变量具有一一对应的关系。直接导出1没有任何意义也不可能在 import 的时候有一个变量与之对应
export a 虽然看上去成立但是 a 的值是一个数字根本无法完成解构因此必须写成 export {a} 的形式。即使 a 被赋值为一个function也是不允许的。而且大部分风格都建议模块中最好在末尾用一个 export 导出所有的接口例如
export { fun as default,a,b,c}; 默认导出
默认导出也被称做定义式导出。命名式导出可以导出多个值但在在 import 引用时也要使用相同的名称来引用相应的值。而默认导出每个导出只有一个单一值这个输出可以是一个函数、类或其它类型的值这样在模块 import 导入时也会很容易引用。
export default function() {}; // 可以导出一个函数
export default class(){}; // 也可以出一个类 命名式导出 与 默认导出
默认导出可以理解为另一种形式的命名导出默认导出可以认为是使用了 default 名称的命名导出。
下面两种导出方式是等价的
const D 123;export default D;
export { D as default }; export 使用示例
使用名称导出一个模块时
// my-module.js 模块
export function cube(x) {return x * x * x;
}const foo Math.PI Math.SQRT2;
export {foo};
在另一个模块脚本文件中我们可以像下面这样引用
import {cube, foo} from my-module;console.log(cube(3)); // 27
console.log(foo); // 4.555806215962888
使用默认导出一个模块时
// my-module.js模块
export default function (x) {return x * x * x;
}
在另一个模块脚本文件中我们可以像下面这样引用相对名称导出来说使用更为简单
// 引用 my-module.js模块
import cube from my-module;console.log(cube(3)); // 27 5、浅谈 JavaScript、ES5、ES6 什么是 JavaScript
JavaScript一种 动态类型、弱类型、基于原型 的客户端脚本语言用来给HTML网页增加动态功能。
动态在运行时确定数据类型。变量使用之前不需要类型声明通常变量的类型是被赋值的那个值的类型。弱类型计算时可以不同类型之间对使用者透明地隐式转换即使类型不正确也能通过隐式转换来得到正确的类型。原型新对象继承对象作为模版将自身的属性共享给新对象模版对象称为原型。这样新对象实例化后不但可以享有自己创建时和运行时定义的属性而且可以享有原型对象的属性。
PS新对象指函数模版对象是实例对象实例对象是不能继承原型的函数才可以的。
JavaScript 是基于原型的客户端脚本语言用来给 HTML 网页增加动态功能。JavaScript 由三部分组成
ECMAScript核心它规定了语言的组成部分语法、类型、语句、关键字、保留字、操作符、对象DOM文档对象模型DOM 把整个页面映射为一个多层节点结果开发人员可借助 DOM提供的 API轻松地删除、添加、替换或修改任何节点。BOM浏览器对象模型支持可以访问和操作浏览器窗口的浏览器对象模型开发人员可以控制浏览器显示的页面以外的部分。
ES 全称就是 ECMAScript作为 JavaScript 语言的核心规定了语言的组成部分语法、类型、语句、关键字、保留字、操作符、对象。 什么是 ES5
作为 ECMAScript第五个版本第四版因为过于复杂废弃了浏览器支持情况可看第一副图增加特性如下。
1. strict模式。严格模式限制一些用法use strict;2. Array 增加方法。增加了every、some 、forEach、filter 、indexOf、lastIndexOf、isArray、map、reduce、reduceRight 方法。 PS 还有其他方法 Function.prototype.bind、String.prototype.trim、Date.now 3. Object 方法。 Object.getPrototypeOf Object.create Object.getOwnPropertyNames Object.defineProperty Object.getOwnPropertyDescriptor Object.defineProperties Object.keys Object.preventExtensions / Object.isExtensible Object.seal / Object.isSealed Object.freeze / Object.isFrozen什么是 ES6
ECMAScript6 在保证向下兼容的前提下提供大量新特性。 ES6 特性如下
1. 块级作用域 关键字 let常量 const
2. 对象字面量的属性赋值简写property value shorthand
var obj {// __proto____proto__: theProtoObj,// Shorthand for ‘handler: handler’handler,// Method definitionstoString() {// Super callsreturn d super.toString();},// Computed (dynamic) property names[ prop_ (() 42)() ]: 42
};
3. 赋值解构
let singer { first: Bob, last: Dylan };
let { first: f, last: l } singer; // 相当于 f Bob, l Dylan
let [all, year, month, day] /^(\d\d\d\d)-(\d\d)-(\d\d)$/.exec(2015-10-25);
let [x, y] [1, 2, 3]; // x 1, y 2
4. 函数参数 ( 默认值、参数打包、 数组展开Default 、Rest 、Spread )
//Default
function findArtist(namelu, age26) {...
}//Rest
function f(x, ...y) {// y is an Arrayreturn x * y.length;
}
f(3, hello, true) 6//Spread
function f(x, y, z) {return x y z;
}
// Pass each elem of array as argument
f(...[1,2,3]) 6
5. 箭头函数 Arrow functions
(1). 简化了代码形式默认 return 表达式结果。(2). 自动绑定语义 this即定义函数时的 this。如上面例子中forEach 的匿名函数参数中用到的 this。
6. 字符串模板 Template strings
var name Bob, time today;
Hello ${name}, how are you ${time}?
// return Hello Bob, how are you today?
7. Iterators迭代器 for..of
迭代器有个 next 方法调用会返回
(1). 返回迭代对象的一个元素{ done: false, value: elem }(2). 如果已到迭代对象的末端{ done: true, value: retVal }
for (var n of [a,b,c]) {console.log(n);
}
// 打印a、b、c
8. 生成器 Generators
9. Class
Class有 constructor、extends、super但本质上是语法糖对语言的功能并没有影响但是更方便程序员使用。
class Artist {constructor(name) {this.name name;}perform() {return this.name performs ;}
}class Singer extends Artist {constructor(name, song) {super.constructor(name);this.song song;}perform() {return super.perform() [ this.song ];}
}let james new Singer(Etta James, At last);
james instanceof Artist; // true
james instanceof Singer; // truejames.perform(); // Etta James performs [At last]
10. Modules
ES6的内置模块功能借鉴了CommonJS和AMD各自的优点
(1). 具有 CommonJS 的精简语法、唯一导出出口 (single exports) 和 循环依赖 (cyclic dependencies) 的特点。(2). 类似 AMD支持异步加载和可配置的模块加载。
// lib/math.js
export function sum(x, y) {return x y;
}
export var pi 3.141593;// app.js
import * as math from lib/math;
alert(2π math.sum(math.pi, math.pi));// otherApp.js
import {sum, pi} from lib/math;
alert(2π sum(pi, pi));Module Loaders:
// Dynamic loading – ‘System’ is default loader
System.import(lib/math).then(function(m) {alert(2π m.sum(m.pi, m.pi));
});// Directly manipulate module cache
System.get(jquery);
System.set(jquery, Module({$: $})); // WARNING: not yet finalized
11. Map Set WeakMap WeakSet
四种集合类型WeakMap、WeakSet 作为属性键的对象如果没有别的变量在引用它们则会被回收释放掉。
// Sets
var s new Set();
s.add(hello).add(goodbye).add(hello);
s.size 2;
s.has(hello) true;// Maps
var m new Map();
m.set(hello, 42);
m.set(s, 34);
m.get(s) 34;//WeakMap
var wm new WeakMap();
wm.set(s, { extra: 42 });
wm.size undefined// Weak Sets
var ws new WeakSet();
ws.add({ data: 42 });//Because the added object has no other references, it will not be held in the set
12. Math Number String Array Object APIs
一些新的 API
Number.EPSILON
Number.isInteger(Infinity) // false
Number.isNaN(NaN) // falseMath.acosh(3) // 1.762747174039086
Math.hypot(3, 4) // 5
Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2abcde.includes(cd) // true
abc.repeat(3) // abcabcabcArray.from(document.querySelectorAll(*)) // Returns a real Array
Array.of(1, 2, 3) // Similar to new Array(...), but without special one-arg behavior[0, 0, 0].fill(7, 1) // [0,7,7]
[1, 2, 3].find(x x 3) // 3
[1, 2, 3].findIndex(x x 2) // 1
[1, 2, 3, 4, 5].copyWithin(3, 0) // [1, 2, 3, 1, 2]
[a, b, c].entries() // iterator [0, a], [1,b], [2,c]
[a, b, c].keys() // iterator 0, 1, 2
[a, b, c].values() // iterator a, b, cObject.assign(Point, { origin: new Point(0,0) })
13. Proxies
使用代理Proxy监听对象的操作然后可以做一些相应事情。
var target {};
var handler {get: function (receiver, name) {return Hello, ${name}!;}
};var p new Proxy(target, handler);
p.world Hello, world!;
可监听的操作 get、set、has、deleteProperty、apply、construct、getOwnPropertyDescriptor、defineProperty、getPrototypeOf、setPrototypeOf、enumerate、ownKeys、preventExtensions、isExtensible。
14. Symbols
Symbol 是一种基本类型。Symbol 通过调用symbol函数产生它接收一个可选的名字参数该函数返回的 symbol 是唯一的。
var key Symbol(key);
var key2 Symbol(key);
key key2 //false
15. Promises
Promises 是处理异步操作的对象使用了 Promise 对象之后可以用一种链式调用的方式来组织代码让代码更加直观类似 jQuery 的 deferred 对象。
function fakeAjax(url) {return new Promise(function (resolve, reject) {// setTimeouts are for effect, typically we would handle XHRif (!url) {return setTimeout(reject, 1000);}return setTimeout(resolve, 1000);});
}// no url, promise rejected
fakeAjax().then(function () {console.log(success);
},function () {console.log(fail);
}); ES5 和 ES6 区别
初学者在 ES6 和 ES5 之间的取舍https://www.zhihu.com/question/30608934
1. es5 使用 require 导包es6 使用 import from
ES5 中的引用需要先使用 require 导入包成为对象再去进行真正引用
// ES5
var React require(react);
var { Component,PropTypes } React; //引用React抽象组件var ReactNative require(react-native);
var { Image,Text } ReactNative; //引用具体的React Native组件
在 ES6 里可以使用 import 直接实现系统库引用不需要额外制作一个类库对象
//ES6
import { Component,PropTypes } from react;
import { Image,Text } from react-native2. 导出及引用单个类
ES5 中要导出一个类给别的模块使用一般通过 module.exports 来实现引用时通过 require方法来获取
//ES5导出
var MyComponent React.createClass({...
});
module.exports MyComponent;//ES5导入
var MyComponent require(./MyComponent);ES6 中使用 export default 实现同样的功能但要使用 import 方法来实现导入
//ES6导出(一般都继承于Component类)
export default class MyComponent extends Component{...
}//ES6导入
import MyComponent from ./MyComponent; 3. ES5 和 ES6 继承的区别
// ES5的继承
function FatherClass(name) {this.family [father, mother, daughter];this.name name
};
FatherClass.prototype.getName function () {console.log(this.name);
};
function ChilderClass(name, age) {// 子类继承父类没涉及到父类原型FatherClass.call(this, name)this.age age;
};
function F() { };
//过渡函数的原型继承父对象
F.prototype FatherClass.prototype;
ChilderClass.prototype new F();
var c new ChilderClass(lily, 18);这个就是 es5 的类继承构造函数继承和原型继承是分开的两种不同的方式。子类继承父类的时候先创造子类的实例对象this然后再将父类的属性和方法添加到this上面FatherClass.call(this,name)然后再去继承原型链。
// ES6的继承
class FatherClass {family [father, mother, daughter];constructor(name) {this.name name}getName() {console.log(this.name);}
};class ChilderClass extends FatherClass {constructor(name, age) {super(name);this.age age;}
};
var c new ChilderClass(lily, 18);这里类继承机制完全和 es5 不一样是调用 super 方法将父类的属性和方法加到 this 上面。在子类的构造函数中只有调用 super 之后才可以使用 this 关键字否则会报错。这是因为子类的构建基于父类只有 super 方法才能调用父类构造函数。 ES5 的继承实质上是先创建子类的实例对象 this然后再将父类的方法添加到 this 上Parent.apply(this)然后继承原型。ES6 的继承机制完全不同它是在子类的构造器中先调用 super 方法创建出父类实例对象 this然后再去修改子类中的 this 完善子类。6、es6 的 import 引入模块 import 语法声明用于从已导出的模块、脚本中导入函数、对象、指定文件或模块的原始值。
import 模块导入与 export 模块导出功能相对应也存在两种模块导入方式
命名式导入名称导入默认导入定义式导入。import 的语法跟 require 不同而且 import 必须放在文件的最开始且前面不允许有其他逻辑代码这和其他所有编程语言风格一致。 import defaultMember from module-name;
import * as name from module-name;
import { member } from module-name;
import { member as alias } from module-name;
import { member1 , member2 } from module-name;
import { member1 , member2 as alias2 , [...] } from module-name;
import defaultMember, { member [ , [...] ] } from module-name;
import defaultMember, * as name from module-name;
import module-name;
name从将要导入模块中收到的导出值的名称member, memberN从导出模块导入指定名称的多个成员defaultMember从导出模块导入默认导出成员alias, aliasN别名对指定导入成员进行的重命名module-name要导入的模块。是一个文件名as重命名导入成员名称“标识符”from从已经存在的模块、脚本文件等导入命名式导入
我们可以通过指定名称就是将这些成员插入到当作用域中。导出时可以导入单个成员或多个成员
注意花括号里面的变量与 export 后面的变量一一对应
import {myMember} from my-module;
import {foo, bar} from my-module;
通过 * 符号我们可以导入模块中的全部属性和方法。当导入模块全部导出内容时就是将导出模块my-module.js所有的导出绑定内容插入到当前模块’myModule’的作用域中
import * as myModule from my-module;
导入模块对象时也可以使用as对导入成员重命名以方便在当前模块内使用
import {reallyReallyLongModuleMemberName as shortName} from my-module;
导入多个成员时同样可以使用别名
import {reallyReallyLongModuleMemberName as shortName, anotherLongModuleName as short} from my-module;
导入一个模块但不进行任何绑定import my-module; 默认导入
在模块导出时可能会存在默认导出。同样的在导入时可以使用 import 指令导出这些默认值。
直接导入默认值import myDefault from my-module;
也可以在命名空间导入和名称导入中同时使用默认导入
import myDefault, * as myModule from my-module; // myModule 做为命名空间使用
//或
import myDefault, {foo, bar} from my-module; // 指定成员导入 import 使用示例
// --file.js--
function getJSON(url, callback) {let xhr new XMLHttpRequest();xhr.onload function () {callback(this.responseText)};xhr.open(GET, url, true);xhr.send();
}export function getUsefulContents(url, callback) {getJSON(url, data callback(JSON.parse(data)));
}// --main.js--
import {getUsefulContents} from file;getUsefulContents(http://itbilu.com, data {doSomethingUseful(data);
}); 7、default 关键字 // d.js
export default function () {
}// 等效于
function a() {
};
export {a as default};
在 import 的时候可以这样用
import a from ./d;// 等效于或者说就是下面这种写法的简写是同一个意思
import {default as a} from ./d;
这个语法糖的好处就是 import 的时候可以省去花括号{}。
简单的说如果 import 的时候你发现某个变量没有花括号括起来没有*号那么你在脑海中应该把它还原成有花括号的 as 语法。
所以下面这种写法你也应该理解了吧import $,{each,map} from jquery;
import 后面第一个 $ 是 {defalut as $} 的替代写法。 8、as 关键字 as 简单的说就是取一个别名export 中可以用import 中其实可以用
// a.js
var a function () {
};
export {a as fun};// b.js
import {fun as a} from ./a;a();
上面这段代码export 的时候对外提供的接口是 fun它是 a.js 内部 a 这个函数的别名但是在模块外面认不到 a只能认到 fun。
import 中的 as 就很简单就是你在使用模块里面的方法的时候给这个方法取一个别名好在当前的文件里面使用。之所以是这样是因为有的时候不同的两个模块可能通过相同的接口比如有一个 c.js 也通过了 fun 这个接口
// c.js
export function fun() {};
如果在b.js中同时使用a和c这两个模块就必须想办法解决接口重名的问题as就解决了。 9、CommonJS 中 module.exports 与 exports 的区别 Module.exports The module.exports object is created by the Module system. Sometimes this is not acceptable; many want their module to be an instance of some class. To do this, assign the desired export object to module.exports. Note that assigning the desired object to exports will simply rebind the local exports variable, which is probably not what you want to do. 译文module.exports对象是由模块系统创建的。 有时这是难以接受的许多人希望他们的模块成为某个类的实例。 为了实现这个需要将期望导出的对象赋值给module.exports。 注意将期望的对象赋值给exports会简单地重新绑定到本地exports变量上这可能不是你想要的。 Module.exports The exports variable is available within a module’s file-level scope, and is assigned the value of module.exports before the module is evaluated. It allows a shortcut, so that module.exports.f … can be written more succinctly as exports.f …. However, be aware that like any variable, if a new value is assigned to exports, it is no longer bound to module.exports: 译文exports变量是在模块的文件级别作用域内有效的它在模块被执行前被赋于 module.exports 的值。它有一个快捷方式以便 module.exports.f … 可以被更简洁地写成exports.f …。 注意就像任何变量如果一个新的值被赋值给exports它就不再绑定到module.exports(其实是exports.属性会自动挂载到没有命名冲突的module.exports.属性) 从 Api文档 上面的可以看出从 require 导入方式去理解关键有两个变量(全局变量 module.exports局部变量 exports )、一个返回值( module.exports )
function require(...) {var module {exports: {}};((module, exports) {// 你的被引入代码 Start// var exports module.exports {}; (默认都有的)function some_func() {};exports some_func;// 此时exports不再挂载到module.exports// export将导出{}默认对象module.exports some_func;// 此时这个模块将导出some_func对象覆盖exports上的some_func// 你的被引入代码 End})(module, module.exports);// 不管是 exports还是module.exports最后返回的还是module.exportsreturn module.exports;
}
demo.js:
console.log(exports); // {}
console.log(module.exports); // {}
console.log(exports module.exports); // true
console.log(exports module.exports); // true
console.log(module);
/**Module {
id: .,
exports: {},
parent: null,
filename: /Users/larben/Desktop/demo.js,
loaded: false,
children: [],
paths:
[ /Users/larben/Desktop/node_modules,
/Users/larben/node_modules,
/Users/node_modules,
/node_modules ] }*/
注意
每个 js 文件一创建都有一个 var exports module.exports {}; 使 exports 和 module.exports 都指向一个空对象。module.exports 和 exports 所指向的内存地址相同每一个 node.js 执行文件都自动创建一个 module 对象同时module对象会创建一个叫 exports 的属性初始化的值是 {}
require 是值的拷贝不是值引用所以不用担心异步导致的数据污染。 区别主要有3点
module.exports 初始值为一个空对象 {}require() 返回的是 module.exports 而不是 exportsexports 是指向的 module.exports 的值的引用。
前两条很好理解第三条意思是
如果 exports newObject那么 exports 断开了与 module.exports 的引用两者就不再指向一个内存地址了所有才有了如下的写法 exports module.exports somethings 等价于 module.exports somethings exports module.exports如果 module.exports newObjectexports 跟 module.exports 不再指向同一个值(或者叫内存地址)那么 exports 就失效了。总结
如果不使用 module.exports仅使用 exports那么 exports 只能得到属性不能重新赋值对象。建议使用 exports.x 等写法。如果使用了module.exports newObject那么这时候 exports 就失效了必须使用 exports module.exports newObject 建立联系
