我只是想知道以下JavaScript对象声明之间的区别。具体来说，事物类中的事物对象文字和事物1对象之间的区别。
var thing = {
sanity:0,
init:function(){
//code
},
send:function(){
//code
}
}
function thing(){
this.sanity = 0;
this.init = function(){
//code
};
this.send = function(){
//code
};
}
thing1 = new thing();
答案 0 :(得分：22)
静态对象或对象文字不需要使用new运算符进行实例化，也表现得像单例。请考虑以下示例：
<强>代码：
var staticObject1 = {
a: 123,
b: 456
};
var staticObject2 = staticObject1;
console.log(staticObject1, staticObject2);
staticObject2.b = "hats";
console.log(staticObject1, staticObject2);
<强>输出：
Object a=123 b=456 Object a=123 b=456
Object a=123 b=hats Object a=123 b=hats
请注意，更改staticObject2.b也会影响staticObject1.b。然而，这可能并不总是期望的效果。许多库（例如Dojo）提供了一种对象克隆方法，如果要复制静态对象，可以缓解这种情况。继续前面的示例，请考虑以下事项：
<强>代码：
var staticObject3 = dojo.clone(staticObject1); // See the doc in the link above
staticObject1.a = "pants";
console.log(staticObject1, staticObject2, staticObject3);
<强>输出：
Object a=pants b=hats Object a=pants b=hats Object a=123 b=hats
请注意staticObject1和staticObject2成员的值相同，而staticObject3不受这些其他对象更改的影响。
静态对象对于创建项目或库命名空间也很有用，而不是填满全局范围，并提升兼容性，就像没有人的业务一样。
在创建需要可移植性或互操作性的库时，这非常有用。这可以在流行的库中看到，例如Dojo，YUI和ExtJs，其中所有或大多数方法分别被称为dojo.examplMethod()，YUI().exampleMethod()或Ext.exampleMethod()。
静态对象也可以被认为与C / C ++中的struct松散相似。
JavaScript中的类基于原型继承，这是一个复杂得多的主题，可以阅读here，here和here。
与静态对象相反，由于JavaScript的closuer属性，这种对象创建方法为私有范围对象成员和方法提供了独特的机会。请考虑以下私有类成员示例：
<强>代码：
var SomeObject = function() {
var privateMember = "I am a private member";
this.publicMember = "I am a public member";
this.publicMethod = function() {
console.log(privateMember, this.publicMember);
};
};
var o = new SomeObject();
console.log(typeof o.privateMember, typeof o.publicMember);
o.publicMethod();
<强>输出：
undefined string
I am a private member I am a public member
请注意typeof o.privateMember是“未定义的”，并且无法在对象外部访问，但是来自内部。
也可以制作私有方法，但不是那么简单，但仍然很容易实现。问题在于私有方法内部this的值默认为window，并且必须应用以下两种技术之一来确保this引用我们在其中工作的对象在这种情况下，SomeObject的实例。请考虑以下示例：
代码：
var SomeObject = function() {
var privateMember = "I am a private member";
var privateMethod = function() {
console.log(this.publicMember);
};
this.publicMember = "I am a public member";
this.publicMethod = function() {
console.log(privateMember, this.publicMember);
};
this.privateMethodWrapper = function() {
privateMethod.call(this);
}
};
var o = new SomeObject();
console.log(typeof o.privateMethod, typeof o.publicMethod, typeof o.privateMethodWrapper);
o.privateMethodWrapper();
<强>输出：
undefined function function
I am a public member
请注意，在使用privateMethodWrapper()时，privatemethod使用call执行，并为函数的上下文传入this。这一切都很好;但是，以下技术是优选的（在我看来），因为它简化了调用范围并产生相同的结果。上一个示例可以更改为以下内容：
<强>代码：
var SomeObject = function() {
var self = this;
var privateMember = "I am a private member";
var privateMethod = function() {
console.log(self.publicMember);
};
this.publicMember = "I am a public member";
this.publicMethod = function() {
console.log(privateMember, this.publicMember);
};
this.privateMethodWrapper = function() {
privateMethod();
}
};
var o = new SomeObject();
console.log(typeof o.privateMethod, typeof o.publicMethod, typeof o.privateMethodWrapper);
o.privateMethodWrapper();
<强>输出：
undefined function function
I am a public member
这个答案是我blog上帖子的基础，我在这里给出了其他例子。希望有所帮助;）
答案 1 :(得分：6)
案例2 引用了javascript 类构造函数。一个明显的区别是变量还不是一个对象，所以你不能在内部引用thing1.sanity。您必须在调用任何内部成员之前通过创建所述类的实例来初始化该类：
var myConstructor = function() {
this.sanity = 0;
}
// wont work
alert(myConstructor.sanity);
// works
var thing1 = new myConstructor();
alert(thing1.sanity);
这篇文章比我的简单例子更深入：
答案 2 :(得分：1)
不同之处在于thing1对象与thing1类相关联，并且将继承（不是字面意思）thing1原型。
例如，您可以稍后编写
thing.prototype.initAndSend = function() { this.init(); this.send(); };
然后，您可以在不修改thing1.initAndSend()的情况下编写thing1。此外，thing1.constructor将等同于thing方法，而{}.constructor则等于Object。
顺便说一句，标准惯例是大写类名。
答案 3 :(得分：0)
使用第一种方法，您将声明一个对象。对于第二个，您将声明一个类，您可以从中实例化（即创建）许多不同的副本。
答案 4 :(得分：0)
函数是对象和构造函数（可以使用new实例化它们。）
哈希表/对象（{}）无法实例化，因此它们通常用作数据结构。我不太确定将它们称为“物体”是否明智。