继承及模块化

首先定义一个父类：

// 定义一个人名
function Person (name) {
  // 属性
  this.name = name || 'Person';
  // 实例方法
  this.sleep = function(){
    console.log(this.name + '正在睡觉！');
  }
}
// 原型方法
Person.prototype.eat = function(food) {
  console.log(this.name + '正在吃：' + food);
};

原型链继承
我们把父类的实例作为子类的原型

function Anybody(){}
Anybody.prototype = new Person(); //将父类的实例作为子类的原型
Anybody.prototype.name = '张三'; 

var anybody = new Anybody();
console.log(anybody.name); //张三
console.log(anybody.eat('fish')); //张三正在吃fish
console.log(anybody.sleep()); //张三正在睡觉！

构造函数继承
使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）

function Li(name){
  Person.call(this);
  this.name = name || '李四';
}

var li = new Li();
console.log(li.name); //李四
console.log(li.sleep());//李四正在睡觉！

模块化加载规范

• CommonJS规范
• AMD（异步加载模块）
• CMD规范（异步加载模块）
• ES6模块化

CommonJS规范
允许模块通过require方法来同步加载要依赖的其他模块，然后通过exports或module.exports来导出需要暴露的接口。

// 导入
require("../app.js");
// 导出
exports.getStoreInfo = function() {};
module.exports = someValue;

它的好处是简单容易使用，服务器端模块便于复用，不好的地方呢是同步加载方式不适合在浏览器环境中使用，同步代表阻塞加载，浏览器资源是异步加载的，而且不能非阻塞的并行加载多个模块

AMD（异步加载模块）
使用异步方式加载模块，模块的加载不影响后面语句的运行。所有依赖模块的语句，都定义在一个回调函数中，等到加载完成之后，回调函数才执行。

// 定义
define("module", ["dep1", "dep2"], function(d1, d2) {...});
// 加载模块
require(["module", "../app"], function(module, app) {...});
//加载模块require([module], callback);第一个参数[module]，是一个数组，里面的成员就是要加载的模块；第二个参数callback是加载成功之后的回调函数。

它适合在浏览器环境中异步加载模块并且可以并行加载多个模块，不好的点是提高了开发成本，代码的阅读和书写比较困难，模块定义方式的语义不顺畅。
大概执行过程：

1. require函数检查依赖的模块，根据配置文件，获取js文件的实际路径
2. 根据js文件实际路径，在dom中插入script节点，并绑定onload事件来获取该模块加载完成的通知。
3. 依赖script全部加载完成后，调用回调函数

CMD规范（异步加载模块）
CMD规范和AMD很相似，和CommonJS和Node.js的 Modules 规范保持了很大的兼容性；在CMD规范中，一个模块就是一个文件。

• 定义模块使用全局函数define，其接收 factory 参数，factory 可以是一个函数，也可以是一个对象或字符串；
• factory 是一个函数，有三个参数，function(require, exports, module)：

//require 是一个方法，接受模块标识作为唯一参数，用来获取其他模块提供的接口：require(id)
//exports 是一个对象，用来向外提供模块接口
//module 是一个对象，上面存储了与当前模块相关联的一些属性和方法
define(function(require, exports, module) {
  var a = require('./a');
  a.doSomething();
  // 依赖就近书写，什么时候用到什么时候引入
  var b = require('./b');
  b.doSomething();
});

优点是依赖就近，延迟执行并且可以很容易在 Node.js 中运行

ES6模块化
ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，完全可以取代 CommonJS 和 AMD 规范，成为浏览器和服务器通用的模块解决方案。

// 导入
import "/app";
import React from "react";
import { Component } from "react";
// 导出
export { } 
export default 
export function multiply() {...};
export var year = 2018;
export default ......

今天了解一下几种继承的方式及模块化规范并记录下来，如有错误请指正。