js Object常用方法

这一篇简单介绍es6 Object的新属性方法.

1.hasOwnProperty

说明： 会返回一个布尔值，指示对象自身属性中是否具有指定的属性
语法： obj.hasOwnProperty(prop)
参数： prop: 要检测的属性 字符串 名称或者 Symbol
返回值： 用来判断某个对象是否含有指定的属性的 Boolean 。
所有继承了 Object 的对象都会继承到 hasOwnProperty 方法。这个方法可以用来检测一个对象是否含有特定的自身属性；和 in 运算符不同，该方法会忽略掉那些从原型链上继承到的属性。
①. 判断属性是否存在：

var o = new Object();
o.prop = 'exists';

function changeO() {
  o.newprop = o.prop;
  delete o.prop;
}

o.hasOwnProperty('prop');   // 返回 true
changeO();
o.hasOwnProperty('prop');   // 返回 false

②. 遍历一个对象的所有自身属性

Object.prototype.type='object';
var obj = {name: 'zxx'};
for(var i in obj){
	if(obj.hasOwnProperty(i)){
	console.log(i, obj[i]); // name, zxx
}else{
	console.log('继承的属性：' + i, obj[i]); // 继承的属性： type, object
}
}

2. isPrototypeOf

说明： 用于测试一个对象是否存在于另外一个对象的原型链上。
语法： prototypeObj.isPrototypeOf(object)
参数： object表示在该对象的原型链上搜寻， prototypeObj 对象且不能为null,否则会报TypeError
返回值： Boolean 表示调用对象是否在另外一个对象的原型链上

function Point(x, y) {
  this.x = x;
  this.y = y;
}
var p = new Point(1, 2);
Point.prototype.isPrototypeOf(p); // true
Object.prototype.isPrototypeOf(p); // true

1. create
   说明： 该方法用于创建一个新对象， 使用现有对象来提供新创建对象的__proto__
   语法： Object.create(proto, [propertiesObject])
   参数： proto（必需） 表示新创建对象的原型对象； propertiesObject（可选） 如果没有指定为 undefined，则是要添加到新创建对象的可枚举属性（即其自身定义的属性，而不是其原型链上的枚举属性）对象的属性描述符以及相应的属性名称。这些属性对应Object.defineProperties()的第二个参数。
   返回值： 一个带着指定的原型对象和属性的新对象。

// 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.');
};
function Rectangle() {
}
Rectangle.prototype = Object.create(Shape.prototype);
var rect = new Rectangle();
console.log(rect instanceof Rectangle); // true
console.log(rect instanceof Shape); // true
rect.move(1, 1); //  'Shape moved.'

2. freeze
   说明： Object.freeze()方法可以冻结一个对象。一个被冻结的对象再也不能被修改（不能添加新的属性，不能删除已有属性，不能修改已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值，并且冻结一个对象后该对象的原型也不能被修改）
   返回值：被冻结的对象。

var obj = {
  prop: function() {},
  foo: 'bar'
};

// 新的属性会被添加, 已存在的属性可能会被修改或移除
obj.foo = 'baz';
obj.lumpy = 'woof';
delete obj.prop;

// 作为参数传递的对象与返回的对象都被冻结
// 所以不必保存返回的对象（因为两个对象全等）
var o = Object.freeze(obj);

o === obj; // true
Object.isFrozen(obj); // === true

// 现在任何改变都会失效
obj.foo = 'quux'; // 静默地不做任何事
// 静默地不添加此属性
obj.quaxxor = 'the friendly duck';

// 在严格模式，如此行为将抛出 TypeErrors
function fail(){
  'use strict';
  obj.foo = 'sparky'; // throws a TypeError
  delete obj.quaxxor; // 返回true，因为quaxxor属性从来未被添加
  obj.sparky = 'arf'; // throws a TypeError
}

fail();

// 试图通过 Object.defineProperty 更改属性
// 下面两个语句都会抛出 TypeError.
Object.defineProperty(obj, 'ohai', { value: 17 });
Object.defineProperty(obj, 'foo', { value: 'eit' });

// 也不能更改原型
// 下面两个语句都会抛出 TypeError.
Object.setPrototypeOf(obj, { x: 20 })
obj.__proto__ = { x: 20 }

3. keys

说明： 该方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致 。

var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); //  ['0', '1', '2']

var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.keys(obj)); //  ['0', '1', '2']

var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj)); //  ['2', '7', '100']

var myObj = Object.create({}, {
  getFoo: {
    value: function () { return this.foo; }
  } 
});

myObj.foo = 1;
console.log(Object.keys(myObj)); //  ['foo']

注意： 在ES5里，如果此方法的参数不是对象（而是一个原始值），那么它会抛出 TypeError。在ES2015中，非对象的参数将被强制转换为一个对象。

Object.keys("foo");
// "Object.keys: 参数不是 Object"

ES2015中

Object.keys("foo");  // ["0", "1", "2"]     

4. defineProperty
5. defineProperties
6. getOwnPropertyDescriptor
7. getOwnPropertyNames
8. getPrototypeOf
9. preventExtensions
10. isExtensible
11. seal
12. isSealed
13. isFrozen

3.is

说明： 用于判断两个值是否是相同的值。
语法： Object.is(value1, value2);
参数： value1，value2分别表示第一个，第二个需要比较的值
返回值： Boolean 表示两个参数是否相同。

Object.is(undefined, undefined);  // true
Object.is(null, null);  // true
Object.is('test', 'test');  // true

var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, foo); // true
Object.is(foo, bar);// false

// 特例
Object.is(0, -0);    // false
Object.is(-0, -0);   // true
Object.is(NaN, 0/0); // true

Polyfill

Object.is = Object.is || function (x, y) {
	if (x === y) {
		// +0 != -0
		return x !== 0 || 1 / x === 1 / y
	} else {
		// NaN == NaN
		return x !== x && y !== y;
	}
}

4. create

Polyfill

// 思路：将传入的对象作为原型
function create(obj) {
  function F() {}
  F.prototype = obj;
  F.prototype.constructor = F; 
  return new F()
}