本文概要

一、概述

JavaScript 的所有其他对象都继承自Object对象，即那些对象都是Object的实
Object对象的原生方法分成两类：Object本身的方法与Object的实例方法。

• Object对象本身的方法
  所谓“本身的方法”就是直接定义在Object对象的静态方法
  Object.print = function (o) { console.log(o) };

• Object的实例方法
  所谓实例方法就是定义在Object原型对象Object.prototype上的方法。它可以被Object实例直接使用

Object.prototype.print = function () {
  console.log(this);
};

var obj = new Object();
obj.print() // Object

静态方法与实例方法的区别：
1、从定义上，实例方法要用到function这个对象中的prototype属性来定义，静态方法通过Object.直接定义
2、从方法调用上，静态方法可以直接通过Object.来调用，实例方法要通过先定义一个引用变量，指向构造函数定义的新对象

Object()
Object本身是一个函数，可以当作工具方法使用，将任意值转为对象。这个方法常用于保证某个值一定是对象

Object 构造函数
var obj = new Object();

Object 构造函数为给定值创建一个对象包装器。如果给定值是 null 或 undefined，将会创建并返回一个空对象，否则，将返回一个与给定值对应类型的对象。

Object不仅可以当作工具函数使用，还可以当作构造函数使用，即前面可以使用new命令。
通过var obj = new Object()的写法生成新对象，与字面量的写法var obj = {}是等价的。或者说，后者只是前者的一种简便写法。

var o1 = {a: 1};
var o2 = new Object(o1);
o1 === o2 // true

var obj = new Object(123);
obj instanceof Number // true

虽然用法相似，但是Object(value)与new Object(value)两者的语义是不同的，Object(value)表示将value转成一个对象，new Object(value)则表示新生成一个对象，它的值是value。

二、Object 的静态方法

所谓“静态方法”，是指部署在Object对象自身的方法。

Object的静态方法：
Object.keys()：遍历对象的属性，返回属性名组成的数组 ，只返回可枚举的属性
Object.getOwnPropertyNames()：遍历对象的属性，返回属性名组成的数组，不可枚举与可枚举属性全部返回
Object.create()：该方法可以指定原型对象和属性，返回一个新的对象。
Object.entries()：返回给定对象自身可枚举属性的 [key, value] 数组。
Object.getPrototypeOf()：返回指定对象的原型对象。
Object.setPrototypeOf()：设置对象的原型（即内部 [[Prototype]] 属性）。
Object.getOwnPropertySymbols()：返回一个数组，它包含了指定对象自身所有的符号属性。
Object.is()：比较两个值是否相同。所有 NaN 值都相等（这与==和===不同）
Object.assign()：通过复制一个或多个对象来创建一个新的对象。
Object.defineProperty()：给对象添加一个属性并指定该属性的配置。
Object.defineProperties()：给对象添加多个属性并分别指定它们的配置。
Object.getOwnPropertyDescriptor()：返回对象指定的属性配置。
Object.preventExtensions()：防止对象的任何扩展。
Object.isExtensible()：判断对象是否可扩展。
Object.seal()：防止其他代码删除对象的属性。
Object.isSealed()：判断对象是否已经密封。
Object.freeze()：冻结对象：其他代码不能删除或更改任何属性。
Object.isFrozen()：判断对象是否已经冻结。

Object.keys()，Object.getOwnPropertyNames()

Object.keys方法和Object.getOwnPropertyNames方法都用来遍历对象的属性
Object.keys方法的参数是一个对象，返回一个数组。该数组的成员都是该对象自身的（而不是继承的）所有属性名

var obj = {
  p1: 123,
  p2: 456
};

Object.keys(obj) // ["p1", "p2"]

Object.getOwnPropertyNames方法与Object.keys类似，也是接受一个对象作为参数，返回一个数组，包含了该对象自身的所有属性名。

var obj = {
  p1: 123,
  p2: 456
};

Object.getOwnPropertyNames(obj) // ["p1", "p2"]

对于一般的对象来说，Object.keys()和Object.getOwnPropertyNames()返回的结果是一样的。只有涉及不可枚举属性时，才会有不一样的结果。Object.keys方法只返回可枚举的属性，Object.getOwnPropertyNames方法还返回不可枚举的属性名。

var a = ['Hello', 'World'];

Object.keys(a) // ["0", "1"]
Object.getOwnPropertyNames(a) // ["0", "1", "length"]

一般情况下，几乎总是使用Object.keys方法，遍历对象的属性。

Object.create()

该方法可以指定原型对象和属性，返回一个新的对象。

语法：Object.create(proto[, propertiesObject])
参数：proto：新创建对象的原型对象
     propertiesObject  ：是要添加到新创建对象的不可枚举（默认）属性（即其自身定义的属性，而不是其原型链上的枚举属性）
返回值：一个新对象，带着指定的原型对象和属性。
注意：如果`propertiesObject`参数是 null或非原始包装对象，则抛出一个 TypeError异常。

    //创建一个Obj对象
    var Obj = {
        name: 'luck',
        age: 18,
        show: function () {
            console.log(this.name + " is " + this.age);
        }
    }

    //MyObj 继承obj, __proto__指向Obj
    var status = false
    var MyObj = Object.create(Obj, {
        like: {
            value: "little_luck", // 初始化赋值
            writable: true,       // 是否是可改写的
            configurable: true,   // 是否能够删除，是否能够被修改
            enumerable: true      //是否可以用for in 进行枚举
        },
        hobit: {
            configurable: true,
            get: function () { 
                // get对象hobit属性时触发的方法
                console.log('change my hobit');
                return status
             }, 
            set: function (value) {    
                status = true                           
                console.log('my hobit is '+ value);
            }
        }
    });
    console.log(MyObj) //{like: "little_luck"}
    MyObj.hobit = 'play'
    console.log(MyObj.hobit)  // true
    console.log(MyObj.__proto__)
/*
{name: "luck", age: 18, show: ƒ}
age: 18
name: "luck"
show: ƒ ()
__proto__: Object
    console.log(MyObj.name) 
*/
  console.log(MyObj.name) // luck
  

Object.setPrototypeOf()

设置对象的原型（即内部 [[Prototype]] 属性）。

Object.getPrototypeOf()

返回指定对象的原型对象。

var num = 3.14
console.log(Object.getPrototypeOf(num)) // Number

Object.entries()

返回给定对象自身可枚举属性的 [key, value] 数组。

var obj = {
      name:'luck',
      age:18,
      profession:'programmer'
 }
console.log(Object.entries(obj))
// [["name", "luck"],["age", "18"],["profession","programmer"]]

Object.is()

比较两个值是否相同。所有 NaN 值都相等（这与==和===不同）

// 在es5中我们比较两个值是否相等，用两个运算符：==、===
// ==  自动转换数据类型
// === NaN不等于自身，以及+0等于-0。
// es6中部署了一个新的方法Object.is来比较两个值严格相等，与=== 基本一致，不同之处只有两个：一是+0不等于-0，二是NaN等于自身

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

Object.assign()

用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

如果目标对象中的属性具有相同的键，则属性将被源对象中的属性覆盖。后面的源对象的属性将类似地覆盖前面的源对象的属性。

Object.assign 方法只会拷贝源对象自身的并且可枚举的属性到目标对象。该方法使用源对象的[[Get]]和目标对象的[[Set]]，所以它会调用相关 getter 和 setter.

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
//  { a: 1, b: 4, c: 5 }

console.log(returnedTarget);
//  { a: 1, b: 4, c: 5 }

Object.defineProperty()，Object.defineProperties()

Object.defineProperty()：通过描述对象，定义某个属性。
Object.defineProperties()：通过描述对象，定义多个属性。

javaScript 提供了一个内部数据结构，用来描述对象的属性，控制它的行为，比如该属性是否可写、可遍历等等。这个内部数据结构称为“属性描述对象”（attributes object）。每个属性都有自己对应的属性描述对象，保存该属性的一些元信息。

Object.defineProperty()方法允许通过属性描述对象，定义或修改一个属性，然后返回修改后的对象，它的用法如下
Object.defineProperty(object, propertyName, attributesObject)

Object.defineProperty方法接受三个参数，依次如下。
object：属性所在的对象
propertyName：字符串，表示属性名
attributesObject：属性描述对象

var obj = Object.defineProperty({}, 'p', {
  value: 123,
  writable: false,
  enumerable: true,
  configurable: false
});

obj.p // 123

obj.p = 246;
obj.p // 123

如果属性已经存在，Object.defineProperty()方法相当于更新该属性的属性描述对象
如果一次性定义或修改多个属性，可以使用Object.defineProperties()方法。

var obj = Object.defineProperties({}, {
  p1: { value: 123, enumerable: true },
  p2: { value: 'abc', enumerable: true },
  p3: { get: function () { return this.p1 + this.p2 },
    enumerable:true,
    configurable:true
  }
});

obj.p1 // 123
obj.p2 // "abc"
obj.p3 // "123abc"

注意，一旦定义了取值函数get（或存值函数set），就不能将writable属性设为true，或者同时定义value属性，否则会报错。

var obj = {};

Object.defineProperty(obj, 'p', {
  value: 123,
  get: function() { return 456; }
});
// TypeError: Invalid property.
// A property cannot both have accessors and be writable or have a value

Object.defineProperty(obj, 'p', {
  writable: true,
  get: function() { return 456; }
});
// TypeError: Invalid property descriptor.
// Cannot both specify accessors and a value or writable attribute

上面代码中，同时定义了get属性和value属性，以及将writable属性设为true，就会报错。

Object.defineProperty()和Object.defineProperties()参数里面的属性描述对象，writable、configurable、enumerable这三个属性的默认值都为false。

var obj = {};
Object.defineProperty(obj, 'foo', {});
Object.getOwnPropertyDescriptor(obj, 'foo')
// {
//   value: undefined,
//   writable: false,
//   enumerable: false,
//   configurable: false
// }

ECMAScript 中有两种属性描述对象:数据属性与访问器属性

1、数据属性

数据属性包含一个数据值的位置，在这个位置可以读取和写入值
Configurable：表示能否通过 delete 删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。默认值为 true
Enumerable：表示能否通过 for-in 循环返回属性。默认值为 true
Writable: 表示能否修改属性的值。默认值是true
Value：包含这个属性的数据值。读取属性值的时候，从这个位置读;写入属性值的时候，把新值保存在这个位置。这个特性的默认值为 undefined
Object.defineProperty()三个参数：属性所在的对象、属性的名字和一个描述符对象

 var person = {};
    Object.defineProperty(person, "name", {
        writable: false,
        configurable: false,
        value: "luckfine"
    });
    alert(person.name); //luckfine
    person.name = "范小饭"; 
    delete person.name
    alert(person.name); //luckfine

    // 这个属性的值是不可修改 的，如果尝试为它指定新值，则在非严格模式下，赋值操作将被忽略;在严格模式下，赋值操作将会导 致抛出错误。
    //configurable 设置为 false，表示不能从对象中删除属性,可以多次调用 Object.defineProperty()方法修改同一个属性，但在把 configurable 特性设置为 false 之后就会有限制了

2、访问器属性:

它们包含一对儿 getter 和 setter 函数,在读取访问器属性时，会调用 getter 函数，这个函数负责返回有效的值;在写入访问器属性时，会调用 setter 函数并传入新值，这个函数负责决定如何处理数据
Configurable:表示能否通过 delete 删除属性从而重新定义属性，能否修改属性的特 性，或者能否把属性修改为数据属性 默认值为true
Enumerable:表示能否通过 for-in 循环返回属性 默认值为false
Get:在读取属性时调用的函数。默认值为 undefined
Set:在写入属性时调用的函数。默认值为 undefine

var obj = Object.defineProperty({}, 'p', {
  get: function () {
    return 'getter';
  },
  set: function (value) {
    console.log('setter: ' + value);
  }
});

obj.p // "getter"
obj.p = 123 // "setter: 123"

Object.getOwnPropertyDescriptor()

获取某个属性的描述对象。
Object.getOwnPropertyDescriptor()方法可以获取属性描述对象。它的第一个参数是目标对象，第二个参数是一个字符串，对应目标对象的某个属性名

var obj = { p: 'a' };

Object.getOwnPropertyDescriptor(obj, 'p')
// Object { value: "a",
//   writable: true,
//   enumerable: true,
//   configurable: true
// }

Object.preventExtensions()

有时需要冻结对象的读写状态，防止对象被改变。JavaScript 提供了三种冻结方法，最弱的一种是Object.preventExtensions，其次是Object.seal，最强的是Object.freeze

Object.preventExtensions方法可以使得一个对象无法再添加新的属性。

var obj = new Object();
Object.preventExtensions(obj);

Object.defineProperty(obj, 'p', {
  value: 'hello'
});
// TypeError: Cannot define property:p, object is not extensible.

obj.p = 1;
obj.p // undefined

Object.isExtensible()

Object.isExtensible方法用于检查一个对象是否使用了Object.preventExtensions方法。也就是说，检查是否可以为一个对象添加属性。

var obj = new Object();

Object.isExtensible(obj) // true
Object.preventExtensions(obj);
Object.isExtensible(obj) // false

Object.seal()

Object.seal方法使得一个对象既无法添加新属性，也无法删除旧属性。

var obj = { p: 'hello' };
Object.seal(obj);

delete obj.p;
obj.p // "hello"

obj.x = 'world';
obj.x // undefined
// Object.seal实质是把属性描述对象的configurable属性设为false，因此属性描述对象不再能改变了。

Object.isSealed()

Object.isSealed方法用于检查一个对象是否使用了Object.seal方法。

var obj = { p: 'a' };

Object.seal(obj);
Object.isSealed(obj) // true
Object.isExtensible(obj) // false

Object.freeze()

Object.freeze方法可以使得一个对象无法添加新属性、无法删除旧属性、也无法改变属性的值，使得这个对象实际上变成了常量

var obj = {
  p: 'hello'
};

Object.freeze(obj);

obj.p = 'world';
obj.p // "hello"

obj.t = 'hello';
obj.t // undefined

delete obj.p // false
obj.p // "hello"

Object.isFrozen()

Object.isFrozen方法用于检查一个对象是否使用了Object.freeze方法。

var obj = {
  p: 'hello'
};

Object.freeze(obj);
Object.isFrozen(obj) // true

三、Object 的实例方法

Object实例对象的方法，主要有以下六个。

Object.prototype.valueOf()：返回当前对象对应的值。
Object.prototype.toString()：返回当前对象对应的字符串形式。
Object.prototype.toLocaleString()：返回当前对象对应的本地字符串形式。
Object.prototype.hasOwnProperty()：判断某个属性是否为当前对象自身的属性，还是继承自原型对象的属性。
Object.prototype.isPrototypeOf()：判断当前对象是否为另一个对象的原型。
Object.prototype.propertyIsEnumerable()：判断某个属性是否可枚举。

Object.prototype.valueOf()

valueOf方法的作用是返回一个对象的“值”，默认情况下返回对象本身

var obj = new Object();
obj.valueOf() === obj // true

valueOf方法的主要用途是，JavaScript 自动类型转换时会默认调用这个方法

var obj = new Object();
1 + obj // "1[object Object]"

Object.prototype.toString()

toString方法的作用是返回一个对象的字符串形式，默认情况下返回类型字符串。

var o1 = new Object();
o1.toString() // "[object Object]"

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

数组、字符串、函数、Date 对象都分别部署了自定义的toString方法，覆盖了Object.prototype.toString方法

[1, 2, 3].toString() // "1,2,3"

'123'.toString() // "123"

(function () {
  return 123;
}).toString()
// "function () {
//   return 123;
// }"

(new Date()).toString()
// "Tue May 10 2016 09:11:31 GMT+0800 (CST)"

toString() 的应用：判断数据类型
Object.prototype.toString方法返回对象的类型字符串，因此可以用来判断一个值的类型。Object.prototype.toString.call(value)
不同数据类型的Object.prototype.toString方法返回值如下。

数值：返回[object Number]。
字符串：返回[object String]。
布尔值：返回[object Boolean]。
undefined：返回[object Undefined]。
null：返回[object Null]。
数组：返回[object Array]。
arguments 对象：返回[object Arguments]。
函数：返回[object Function]。
Error 对象：返回[object Error]。
Date 对象：返回[object Date]。
RegExp 对象：返回[object RegExp]。
其他对象：返回[object Object]。

Object.prototype.toString.call(2) // "[object Number]"
Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(Math) // "[object Math]"
Object.prototype.toString.call({}) // "[object Object]"
Object.prototype.toString.call([]) // "[object Array]"

利用这个特性，可以写出一个比typeof运算符更准确的类型判断函数。

var type = function (o){
  var s = Object.prototype.toString.call(o);
  return s.match(/\[object (.*?)\]/)[1].toLowerCase();
};

type({}); // "object"
type([]); // "array"
type(5); // "number"
type(null); // "null"
type(); // "undefined"
type(/abcd/); // "regex"
type(new Date()); // "date"

在上面这个type函数的基础上，还可以加上专门判断某种类型数据的方法。

var type = function (o){
  var s = Object.prototype.toString.call(o);
  return s.match(/\[object (.*?)\]/)[1].toLowerCase();
};

['Null',
 'Undefined',
 'Object',
 'Array',
 'String',
 'Number',
 'Boolean',
 'Function',
 'RegExp'
].forEach(function (t) {
  type['is' + t] = function (o) {
    return type(o) === t.toLowerCase();
  };
});

type.isObject({}) // true
type.isNumber(NaN) // true
type.isRegExp(/abc/) // true

Object.prototype.toLocaleString()

Object.prototype.toLocaleString方法与toString的返回结果相同，也是返回一个值的字符串形式

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

举例来说，日期的实例对象的toString和toLocaleString返回值就不一样，而且toLocaleString的返回值跟用户设定的所在地域相关。

var date = new Date();
date.toString() // "Tue Jan 01 2018 12:01:33 GMT+0800 (CST)"
date.toLocaleString() // "1/01/2018, 12:01:33 PM"

Object.prototype.hasOwnProperty()

Object.prototype.hasOwnProperty方法接受一个字符串作为参数，返回一个布尔值，表示该实例对象自身是否具有该属性。

var obj = {
  p: 123
};

obj.hasOwnProperty('p') // true
obj.hasOwnProperty('toString') // false

Object.prototype.propertyIsEnumerable()

实例对象的propertyIsEnumerable()方法返回一个布尔值，用来判断某个属性是否可遍历。注意，这个方法只能用于判断对象自身的属性，对于继承的属性一律返回false。

var obj = {};
obj.p = 123;

obj.propertyIsEnumerable('p') // true
obj.propertyIsEnumerable('toString') // false

本文参考：
JavaScript 教程
MDN web docs