首先我们都知道js的一个函数定义是这样的
function func(){ //声明一个普通的函数 //省略代码 } 而没有名字的函数叫匿名函数，是长这样的
function(){ //声明一个匿名函数，一般这样声明方式是用于回调函数 //省略代码 } 或者我们习惯用一个变量来保存匿名函数，那么这个变量成为函数本身
var func = function(){ //匿名函数保存到func变量内 //省略代码 } 同样，在调用函数的时候，使用函数名或者变量名后面加上一个括号，像以下这样
func(); //调用函数 再者，也可以在声明函数的时候直接调用，这种叫做即时执行函数，需要加上两个括号，像这样
(function(){ //即时执行函数 //省略代码 })(); 当然，函数是可以有返回值的，如果是即时执行函数有返回值，那么效果会怎样？
var func = (function(){ //即时执行函数 var i = 1; return i; })(); 这样写，func获取的就不只匿名函数，而是函数的返回结果，func = 1
----------------------------------------我是分割线-----------------------------------------
刚刚，我们的函数返回的是一个整数，但如果我们的函数返回的是另一个函数呢？就成了闭包，像这样：
var func = (function(){ //即时执行函数 var resultFunc = function(){ //要返回的函数 //省略代码 } return resultFunc; })(); 以上这样写 func就是resultFunc函数，这样有什么用呢？看下面的代码，注意变量 i 的作用域
var func = (function(){ var i = 5; //声明了局部变量 var resultFunc = function(){ console.log(i); //返回的函数体内能访问变量 i //省略代码 } //作用域内能访问变量 i return resultFunc; })(); //函数体外能不能访问变量 i 这样声明的 i 变量外部是不能访问的，是不是很像面向对象的私有成员变量？接下来我们试试内部方法
var func = (function(){ var i = 5; var privateFunc = function(){ //声明了局部变量 //省略代码 } var resultFunc = function(){ privateFunc(); //调用局部函数 //省略代码 } return resultFunc; })(); 小结一下：实际情况下，我们可以尝试这样写：
var func = (function(){ var i = 5; var privateFunc = function(){ //声明了局部变量 console.log("执行了privateFunc局部函数"); } var resultFunc = function(j){ console.log("外部变量:"+j); console.log("内部变量:"+i); privateFunc(); //调用局部函数 //省略代码 } return resultFunc; })(); var test = new func(9); 
这样看，其实 resultFunc 更像是一个构造函数，这个函数在我们new func（）的时候，必须且只执行一次，并且这个函数可以接受外部参数的哦。
----------------------------------------我是分割线-----------------------------------------
好了，接下来我们可以通过prototype的方式为其添加一些公开函数，而这些函数都是可以访问局部变量及局部函数的：
var func = (function(){ var i = 5; var privateFunc = function(){ //声明了局部变量 console.log("执行了privateFunc局部函数"); } var resultFunc = function(j){ console.log("外部变量:"+j); console.log("内部变量:"+i); privateFunc(); //调用局部函数 //省略代码 } var _proto = resultFunc.prototype; //取出prototype变量 _proto.myName = "ken"; //prototype的变量 _proto.publicFunc = function(){ //prototype的方法 console.log("这个是公共的方法,还有我的名字是"+this.myName); } return resultFunc; })(); var test = new func(9); test.publicFunc(); console.log(test.myName); 
在外部能通过"."的方式调用prototype的内容，prototype函数体内通过this.访问自身变量。
就这样，公共及私有成员方法都通过闭包实现出来。
----------------------------------------再次分割线-----------------------------------------
通过以上的，公共变量及方法都是保存在prototype内，那么其实如果想模拟面向对象的继承，只要把prototype拷贝就可以了，先整理一下父类的代码：
var Super = (function(){ function _super(){ console.log("Super constructor"); this.name = "Super"; } var _proto = _super.prototype; _proto.sayHi = function(){ console.log("hello ! my name is "+this.getMyName()); } _proto.getMyName = function(){ return this.name; } return _super; })(); var s = new Super(); s.sayHi(); 
以下是子类的继承方式
var child = (function(){ var extend = Super; //定义要继承的父类 function _child(){ //子类的构造函数 extend.call(this); //让父类内部的this替换成子类的this，执行函数 console.log("child constructor"); this.name="child"; //覆盖子类的name } var nullObj = function(){}; //这里建立一个空白对象 nullObj.prototype = extend.prototype; //空白对象的prototype指向父类的prototype _child.prototype = new nullObj(); //新建nullObj（实际上是复制一份）的prototype给_child _child.prototype.constructor = _child;//把_child的构造函数放回prototype里,因prototype刚刚已经被覆盖了 var _proto = _child.prototype; //取得prototype ///这里可以继续添加子类的方法 return _child; })(); 注意：nullObj.prototype = extend.prototype; 这里nullObj.prototype是引用，不能直接修改nullObj.prototype内容，不然会影响父类的代码，只能通过new nullObj 复制给 _child.prototype
调用测试
var c = new child(); c.sayHi(); console.log(c.name); 
可以看到这里首先是调用了父类的构造函数，再调用子类的构造函数，而后sayHi方法被子类继承过来，而name内容变成了子类的child字符串。
采用闭包的方式跟ES6的class有什么不一样？
● ES6的class不存在私有成员，内部通过this访问变量或函数，外部通过"."方式访问。
● 采用闭包方式可以拥有私有成员，公共成员跟ES6访问方式一样，访问私有成员因为作用域的关系，只要直接调用就好了。
● ES6的使用比闭包方式要简单，可以根据自己的情况选择使用。
链接：https://www.jianshu.com/p/77e5840fc514