var obj = {};
obj[true] = "foo";
obj[3] = "bar";
obj[obj] = "baz";
obj["true"];
obj["3"];
obj["[object Object]"];
var ary = ["foo", 42, "bar"]; ary.baz = "baz"; ary.length; //3 ary.baz; /* 如果试图想数组添加一个属性，但是属性名“看起来”像一个数字，那么它会变成一个数值下标 */ ary["4"] = "baz"; ary.length; //5 ary[4];
var obj = {};
Object.defineProperty(obj, "a", {enumerable:true, value:2});
Object.defineProperty(obj, "b", {enumerable:false, value:3});
/* 检查给定属性名是否直接存在于对象中（而不是在原型链上）并满足enumerable:true */
obj.propertyIsEnumerable("a"); //true
obj.propertyIsEnumerable("b"); //false
/* 返回一个数组，包含所有（自身）可枚举属性 */
Object.keys(obj); //["a"]
/* 返回一个数组，包含所有（自身）属性 */
Object.getOwnPropertyNames(obj); //["a", "b"]注意：in和hasOwnProperty(..)的区别在于是否查找[[Prototype]]链，然而，Object.keys(..)和Object.getOwnPropertyNames(..)都只会查找对象直接包含的属性。function Foo(){}
var foo = new Foo();
Foo.prototype === Object.getPrototypeOf(foo); //true注意：在面向类的语言中，类可以复制（实例化）多次，就像用模具制作东西一样。在JavaScript中，并没有类似的复制机制。不能创建一个类的多个实例，只能创建多个对象，它们[[property]]关联的是同一个对象。这样就可用通过委托访问对象的属性和方法了。var foo = {
something:function(){
// ....
}
};
var bar = Object.create(foo); // 创建新对象bar，并将其关联到对象foo上。Object.create(null)会创建一个拥有空链接的对象，这个对象无法进行委托，其不存在原型链，所以instanceof总是返回false。其不受原型链干扰，非常适合用来存储数据！if(a.something) {
a.something(); // something()并不一定在a自身上
}方式三：isPrototypeOf()、getPrototypeOf()function Foo(){}
Foo.prototype = {};
var a1 = new Foo();
a1.constructor === Foo; //false
a1.constructor === Object; //true详解：function Foo(name){
this.name = "FenFei"
}
function Bar(){}
错误理解一：
Bar.prototype = Foo.prototype; Bar.prototype.myTest = 123; new Foo().myTest; //123并不会创建一个关联到Bar.prototype的新对象，它只是让Bar.prototype直接引用Foo.prototype对象。当执行类似Bar.prototype.myTest = 123的赋值语句时会直接修改Foo.prototype对象本身。
错误理解二：
Bar.prototype = new Foo();
new Bar("Camile").name; //FenFei的确会创建一个关联到Bar.prototype的新对象。但是它使用了Foo()的“构造函数调用”，如果Foo有副作用（比如注册到其他对象、给this添加数据属性等等），就会影响Bar()的后代。正确处理方式一[ES6之前]：
Bar.prototype = Object.create(Foo.prototype);
Bar.prototype.myTest = 123;
new Foo().myTest; //undefined
new Bar("Camile").name; //undefined
正确处理方式二[ES6之后]：
Object.setPrototypeOf(Bar.prototype, Foo.prototype);
Bar.prototype.myTest = 123;
new Foo().myTest; //undefined
new Bar("Camile").name; //undefined
a instanceof Foo;（2）在a的整条[[prototype]]链中是否出现过Foo.prototype？
Foo.prototype.isPrototypeOf(a); // 不需要间接引用函数Foo，它的prototype属性会自动访问。（3）区别
b.isPrototypeOf(c);示例：
function Foo(){}
var a = new Foo();
console.log(a instanceof Foo); // true
console.log(Foo.prototype.isPrototypeOf(a)); // true
var b = {};
var c = Object.create(b);
console.log(b.isPrototypeOf(c)); // true
console.log(b instanceof c); // TypeError
在传统面向类的语言中，类定义之后就不会进行修改，所以类的设计模式不支持修改。但是JavaScript最强大的特性之一就是它的动态性，任何对象的定义都可以修改（除非你把它设置成不可变）！
[转载请标明出处：http://blog.csdn.net/ligang2585116]
版权声明：本文为博主原创文章，未经博主允许不得转载。转载请标明出处：http://blog.csdn.net/ligang2585116！
JavaScript对象、函数（你不知道的JavaScript）
原文：http://blog.csdn.net/ligang2585116/article/details/47379317