JavaScript之Object对象常用属性与方法手册

MDN Object参考地址：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object

简单描述

Object 构造函数创建一个对象包装器。
创建对象的方式：可以通过new Object()， Object.create()方法，或者使用字面量标记（初始化标记）初始化对象。
当以非构造函数形式被调用时，Object 等同于 new Object()。
如下：

var obj = Object({age:28,name:'jack'});
console.log(obj); //{age: 28,name: "jack"}

属性

Object.prototype

Object.prototype 属性表示 Object 的原型对象。
Object.prototype 属性的属性特性：

writable：true
enumerable：false
configurable：true

几乎所有的 JavaScript 对象都是 Object 的实例；一个典型的对象继承了Object.prototype的属性（包括方法），尽管这些属性可能被遮蔽（亦称为覆盖）。但是有时候可能故意创建不具有典型原型链继承的对象，比如通过Object.create(null)创建的对象，或者通过Object.setPrototypeOf方法改变原型链。

改变Object原型，会通过原型链改变所有对象；除非在原型链中进一步覆盖受这些变化影响的属性和方法。这提供了一个非常强大的、但有潜在危险的机制来覆盖或扩展对象行为。

`[已废弃]`Object.prototype.proto

该特性已经从 Web 标准中删除，虽然一些浏览器目前仍然支持它，但也许会在未来的某个时间停止支持，请尽量不要使用该特性。为了更好的支持，建议只使用 Object.getPrototypeOf()。

通过现代浏览器的操作属性的便利性，可以改变一个对象的 [[Prototype]] 属性,这种行为在每一个JavaScript引擎和浏览器中都是一个非常慢且影响性能的操作，使用这种方式来改变和继承属性是对性能影响非常严重的，并且性能消耗的时间也不是简单的花费在 obj.__proto__ = ... 语句上,它还会影响到所有继承来自该 [[Prototype]] 的对象，如果你关心性能，你就不应该在一个对象中修改它的 [[Prototype]]。相反,创建一个新的且可以继承 [[Prototype]] 的对象，推荐使用 Object.create()。

Object.prototype 的 __proto__ 属性是一个访问器属性（一个getter函数和一个setter函数）,暴露了通过它访问的对象的内部[[Prototype]] (一个对象或 null)。
实例：

let Circle = function () {};
Circle.prototype.add = (num1,num2){
    return num1 + num2;
}
let shape = {};
let circle = new Circle();
 
 设置该对象的原型链引用
// 过时且不推荐使用的。这里只是举个例子，尽量不要在生产环境中这样做。
shape.__proto__ = circle;

 判断该对象的原型链引用是否属于circle
console.log(shape.__proto__ === circle);  true

result = shape.add(1,2);
console.log(result); 3

let shape =  () {};
let p = {
    a:  () {
        console.log('aaa');
    }
};
shape.prototype.__proto__ = p;

let circle =  shape();
circle.a();aaa
console.log(shape.prototype === circle.__proto__);true

或者
let shape =  () {};
var p = () {
        console.log('a');
    }
};

let circle =  shape();
circle.__proto__ = p;
circle.a();   a
console.log(shape.prototype === circle.__proto__);false

或者
 test() {}
test.prototype.myname =  () {
    console.log('myname');
}
let a =  test()
console.log(a.__proto__ === test.prototype);true
a.myname();myname

或者
let fn =  () {};
fn.prototype.myname = );
}

let obj = {
    __proto__: fn.prototype
};

obj.myname();myname

Object.prototype.constructor

返回创建实例对象的 Object 构造函数的引用。注意，此属性的值是对函数本身的引用，而不是一个包含函数名称的字符串。对原始类型来说，如1，true和"test"，该值只可读。

所有对象都会从它的原型上继承一个 constructor 属性：

var o = {};
o.constructor === Object;  true

var o =  Object;
o.constructor === Object; var a = [];
a.constructor === Array; var a =  Array;
a.constructor === Array var n = new Number(3);
n.constructor === Number;  true

例子：如下情况，该对象具有创建自身的create方法。

 Parent() {};
 CreatedConstructor() {}

CreatedConstructor.prototype = Object.create(Parent.prototype);

CreatedConstructor.prototype.create =  create() {
  return new this.constructor();
}

new CreatedConstructor().create().create();  error undefined is not a function since constructor === Parent

在上面的示例中，将显示异常，因为构造函数链接到Parent。为了避免它，只需分配您将要使用的必要构造函数。

 Parent() {}; 
 CreatedConstructor() {} 

CreatedConstructor.prototype = Object.create(Parent.prototype); 
CreatedConstructor.prototype.constructor = CreatedConstructor;  set right constructor for further using

CreatedConstructor.prototype.create =  create() { 
  .constructor();
} 

 it's pretty fine

现在很清楚为什么更改构造函数会很有用，再看下面的例子：

 ParentWithStatic() {}

ParentWithStatic.startPosition = { x: 0,y:0 };
ParentWithStatic.getStartPosition =  getStartPosition() {
  .startPosition;
} 

 Child(x,y) {
  this.position = {
    x: x,y: y
  };
}

Child.prototype = Object.create(ParentWithStatic.prototype); 
Child.prototype.constructor = Child;

Child.prototype.getOffsetByInitialPosition =  getOffsetByInitialPosition() {
  var position = .position;
  var startPosition = this.constructor.getStartPosition();  error undefined is not a function,since the constructor is Child

  return {
    offsetX: startPosition.x - position.x,offsetY: startPosition.y - position.y
  }
};

对于此示例，我们需要保持父构造函数继续正常工作。

方法

Object.setPrototypeOf()

Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即,内部[[Prototype]]属性）到另一个对象或 null。
语法：Object.setPrototypeOf(obj,prototype)
参数：

obj：要设置其原型的对象。
prototype：该对象的新原型(一个对象或 null)。

如果对象的[[Prototype]]被修改成不可扩展(通过 Object.isExtensible()查看)，就会抛出 TypeError异常。如果prototype参数不是一个对象或者null(例如，数字，字符串，boolean，或者 undefined)，则什么都不做。否则，该方法将obj的[[Prototype]]修改为新的值。

Object.setPrototypeOf()是ECMAScript 6最新草案中的方法，相对于 Object.prototype.__proto__ ，它被认为是修改对象原型更合适的方法。

例如：

var dict = Object.setPrototypeOf({},null);

Polyfill

使用较旧的 Object.prototype.__proto__ 属性，我们可以很容易地定义Object.setPrototypeOf 如果它不可用：

 仅适用于Chrome和FireFox，在IE中不工作：
Object.setPrototypeOf = Object.setPrototypeOf ||  (obj,proto) {
  obj.__proto__ = proto;
   obj; 
}

Object.getPrototypeOf()

描述：方法返回指定对象的原型（内部[[Prototype]]属性的值）。

语法：

Object.getPrototypeOf(object)

参数：object，要返回其原型的对象。

返回值：给定对象的原型。如果没有继承属性，则返回 null 。

实例：

var proto = {};
var obj = Object.create(proto);
console.log(Object.getPrototypeOf(obj) === proto); // true

var reg = /a/;
console.log(Object.getPrototypeOf(reg) === RegExp.prototype); Object.getPrototypeOf( Object )是把Object这一构造函数看作对象，
//返回的当然是函数对象的原型，也就是 Function.prototype。
console.log(Object.getPrototypeOf(Object)== Function.prototype) true

Object.values()

Object.values()@H_830_502@方法返回一个给定对象自身的所有可枚举属性值的数组，值的顺序与使用for...in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。

语法：

Object.values(obj)

参数：obj，被返回可枚举属性值的对象。

返回值：一个包含对象自身的所有可枚举属性值的数组。

var obj = { foo: 'bar',baz: 42 }; console.log(Object.values(obj)); ['bar',42] array like object var obj = { 0: 'a',1: 'b',2: 'c' ['a','b','c'] array like object with random key ordering when we use numeric keys,the value returned in a numerical order according to the keys var an_obj = { 100: 'a',2: 'b',7: 'c' }; console.log(Object.values(an_obj)); ['b','c','a'] getFoo is property which isn't enumerable var my_obj = Object.create({},{ getFoo: { value: function() { .foo; } } }); my_obj.foo = 'bar'; console.log(Object.values(my_obj)); ['bar'] non-object argument will be coerced to an object console.log(Object.values('foo')); ['f','o','o']

如果要 Object.values兼容不支持它的旧环境，可在 tc39/proposal-object-values-entries 或 es-shims/Object.values 中找到 Polyfill 。根据Object.keys()@H_830_502@的Polyfill仿写一个：

if (!Object.values) Object.values = (obj) { if (obj !== Object(obj)) throw new TypeError('Object.values called on a non-object'); var val=[],key; for (key in obj) { if (Object.prototype.hasOwnProperty.call(obj,key)) { val.push(obj[key]); } } val; }