对象相关方法汇总

前面介绍了数组和字符串相关方法，这篇我们来继续总结一下对象的相关方法。

1、hasOwnProperty() 检查对象自身属性中是否具有指定属性

语法：obj.hasOwnProperty(prop)

参数:

prop 要检测的属性的 String 字符串形式表示的名称，或者 Symbol。

示例：

o = new Object();
o.hasOwnProperty('prop'); // 返回 false
o.prop = 'exists';
o.hasOwnProperty('prop'); // 返回 true
delete o.prop;
o.hasOwnProperty('prop'); // 返回 false

作用：hasOwnProperty() 方法可以用来检测一个对象是否含有特定的自身属性。和 in 运算符不同，该方法会忽略掉那些从原型链上继承到的属性。

注意：即使属性的值是 null 或 undefined，只要属性存在，hasOwnProperty 依旧会返回 true。

2、isPrototypeOf() 测试一个对象是否存在于另一个对象的原型链上

语法：prototypeObj.isPrototypeOf(object)

参数：

object 在该对象的原型链上搜寻

示例：

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

作用：isPrototypeOf() 方法检查一个对象是否存在于另一个对象的原型链上。

3、propertyIsEnumerable()检测指定的属性是否可枚举

语法：obj.propertyIsEnumerable(prop)

参数：

prop 需要测试的属性名

示例：

var o = {};
var a = [];
o.prop = 'is enumerable';
a[0] = 'is enumerable';

o.propertyIsEnumerable('prop'); // 返回 true
a.propertyIsEnumerable(0);      // 返回 true

作用：propertyIsEnumerable()方法可以确定对象中指定的属性是否可以被 for...in 循环枚举，但是通过原型链继承的属性除外。如果对象没有指定的属性，则此方法返回 false。

4、Object.is() 判断两个值是否相同

语法：Object.is(value1, value2)

示例：

Object.is('foo', 'foo');     // true
Object.is(0, -0);            // false
Object.is(0, +0);            // true
Object.is(-0, -0);           // true
Object.is(NaN, 0/0);         // true

作用：bject.is()判断两个值是否相同。

注意：这种相等性判断逻辑和传统的 == 运算不同，== 运算符会对它两边的操作数做隐式类型转换（如果它们类型不同），然后才进行相等性比较，（所以才会有类似 "" == false 等于 true 的现象），但 Object.is 不会做这种类型转换。

5、Object.isExtensible()判断一个对象是否是可扩展的

语法：Object.isExtensible(obj)

示例：

// 新对象默认是可扩展的.
var empty = {};
Object.isExtensible(empty); // === true

// ...可以变成不可扩展的.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// 密封对象是不可扩展的.
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// 冻结对象也是不可扩展.
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false

作用：Object.isExtensible()方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。

注意：默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__ 属性可以被更改。Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）。

6、Object.isFrozen()判断一个对象是否被冻结

语法：Object.isFrozen(obj)

示例：

// 一个对象默认是可扩展的,所以它也是非冻结的.
Object.isFrozen({}); // === false

// 一个不可扩展的空对象同时也是一个冻结对象.
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen) //=== true;

// 一个非空对象默认也是非冻结的.
var oneProp = { p: 42 };
Object.isFrozen(oneProp) //=== false

// 让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象,
// 因为p属性仍然是可以配置的(而且可写的).
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp) //=== false

作用：

注意：一个对象是冻结的是指它不可扩展，所有属性都是不可配置的，且所有数据属性（即没有getter或setter组件的访问器的属性）都是不可写的。使用Object.freeze可冻结对象。 

7、Object.isSealed()判断对象是否被密封

语法：Object.isSealed(obj)

示例：

// 新建的对象默认不是密封的.
var empty = {};
Object.isSealed(empty); // === false

// 如果你把一个空对象变的不可扩展,则它同时也会变成个密封对象.
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// 但如果这个对象不是空对象,则它不会变成密封对象,因为密封对象的所有自身属性必须是不可配置的
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// 如果把这个属性变的不可配置,则这个对象也就成了密封对象.
Object.defineProperty(hasProp, "fee", { configurable: false });
Object.isSealed(hasProp); // === true

作用：Object.isSealed()方法判断一个对象是否被密封。

注意：密封对象是指那些不可 扩展 的，且所有自身属性都不可配置且因此不可删除（但不一定是不可写）的对象。

8、Object.assign() 将可枚举属性值从一个或多个源对象复制到目标对象

语法：Object.assign(target, ...sources)

示例：

const obj = { a: 1 };
const copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }

作用：Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

注意：这种方法实现的是浅拷贝。

9、Object.create()使用指定对象作为新创建对象的原型

语法：Object.create(proto, propertiesObject)

参数：

proto 新创建对象的原型对象。

propertiesObject 可选。如果没有指定为 undefined，则是要添加到新创建对象的不可枚举（默认）属性（即其自身定义的属性，而不是其原型链上的枚举属性）对象的属性描述符以及相应的属性名称。这些属性对应Object.defineProperties()的第二个参数。

示例：

const person = {
  isHuman: false,
  printIntroduction: function() {
    console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
  }
};

const me = Object.create(person);

me.name = 'Matthew'; // "name" is a property set on "me", but not on "person"
me.isHuman = true; // inherited properties can be overwritten

me.printIntroduction();
// expected output: "My name is Matthew. Am I human? true"

作用：Object.create()方法创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。 

10、Object.setPrototypeOf()设置一个指定的对象的原型

语法：Object.setPrototypeOf(obj, prototype)

参数：

obj 要设置其原型的对象

prototype 该对象的新原型(一个对象 或 null)

示例：

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

作用：为一个对象设置指定的原型。

11、Object.preventExtensions()让对象变得不可扩展

语法：Object.preventExtensions(obj)

示例：

const object1 = {};

Object.preventExtensions(object1);

try {
  Object.defineProperty(object1, 'property1', {
    value: 42
  });
} catch (e) {
  console.log(e);
  // Expected output: TypeError: Cannot define property property1, object is not extensible
}

作用：Object.preventExtensions()方法让一个对象变的不可扩展，也就是永远不能再添加新的属性。

12、Object.freeze()冻结一个对象

语法：Object.freeze(obj)

示例：

const obj = {
  prop: 42
};

Object.freeze(obj);

obj.prop = 33;
// 在严格模式下会报错

console.log(obj.prop);
// 42   没有修改成功

作用：Object.freeze() 方法可以冻结一个对象。

注意：一个被冻结的对象再也不能被修改；冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。此外，冻结一个对象后该对象的原型也不能被修改。

13、Object.seal()密封一个对象

语法：Object.seal(obj)

示例：

const object1 = {
  property1: 42
};

Object.seal(object1);
object1.property1 = 33;
console.log(object1.property1);
// expected output: 33

delete object1.property1; // cannot delete when sealed
console.log(object1.property1);
// expected output: 33

作用：Object.seal()方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置(属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。但属性的值仍然可以修改。)。当前属性的值只要原来是可写的就可以改变。

14、Object.defineProperties()直接对象上定义新属性或修改现有属性

语法：Object.defineProperties(obj, props)

参数：

obj 在其上定义或修改属性的对象。

示例：

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
});

作用：Object.defineProperties() 方法直接在一个对象上定义新的属性或修改现有属性，并返回该对象。

15、Object.defineProperty()直接在对象上定义一个新属性或修改现有属性

语法：Object.defineProperty(obj, prop, descriptor)

参数：

obj 要定义属性的对象。 

prop 要定义或修改的属性的名称或 Symbol 。

descriptor 要定义或修改的属性描述符。

示例：

const object1 = {};

Object.defineProperty(object1, 'property1', {
  value: 42,
  writable: false
});

object1.property1 = 77;
// throws an error in strict mode

console.log(object1.property1);
// expected output: 42  不可写，所以修改失败

作用：Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象。

16、Object.values()返回对象所有可枚举属性值的数组

语法：Object.values(obj)

示例：

var obj = { foo: 'bar', baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]

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

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

17、Object.keys()返回对象所有可枚举属性的字符串数组

语法：Object.keys(obj)

示例：

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

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

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

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

18、Object.entries()返回对象可枚举属性的键值对数组

语法：Object.entries(obj)

示例：

const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

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

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

作用：Object.entries()方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环还会枚举原型链中的属性）。

19、Object.fromEntries()把键值对列表转换为一个对象

语法：Object.fromEntries(iterable)

参数：

iterable 可迭代对象，类似 Array、Map 或者其它实现了可迭代协议的对象。

示例：

const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);

const obj = Object.fromEntries(entries);

console.log(obj);
// expected output: Object { foo: "bar", baz: 42 }

作用：Object.fromEntries()方法接收一个键值对的列表参数，并返回一个带有这些键值对的新对象。

注意：Object.fromEntries()是Object.entries() 的反转。

20、toString()返回一个表示该对象的字符串

语法：obj.toString()

示例：

function Dog(name) {
  this.name = name;
}

const dog1 = new Dog('Gabby');

Dog.prototype.toString = function dogToString() {
  return `${this.name}`;
};

console.log(dog1.toString());
// expected output: "Gabby"

var o = new Object();
o.toString(); // returns [object Object]

作用：toString()返回一个表示该对象的字符串。

注意：每个对象都有一个 toString()方法，当该对象被表示为一个文本值时，或者一个对象以预期的字符串方式引用时自动调用。默认情况下，toString() 方法被每个 Object 对象继承。如果此方法在自定义对象中未被覆盖，toString() 返回 "[object type]"（利用这一特性结合apply和call，可以用来作数据类型的判断），其中 type 是对象的类型。

21、valueOf()返回指定对象的原始值

语法：object.valueOf()

示例：

// Array：返回数组对象本身
var array = ["ABC", true, 12, -5];
console.log(array.valueOf() === array);   // true

// Date：当前时间距1970年1月1日午夜的毫秒数
var date = new Date(2013, 7, 18, 23, 11, 59, 230);
console.log(date.valueOf());   // 1376838719230

// Number：返回数字值
var num =  15.26540;
console.log(num.valueOf());   // 15.2654

// 布尔：返回布尔值true或false
var bool = true;
console.log(bool.valueOf() === bool);   // true

// Object：返回对象本身
var obj = {name: "张三", age: 18};
console.log( obj.valueOf() === obj );   // true

// String：返回字符串值
var str = "http://www.xyz.com";
console.log( str.valueOf() === str );   // true

作用：valueOf()返回该对象的原始值。

注意：默认情况下，valueOf方法由Object后面的每个对象继承。 每个内置的核心对象都会覆盖此方法以返回适当的值。如果对象没有原始值，则valueOf将返回对象本身。

22、toLocaleString()返回对象本地化的字符串表示

语法：obj.toLocaleString()

示例：

var obj = { a:1 };
obj.toString();  // "[object Object]"
obj.toLocaleString(); "[object Object]"

var a = new Number(123456);
a.toString(); // "123456"
a.toLocaleString(); // "123,456"

var b = new Date();
b.toString();  // "Tue Dec 11 2018 20:57:30 GMT+0800 (中国标准时间)"
b.toLocaleString();  // "2018/12/11 下午8:57:30"

var c = [Number(1234560), Boolean(false), new Date(), {}];
c.toString(); // "1234560,false,Tue Dec 11 2018 20:59:22 GMT+0800 (中国标准时间),[object Object]"
c.toLocaleString(); // "1,234,560,false,2018/12/11 下午8:59:22,[object Object]"

作用：toLocaleString() 方法返回一个该对象的字符串表示。此方法被用于派生对象为了特定语言环境的目的（locale-specific purposes）而重载使用。

注意：Array、Date、Number和Typed Array提供了它们本身的toLocaleString()实现。

23、Object.getOwnPropertyDescriptor()返回指定对象上指定自有属性属性描述符

语法：Object.getOwnPropertyDescriptor(obj, prop)

参数：

obj 需要查找的目标对象

prop 目标对象内属性名称

示例：

o = { bar: 42 };
d = Object.getOwnPropertyDescriptor(o, "bar");
// d {
//   configurable: true,
//   enumerable: true,
//   value: 42,
//   writable: true
// }

作用：Object.getOwnPropertyDescriptor() 方法返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）

24、Object.getOwnPropertyDescriptors()返回对象的所有自身属性描述符

语法：Object.getOwnPropertyDescriptors(obj)

示例：

const obj = {
    [Symbol('foo')]: 123,
    get bar() { return 'abc' },
};
console.log(Object.getOwnPropertyDescriptors(obj));
 
// Output:
// { [Symbol('foo')]:
//    { value: 123,
//      writable: true,
//      enumerable: true,
//      configurable: true },
//   bar:
//    { get: [Function: bar],
//      set: undefined,
//      enumerable: true,
//      configurable: true } }

作用：Object.getOwnPropertyDescriptors() 方法用来获取一个对象的所有自身属性的描述符。如果没有任何自身属性，则返回空对象。

25、Object.getOwnPropertyNames()返回对象所有属性名字符串组成的数组

语法：Object.getOwnPropertyNames(obj)

示例：

var arr = ["a", "b", "c"];
console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]

// 类数组对象
var obj = { 0: "a", 1: "b", 2: "c"};
console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]

作用：Object.getOwnPropertyNames()返回一个数组，该数组对元素是 obj自身拥有的枚举或不可枚举属性名称字符串（但不包括Symbol值作为名称的属性）。 数组中枚举属性的顺序与通过 for...in 循环（或 Object.keys）迭代该对象属性时一致。数组中不可枚举属性的顺序未定义。

26、Object.getOwnPropertySymbols()返回对象自身所有Symbol属性的数组

语法：Object.getOwnPropertySymbols(obj)

示例：

var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2
console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0])      // Symbol(a)

作用：Object.getOwnPropertySymbols()方法返回一个给定对象自身的所有 Symbol 属性的数组。

注意：所有的对象在初始化的时候不会包含任何的 Symbol，除非你在对象上赋值了 Symbol 否则Object.getOwnPropertySymbols()只会返回一个空的数组。

27、Object.getPrototypeOf()返回指定对象的原型

语法：Object.getPrototypeOf(object)

示例：

const prototype1 = {};
const object1 = Object.create(prototype1);

console.log(Object.getPrototypeOf(object1) === prototype1);
// expected output: true

var reg = /a/;
Object.getPrototypeOf(reg) === RegExp.prototype; // true

作用：Object.getPrototypeOf() 方法返回指定对象的原型（内部[[Prototype]]属性的值），没有则返回null。

结语

对象的方法到此就总结完啦，欢迎大家批评指正~~~撒花！！！