请教一段JavaScript闭包的分析

Question

function JSClass() {
    var privateStaticVariable = "私有静态变量";
    var privateStaticMethod = function() {alert("调用私有静态方法");};
    return function() {
        this.test1 = function() {return privateStaticVariable; }
        this.test2 = function(obj) {
   privateStaticVariable = obj; 
   privateStaticMethod = function() {alert("静态方法");}
   }
        this.test3 = function() {privateStaticMethod();}
    };
}
var testObject1 = new JSClass();
var testObject2 = new JSClass();
document.write(testObject1.test1());
document.write("<br>");
testObject1.test2("改变的私有静态变量");
document.write(testObject2.test1());
testObject2.test3();
我的理解：
这段代码里 return function()返回的是那个匿名函数的this.test1，而后面的对象实例都是对JSClass的引用，所以最终得不到结果而这样写：
var JSClass = (function() {
    var privateStaticVariable = "私有静态变量";
    var privateStaticMethod = function() {alert("调用私有静态方法");};
    return function() {
        this.test1 = function() {return privateStaticVariable; }
        this.test2 = function(obj) {
   privateStaticVariable = obj; 
   privateStaticMethod = function() {alert("静态方法");}
   }
        this.test3 = function() {privateStaticMethod();}
    };
})();var testObject1 = new JSClass();
var testObject2 = new JSClass();
document.write(testObject1.test1());
document.write("<br>");
testObject1.test2("改变的私有静态变量");
document.write(testObject2.test1());
testObject2.test3();//不是直接定义Javascript类，而是用一个匿名的function作为静态变量的容器，并返回Javascript类最后可以得到document.write(testObject1.test1());等结果
return返回的this.test1可以共享给最外层函数，并且privateStaticVariable这个变量可以维持改变为什么(function(){})()这样写就可以实现内层嵌套函数的this.test1共享和局部变量的改变呢？

Answer 1

document.write(testObject1.test1());
==>
document.write((new testObject1()).test1());

Answer 2

这是匿名函数的利用(function() {})() ==>就已经执行了也就是说JSClass 其实为function() {
        this.test1 = function() {return privateStaticVariable; }
        this.test2 = function(obj) {
   privateStaticVariable = obj; 
   privateStaticMethod = function() {alert("静态方法");}
   }
        this.test3 = function() {privateStaticMethod();}
    };
而这var privateStaticVariable = "私有静态变量";
    var privateStaticMethod = function() {alert("调用私有静态方法");};
原本该是全局变量的变量变成了局部变量，被隐藏起来，在外面不得使用，但是这个return 出来的function却可以使用，这就是闭包的作用。

Answer 3

而你的第一段代码之所以不对，是因为你的代码本身有误
function JSClass() {
    var privateStaticVariable = "私有静态变量";
    var privateStaticMethod = function() {alert("调用私有静态方法");};
    return function() {
        this.test1 = function() {return privateStaticVariable; }
        this.test2 = function(obj) {
            privateStaticVariable = obj; 
            privateStaticMethod = function() {alert("静态方法");}
        };
        this.test3 = function() {privateStaticMethod();}
    };
}var testObject1 = new JSClass();
var testObject2 = new JSClass();
var test = new testObject1();
var test2 = new testObject2();
document.write(test.test1());
document.write("<br>");
test.test2("改变的私有静态变量");
document.write(test2.test1());
test2.test3();testObject1远非对象实例，相反，他是对象本身。这个对象就是下面那个例子中执行结果中的JSClass的身份。

Answer 4

var testObject1 = new JSClass();
var obj = new testObject1();
你下面的方式实质上是一样的，
var testObject1 = new JSClass();

Answer 5

但前者和后者有一个区别
区别在哪呢
就是那个局部变量的共享上前者是2个独立的对象，那么可以想象是不同的块内的数据后者则是共享着那个局部变量，testObject1和testObject2是同一个对象的2个不同的实例（这个解释有点牵强）。