1.Object.prototype
Object._proto_ == Function.prototype //true
Function._proto_ ==Function.prototype //true
Function._proto_._proto_ == Object.prototype //true
Object.prototype._proto_ ==null //true
2.Object.assign()
Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
语法
Object.assign(target, ...sources)
1.复制一个对象
var obj ={a:1};
var obj2 = Object.assign({},obj);
//obj2 {a:1}
2.Object.assign()方法是浅拷贝
var obj1 = {a:1,b:{c:2}};
var copy = Object.assign({},obj1);
copy.b.c=4;
//obj1.b.c =4
// Deep Clone
obj1 = { a: 0 , b: { c: 0}};
let obj3 = JSON.parse(JSON.stringify(obj1));
obj1.a = 4;
obj1.b.c = 4;
console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}}
3.合并对象
合并具有相同属性的对象
var o1 = { a: 1, b: 1, c: 1 };
var o2 = { b: 2, c: 2 };
var o3 = { c: 3 };
var obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
3.Object.create()
Object.create()方法，主要用于原型式继承。（基于一个已有的对象来来提供新创建的对象的proto）
语法
Object.create(proto, [propertiesObject])
1.对象实现类式继承（原型式继承）
var person = {
name:'Nicholas',
friends:['Shelly','Court','Van']
};
var copy = Object.create(person);
copy.name //'Nicholas';
copy.friends //['Shelly','Court','Van']
//object.create()实现原理
function create(o){
function F(){}
F.prototype = o;
return new F();
}
2.方法实现类式继承
// Shape - 父类(superclass)
function Shape() {
this.x = 0;
this.y = 0;
}
// 父类的方法
Shape.prototype.move = function(x, y) {
this.x += x;
this.y += y;
console.info('Shape moved.');
};
// Rectangle - 子类(subclass)
function Rectangle() {
Shape.call(this); // call super constructor.
}
// 子类续承
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;
var rect = new Rectangle();
console.log('Is rect an instance of Rectangle?',
rect instanceof Rectangle); // true
console.log('Is rect an instance of Shape?',
rect instanceof Shape); // true
rect.move(1, 1); // Outputs, 'Shape moved.'
4.Object.defineProperties()
直接在一个对象上定义新的属性或修改现有属性，并修改该对象
例子
var obj = {};
Object.defineProperties(obj, {
'property1': {
value: true,
writable: true
},
'property2': {
value: 'Hello',
writable: false
}
// etc. etc.
});
5.Object.defineProperty()
直接在一个对象上定义一个新的属性或修改现有属性，并修改该对象。
6.Object.getPropertyOf()方法返回指定对象的原型（内部[[Prototype]]属性的值）。
示例
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
var reg = /a/;
Object.getPrototypeOf(reg) === RegExp.prototype; // true
Object.getPrototypeOf( Object ) === Function.prototype;
var obj = new Object();
Object.prototype === Object.getPrototypeOf( obj );
7.判断两个值是否是相同的值
语法
Object.is(value1,value2)
描述
Object.is() 判断两个值是否相同。如果下列任何一项成立，则两个值相同：
这种相等性判断逻辑和传统的 == 运算符所用的不同，== 运算符会对它两边的操作数做隐式类型转换（如果它们类型不同），然后才进行相等性比较，（所以才会有类似 "" == false 为 true 的现象），但 Object.is 不会做这种类型转换。
这与===运算符也不一样。===运算符（和==运算符）将数字值-0和+0视为相等，并认为Number.NaN不等于NaN。
示例
Object.is('foo', 'foo'); // true
Object.is(window, window); // true
Object.is('foo', 'bar'); // false
Object.is([], []); // false
var test = { a: 1 };
Object.is(test, test); // true
Object.is(null, null); // true
// 特例
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0/0); // true
8.Object.hasOwnProperty()返回一个布尔值，指出对象自身属性中是否含有制定属性。
1.自身属性与继承属性
o = new Object();
o.prop = 'exists';
o.hasOwnProperty('prop'); // 返回 true
o.hasOwnProperty('toString'); // 返回 false
o.hasOwnProperty('hasOwnProperty'); // 返回 false
2.hasOwnProperty()会被外部方法覆盖
var foo={
hasOwnProperty:function(){return false;},
bar:baz
}
foo.hasOwnProperty()//false;
//调用Object 原型上的 hasOwnProperty 属性
Object.prototype.hasOwnProperty.call('foo','bar')//true
9.Object.isPropertyOf()方法用于检测一个对象是否存在于另一个对象的原型链上。
isPrototypeOf() 与 instanceof 运算符不同。在表达式 "object instanceof AFunction"中，object 的原型链是针对 AFunction.prototype 进行检查的，而不是针对 AFunction 本身。
示例
function Foo() {}
function Bar() {}
function Baz() {}
Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);
var baz = new Baz();
console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true
