Object.constructor,prototype
对象的prototype和constructor是两个重要的属性，他们总是成对出现，提到constructor的地方，不得不涉及到另外一个非常重要的属性prototype,它是js中基于原型继承的一个基础。所谓的成对出现，是因为function的prototype属性指向了一个prototype对象，在prototype对象中又有一个constructor属性，这个constructor属性同样指向一个constructor对象，而这个constructor对象恰恰就是这个function函数本身。
function Person(name)
{
this.name=name;
this.showMe=function()
{
alert(this.name);
}
};
var one=new Person('JavaScript');
one.showMe();//JavaScript 很多人见到了久违的new操作符，于是就叫Person为“类”，可是又没有关键字class的出现，觉得叫“类”有点勉强。于是退而求其次叫Person为类的构造函数。这些概念好像都没有错，之所以出现这样的情况，可能是因为大家都学习了传统的面向对象语言（c++，c#，java等），还有一种思维定势吧。为了让javascript也面向对象，要在javascript中找到与传统面向对象语言的影子。可是按照javascript的说法，function定义的这个Person就是一个Object(对象),而且还是一个很特殊的对象，这个使用function定义的对象与使用new操作符生成的对象之间有一个重要的区别。
这个区别就是function定义的对象有一个prototype属性，使用new生成的对象就没有这个prototype属性。（这个之前没有注意过这个区别，代码测试下竟然还真是）
function Person(name)
{
this.name=name;
this.showMe=function()
{
alert(this.name);
}
};
var one=new Person('js');
alert(one.prototype)//undefined
alert(typeof Person.prototype);//object
alert(Person.prototype.constructor);//function Person(name) {...};one这个对象竟然没有prototype属性。。。
function Person(name)
{
this.name=name;
this.showMe=function()
{
alert(this.name);
}
};
Person.prototype.from=function()
{
alert('I come from prototype.');
}
var one=new Person('js');
one.showMe();//js,这个结果正常
one.from();//I come from prototype.，这个结果有一点奇怪要解释这个结果就要仔细研究一下new这个操作符了
var one=new Person('js');这个语句执行的过程可以分成下面的语句：
var one={};
Person.call(one,'js'); 按照《悟透javascript》书中说的，new形式创建对象的过程实际上可以分为三步：
第一步是建立一个新对象（叫A吧）；
第二步将该对象（A）内置的原型对象设置为构造函数(就是Person)prototype 属性引用的那个原型对象；
第三步就是将该对象（A）作为this 参数调用构造函数(就是Person)，完成成员设置等初始化工作。
其中第二步中出现了一个新名词就是内置的原型对象__prop__，注意这个新名词跟prototype对象不是一回事，__prop__（图中标记的inobj）就指向了函数Person的prototype对象。在person的prototype对象中出现的任何属性或者函数都可以在one对象中直接使用，这个就是javascript中的原型继承了。示意图如下所示：
每个函数都有一个默认的prototype属性。
如果这个函数被用在创建自定义对象的场景中，我们称这个函数为构造函数。 比如下面一个简单的例子：
// 构造函数
function Person(name) {
this.name = name;
}
// 定义Person的原型，原型中的属性可以被自定义对象引用
Person.prototype = {
getName: function() {
return this.name;
}
}
var zhang = new Person("ZhangSan");
console.log(zhang.getName()); // "ZhangSan"作为类比，我们考虑下JavaScript中的数据类型 - 字符串（String）、数字（Number）、数组（Array）、对象（Object）、日期（Date）等。
我们有理由相信，在JavaScript内部这些类型都是作为构造函数来实现的；
同时对数组操作的很多方法（比如concat、join、push）应该也是在prototype属性中定义的。
实际上，JavaScript所有的固有数据类型都具有只读的prototype属性（因为如果修改了这些类型的prototype属性，则哪些预定义的方法就消失了），但是我们可以向其中添加自己的扩展方法。
Object.constructor遇到prototype的问题
constructor始终指向创建当前对象的构造函数。
var arr = [1, 56, 34, 12];// 等价于 var foo = new Array(1, 56, 34, 12);
console.log(arr.constructor === Array); // true
var Foo = function() { }; // 等价于 var foo = new Function();
console.log(Foo.constructor === Function); // true
// 由构造函数实例化一个obj对象
var obj = new Foo();
console.log(obj.constructor === Foo); // true
// 将上面两段代码合起来，就得到下面的结论
console.log(obj.constructor.constructor === Function); // true但是当constructor遇到prototype时，有趣的事情就发生了。 这个现象在我的这篇博客里基于原型创建对象的时候也提到过。链接描述
我们知道每个函数都有一个默认的属性prototype，而这个prototype的constructor默认指向这个函数。如下例所示：
function Person(name) {
this.name = name;
};
Person.prototype.getName = function() {
return this.name;
};
var p = new Person("ZhangSan");
console.log(p.constructor === Person); // true
console.log(Person.prototype.constructor === Person); // true
// 将上两行代码合并就得到如下结果
console.log(p.constructor.prototype.constructor === Person); // true当时当我们重新定义函数的prototype时（这里不是修改而是覆盖），或者成为原型重写，constructor的行为就有点奇怪了，如下示例：
function Person(name) {
this.name = name;
};
Person.prototype = {
getName: function() {
return this.name;
}
};
var p = new Person("ZhangSan");
console.log(p.constructor === Person); // false
console.log(Person.prototype.constructor === Person); // false
console.log(p.constructor.prototype.constructor === Person); // false是因为覆盖Person.prototype时，等价于进行如下代码操作：
Person.prototype = new Object({
getName: function() {
return this.name;
}
});而constructor始终指向创建自身的构造函数，所以此时Person.prototype.constructor === Object，即：
function Person(name) {
this.name = name;
};
Person.prototype = {
getName: function() {
return this.name;
}
};
var p = new Person("ZhangSan");
console.log(p.constructor === Object); // true
console.log(Person.prototype.constructor === Object); // true
console.log(p.constructor.prototype.constructor === Object); // true如何修正过来，只需要重新覆盖Person.prototype.constructor即可：
function Person(name) {
this.name = name;
};
Person.prototype = new Object({
getName: function() {
return this.name;
}
});
Person.prototype.constructor = Person;
var p = new Person("ZhangSan");
console.log(p.constructor === Person); // true
console.log(Person.prototype.constructor === Person); // true
console.log(p.constructor.prototype.constructor === Person); // trueObject的常用方法
javascript中的一切皆对象，而这些对象的有一个最父层的类就是Object,常用的一些属性方法汇总一下，这些方法在判断上述问题以及其他方面很有用。
Object.constructor //对象的构造函数
Object.hasOwnProperty() //检查对象属性是否被继承
Object.isPrototypeOf() //检查一个对象是否是另外一个对象的原型
Object.propertyIsEnumerable() //是否可以通过for/in 循环看到属性
Object.toLocaleString() //返回对象的本地字符串表示
Object.toString() //定义一个对象的字符串表示
Object.valueOf() //制定对象的原始值
最近从图书馆把那边厚厚的《javascript高级程序设计》借过来了，看看单单事件就能将讲那么厚厚一章，打算搞一个基础知识系列~~求监督和共勉