使用Object.getOwnPropertyNames(Object)可以得到
["length", "name", "prototype", "assign", "getOwnPropertyDescriptor", "getOwnPropertyDescriptors", "getOwnPropertyNames", "getOwnPropertySymbols", "is", "preventExtensions", "seal", "create", "defineProperties", "defineProperty", "freeze", "getPrototypeOf", "setPrototypeOf", "isExtensible", "isFrozen", "isSealed", "keys", "entries", "values"]
這就是對(duì)象屬性的名稱
es6的部分為["is","assign","getOwnPropertyDescriptors","setPrototypeOf","getPrototypeOf","keys","values","entries","fromEntries"]

Object.prototype

表示Object的原型對(duì)象
Object.getOwnPropertyNames(Object.prototype)
["constructor", "defineGetter", "defineSetter", "hasOwnProperty", "lookupGetter", "lookupSetter", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "proto", "toLocaleString"]
這是對(duì)象原型鏈上的屬性的名稱

幾乎所有的javascript對(duì)象都是Object實(shí)例 一個(gè)典型的對(duì)象繼承了Object.prototype的屬性(包括方法), 不過(guò)這些方法也可以覆蓋
Object.create(null)撞見(jiàn)的對(duì)象或者通過(guò)Object.setPrototypeOf()方法改變?cè)玩?可以創(chuàng)建不具有典型原型鏈繼承的對(duì)象

Object.assign(target,sources)

target:目標(biāo)對(duì)象
sources:源對(duì)象
用于將所有可美劇屬性的值從一個(gè)或多個(gè)源對(duì)象復(fù)制到目標(biāo)對(duì)象. 返回目標(biāo)對(duì)象

const object1 = {
  a: 1,
  b: 2,
  c: 3
};

const object2 = Object.assign({c: 4, d: 5}, object1);

console.log(object2.c, object2.d);
// expected output: 3 5

注意對(duì)象屬性覆蓋問(wèn)題
針對(duì)于深拷貝問(wèn)題药蜻，需要用到其他方法 因?yàn)镺bject.assign()拷貝的是屬性值 假如源對(duì)象sources的屬性值是一個(gè)指向?qū)ο蟮囊?它也只拷貝那個(gè)引用值班眯。

let obj1 = {a:0,b:{c:0}};
obj2 = Object.assign({},obj1);
console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}
obj2.b.c = 3
console.log(JSON.stringify(obj1));//{a:1,b:{c:3}}
console.log(JSON.stringify(obj2));//{a:1,b:{c:3}}

  // 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}}

Object.create(proto, [propertiesObject])

proto 新創(chuàng)建對(duì)象的原型對(duì)象
propertiesObject
創(chuàng)建一個(gè)新的對(duì)象,使用現(xiàn)有的對(duì)象來(lái)提供新創(chuàng)建的對(duì)象的proto

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 = 'Mathew';
me.isHuman = true;
me.printIntroduction();
//My name is Mathew. Am I human? true;
me.__proto__ === person //true

Object.defineProperties(obj,props)

obj 在其上定義或者修改屬性的對(duì)象
props 要定義其可枚舉屬性或者修改的屬性描述符的對(duì)象
可以通過(guò)Object.getOwnPropertyDescriptor()來(lái)獲取每個(gè)屬性的屬性描述符
configurable enumerable value writable get set
方法直接在一個(gè)對(duì)象上定義新的屬性或修改現(xiàn)有屬性蝇摸，并返回該對(duì)象

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

Object.defineProperty(obj,prop,descriptor)

方法會(huì)直接在一個(gè)對(duì)象定義一個(gè)新的屬性,或者修改一個(gè)對(duì)象的現(xiàn)有屬性,這個(gè)屬性是可枚舉的缀台，能夠在屬性枚舉期間呈現(xiàn)出來(lái)(for...in或者Object.keys())进统。并返回這個(gè)對(duì)象 默認(rèn)情況下,使用這個(gè)方法添加的屬性值是不可修改的
obj 要在其上定義屬性的對(duì)象
prop 要定義或者修改的屬性的名稱
descriptor 將被定義或者修改的屬性描述符

Object.defineProperty(obj, "key", {
  enumerable: false,
  configurable: false,
  writable: false,
  value: "static"
});

Object.entries(obj)

obj 可以返回其可枚舉屬性的鍵值對(duì)的對(duì)象
返回一個(gè)給定對(duì)象自身可枚舉屬性的鍵值對(duì)數(shù)組。
排列與使用for...in循環(huán)遍歷該對(duì)象時(shí)返回的順序一直(區(qū)別在于for...in循環(huán)也枚舉原型鏈中的屬性)

const object1 = { foo: 'bar', baz: 42 };
console.log(Object.entries(object1)[1]);
// expected output: Array ["baz", 42]

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

const result = Object.entries(object2).sort((a, b) => a - b);
console.log(Object.entries(result)[1]);
// expected output: Array ["1", Array ["1", "b"]]

Object.fromEntries(iterable)

iterable 要迭代的鍵值對(duì)數(shù)組
把鍵值對(duì)列表轉(zhuǎn)換成一個(gè)對(duì)象 相當(dāng)于Object.entries()的反轉(zhuǎn)函數(shù) 但是不知道為什么chrome瀏覽器不支持這個(gè)方法

const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }

const object1 = {a:1,b:2,c:3}
const object2 = Object.fromEntries(
    Object.entries(object1).map(([key,value]) => {
         return [key,value * 2] //這里用到了解構(gòu)賦值  key 和value 是entries返回的二維數(shù)組中的2個(gè)值
    })
)
console.log(object2);
//{a:2,b:4,c:6}

Object.freeze(obj)

obj要被凍結(jié)的對(duì)象
方法凍結(jié)一個(gè)對(duì)象尊蚁，凍結(jié)指的是不能向這個(gè)對(duì)象添加新的屬性驹饺，不能修改其已有屬性的值，不能刪除已有屬性最仑，以及不能修改該屬性已有屬性的可枚舉性藐俺、可配置性炊甲、可寫性。該方法返回被凍結(jié)的對(duì)象

const object1 = {property1:42}
const object2 = Object.freeze(object1)
object2.property1 = 33;
console.log(object2.property1)
//42

Object.isFrozen(obj)

obj被檢測(cè)的對(duì)象
方法判斷一個(gè)對(duì)象是否被凍結(jié) 一個(gè)對(duì)象是凍結(jié)的是指它不可擴(kuò)展 所有屬性都是不可配置的 且所有數(shù)據(jù)屬性都是不可寫的欲芹。

// 一個(gè)對(duì)象默認(rèn)是可擴(kuò)展的,所以它也是非凍結(jié)的.
Object.isFrozen({}); // === false

// 一個(gè)不可擴(kuò)展的空對(duì)象同時(shí)也是一個(gè)凍結(jié)對(duì)象.
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen) //=== true;

// 一個(gè)非空對(duì)象默認(rèn)也是非凍結(jié)的.
var oneProp = { p: 42 };
Object.isFrozen(oneProp) //=== false

// 讓這個(gè)對(duì)象變的不可擴(kuò)展,并不意味著這個(gè)對(duì)象變成了凍結(jié)對(duì)象,
// 因?yàn)閜屬性仍然是可以配置的(而且可寫的).
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp) //=== false

// ...如果刪除了這個(gè)屬性,則它會(huì)成為一個(gè)凍結(jié)對(duì)象.
delete oneProp.p;
Object.isFrozen(oneProp) //=== true

// 一個(gè)不可擴(kuò)展的對(duì)象,擁有一個(gè)不可寫但可配置的屬性,則它仍然是非凍結(jié)的.
var nonWritable = { e: "plep" };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, "e", { writable: false }); // 變得不可寫
Object.isFrozen(nonWritable) //=== false

// 把這個(gè)屬性改為不可配置,會(huì)讓這個(gè)對(duì)象成為凍結(jié)對(duì)象.
Object.defineProperty(nonWritable, "e", { configurable: false }); // 變得不可配置
Object.isFrozen(nonWritable) //=== true

// 一個(gè)不可擴(kuò)展的對(duì)象,擁有一個(gè)不可配置但可寫的屬性,則它仍然是非凍結(jié)的.
var nonConfigurable = { release: "the kraken!" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", { configurable: false });
Object.isFrozen(nonConfigurable) //=== false

// 把這個(gè)屬性改為不可寫,會(huì)讓這個(gè)對(duì)象成為凍結(jié)對(duì)象.
Object.defineProperty(nonConfigurable, "release", { writable: false });
Object.isFrozen(nonConfigurable) //=== true

// 一個(gè)不可擴(kuò)展的對(duì)象,值擁有一個(gè)訪問(wèn)器屬性,則它仍然是非凍結(jié)的.
var accessor = { get food() { return "yum"; } };
Object.preventExtensions(accessor);
Object.isFrozen(accessor) //=== false

// ...但把這個(gè)屬性改為不可配置,會(huì)讓這個(gè)對(duì)象成為凍結(jié)對(duì)象.
Object.defineProperty(accessor, "food", { configurable: false });
Object.isFrozen(accessor) //=== true

// 使用Object.freeze是凍結(jié)一個(gè)對(duì)象最方便的方法.
var frozen = { 1: 81 };
Object.isFrozen(frozen) //=== false
Object.freeze(frozen);
Object.isFrozen(frozen) //=== true

// 一個(gè)凍結(jié)對(duì)象也是一個(gè)密封對(duì)象.
Object.isSealed(frozen) //=== true

// 當(dāng)然,更是一個(gè)不可擴(kuò)展的對(duì)象.
Object.isExtensible(frozen) //=== false

Object.getOwnPropertyDescriptor(obj,prop)

obj 需要查找的目標(biāo)的對(duì)象
prop目標(biāo)對(duì)象內(nèi)屬性名稱(String類型)
方法放回指定對(duì)象上一個(gè)自由屬性對(duì)應(yīng)的屬性描述符卿啡。(自由屬性指的是直接賦予該對(duì)象的屬性，不需要從原型鏈上進(jìn)行查找的屬性)菱父。
value writable get set configurable enumerable

var o = {get foo (){return 17}};
var d = Object.getOwnPropertyDescriptor(o,'foo')
//d{
//    configurable:true,
//    enumerable:true,
//    get:/*the getter function*/,
//   set:undefined
//}

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

Object.getOwnPropertyDescriptors(obj)

obj 任意對(duì)象
方法用來(lái)獲取一個(gè)對(duì)象的所有自身屬性的描述符 如果沒(méi)有任何自身屬性 則返回空對(duì)象

o = {a:42}
var d = Object.getOwnPropertyDescriptors(o);
//d{
//    configurable:true,
//    value:42,
//    enumerable:true,
//    writable:true
//}

Object.getOwnPropertyNames(obj)

obj 一個(gè)對(duì)象颈娜，其自身的可枚舉和不可枚舉屬性的名稱被返回

var arr = [1,3,3];
console.log(Object.getOwnPropertyNames(arr));
// ["0", "1", "2", "length"]
var arr = {0:"a",1:"b"}
console.log(Object.getOwnPropertyNames(arr));
// ["0", "1"]
// 使用Array.forEach輸出屬性名和屬性值
Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) {
  console.log(val + " -> " + obj[val]);
});
// 輸出
// 0 -> a
// 1 -> b
// 2 -> c

//不可枚舉屬性依然還是會(huì)顯示出來(lái)
var obj = Object.create({},{
    getFoo:{
        value:function(){return this.foo},
        enumerable:false
    }
 });
obj.foo = 1;
console.log(Object.getOwnPropertyNames(obj));
// ["getFoo", "foo"]
console.log(Object.getOwnPropertyNames(obj).sort());
// ["foo", "getFoo"]
//如果只想要可枚舉的屬性可以通過(guò)Object.keys()或者for...in來(lái)解決  for...in 需要用到Object.hasOwnProperty()方法過(guò)濾
//如果只想要不可枚舉的屬性 可以通過(guò)Array.prototype.filter()和Object.keys()來(lái)做篩選去掉可枚舉的 剩余的就是不可枚舉的屬性

Object.getOwnPropertySymbols(obj)

obj要返回Symbol屬性的對(duì)象
方法返回一個(gè)給定對(duì)象自身的所有Symbol屬性的數(shù)組

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.getPrototypeOf(object)

object 要返回其原型的對(duì)象
方法返回指定對(duì)象的原型
如果給定對(duì)象的原型沒(méi)有繼承屬性 則返回null 比方說(shuō) 空對(duì)象{}的proto

JavaScript中的 Object 是構(gòu)造函數(shù)（創(chuàng)建對(duì)象的包裝器）。
一般用法是：
var obj = new Object();

所以：
Object.getPrototypeOf( Object );               // ? () { [native code] }
Object.getPrototypeOf( Function );             // ? () { [native code] }

Object.getPrototypeOf( Object ) === Function.prototype;        // true

Object.getPrototypeOf( Object )是把Object這一構(gòu)造函數(shù)看作對(duì)象浙宜，
返回的當(dāng)然是函數(shù)對(duì)象的原型官辽，也就是 Function.prototype。

正確的方法是粟瞬，Object.prototype是構(gòu)造出來(lái)的對(duì)象的原型同仆。
var obj = new Object();
Object.prototype === Object.getPrototypeOf( obj );              // true

Object.prototype === Object.getPrototypeOf( {} );               // true

Object.setPrototypeOf(obj,prototype)

obj 要設(shè)置其原型的對(duì)象
prototype 該對(duì)象的新原型(一個(gè)對(duì)象或者null)
方法設(shè)置一個(gè)指定的對(duì)象的原型 到另一個(gè)對(duì)象或者null

//如果對(duì)象的[[prototype]]被修改成不可擴(kuò)展，就會(huì)拋出TypeError異常裙品。如果prototype參數(shù)不是一個(gè)對(duì)象或者null(例如俗批，數(shù)字，字符串市怎，boolean扶镀，或者undefined)，則什么都不做焰轻。否則，該方法將obj的[[prototype]]修改為新的值昆雀。
//Object.setPrototypeOf()是es6的方法辱志。相對(duì)于Object.prototype.__proto__，它被認(rèn)為是修改對(duì)象原型更合適的方法狞膘。
var dict = Object.setPrototypeOf({},null);

Object.is(value1,value2)

value1 需要比較的第一個(gè)值
value2 需要比較的第二個(gè)值
方法判斷兩個(gè)值是否是相同的值 不同于== 和===
這個(gè)相同指的是完全相同

• 兩個(gè)值都是 undefined
• 兩個(gè)值都是 null
• 兩個(gè)值都是 true 或者都是 false
• 兩個(gè)值是由相同個(gè)數(shù)的字符按照相同的順序組成的字符串
• 兩個(gè)值指向同一個(gè)對(duì)象
• 兩個(gè)值都是數(shù)字并且
  • 都是正零 +0
  • 都是負(fù)零 -0
  • 都是 NaN
  • 都是除零和 NaN 外的其它同一個(gè)數(shù)字

===運(yùn)算符運(yùn)算符會(huì)把-0和+0 認(rèn)為相等 并且Number.NaN 不等于NaN

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

Object.preventExtensions(obj)

obj將要變成不可擴(kuò)展的對(duì)象
方法讓一個(gè)對(duì)象變的不可擴(kuò)展,也就是永遠(yuǎn)不能在添加新的屬性
返回值為已經(jīng)不可擴(kuò)展的對(duì)象

//如果一個(gè)對(duì)象可以添加新的屬性揩懒，則這個(gè)對(duì)象是可擴(kuò)展的。一般來(lái)說(shuō)不可擴(kuò)展對(duì)象的屬性可能仍然可被刪除挽封。
// Object.preventExtensions將原對(duì)象變的不可擴(kuò)展,并且返回原對(duì)象.
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2;  // true
 
// 字面量方式定義的對(duì)象默認(rèn)是可擴(kuò)展的.
var empty = {};
Object.isExtensible(empty) //=== true
 
// ...但可以改變.
Object.preventExtensions(empty);
Object.isExtensible(empty) //=== false
 
// 使用Object.defineProperty方法為一個(gè)不可擴(kuò)展的對(duì)象添加新屬性會(huì)拋出異常.
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // 拋出TypeError異常
 
// 在嚴(yán)格模式中,為一個(gè)不可擴(kuò)展對(duì)象的新屬性賦值會(huì)拋出TypeError異常.
function fail()
{
  "use strict";
  nonExtensible.newProperty = "FAIL"; // throws a TypeError
}
fail();
 
// 一個(gè)不可擴(kuò)展對(duì)象的原型是不可更改的,__proto__是個(gè)非標(biāo)準(zhǔn)魔法屬性,可以更改一個(gè)對(duì)象的原型.
var fixed = Object.preventExtensions({});
fixed.__proto__ = { oh: "hai" }; // 拋出TypeError異常

Object.isExtensible(obj)

obj需要檢測(cè)的對(duì)象
方法判斷一個(gè)對(duì)象是否是可擴(kuò)展的(是否可以在它上面添加新的屬性)

// 新對(duì)象默認(rèn)是可擴(kuò)展的.
var empty = {};
Object.isExtensible(empty); // === true

// ...可以變的不可擴(kuò)展.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// 密封對(duì)象是不可擴(kuò)展的.
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// 凍結(jié)對(duì)象也是不可擴(kuò)展.
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false

seal(obj)

obj將要被密封的對(duì)象
返回值：被密封的對(duì)象
方法封閉一個(gè)對(duì)象已球，阻止添加新屬性并將所有現(xiàn)有屬性標(biāo)記為不可配置。當(dāng)前屬性的值只要可寫就可以改變辅愿。

//通常一個(gè)對(duì)象是可擴(kuò)展的(可以添加新的屬性)智亮。密封一個(gè)對(duì)象會(huì)讓這個(gè)對(duì)象變的不能添加新屬性，且所有已有屬性會(huì)變得不可配置点待。屬性不可配置的效果就是屬性變的不可刪除阔蛉，以及一個(gè)數(shù)據(jù)屬性不能被重新定義為訪問(wèn)器屬性，或者反之癞埠，但屬性的值仍然可以修改状原。嘗試刪除一個(gè)密封對(duì)象的屬性或者將某個(gè)密封對(duì)象的屬性從數(shù)據(jù)屬性轉(zhuǎn)換成訪問(wèn)器屬性聋呢，結(jié)果會(huì)靜默失敗或拋出TypeError
//不會(huì)影響從原型鏈上繼承的屬性。但__proto__ 屬性的值也會(huì)不能修改 
//返回被密封對(duì)象的引用

var obj = {
  prop:function(){},
  foo:'bar'
};
// New properties may be added, existing properties
// may be changed or removed.
obj.foo = 'baz';
obj.lumy = 'woof';
delete obj.prop;

var o = Object.seal(obj);
o === obj;//true
Object.isSealed(obj);//true

obj.foo = 'quux';//still work

//but you can not convert data properties to accessors
Object.defineProperty(obj,'foo',{
  get:function(){return 'g';}
});//throws a TypeError

obj.quaxxor = 'the friendly duck';
delete obj.foo  //silently does not add property

// ...and in strict mode such attempts
// will throw TypeErrors.
function fail() {
  'use strict';
  delete obj.foo; // throws a TypeError
  obj.sparky = 'arf'; // throws a TypeError
}
fail();

// Attempted additions through
// Object.defineProperty will also throw.
Object.defineProperty(obj, 'ohai', {
  value: 17
}); // throws a TypeError
Object.defineProperty(obj, 'foo', {
  value: 'eit'
}); // changes existing property value

Object.isSealed(obj)

obj 要被檢查的對(duì)象
方法判斷一個(gè)對(duì)象是否被密封 返回一個(gè)Boolean

//新建的對(duì)象默認(rèn)不是密封的
var empty = {};
Objext.isSealed(empty) //=== false

// 如果你把一個(gè)空對(duì)象變的不可擴(kuò)展,則它同時(shí)也會(huì)變成個(gè)密封對(duì)象.
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// 但如果這個(gè)對(duì)象不是空對(duì)象,則它不會(huì)變成密封對(duì)象,因?yàn)槊芊鈱?duì)象的所有自身屬性必須是不可配置的.
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// 如果把這個(gè)屬性變的不可配置,則這個(gè)對(duì)象也就成了密封對(duì)象.
Object.defineProperty(hasProp, "fee", { configurable: false });
Object.isSealed(hasProp); // === true

// 最簡(jiǎn)單的方法來(lái)生成一個(gè)密封對(duì)象,當(dāng)然是使用Object.seal.
var sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // === true

// 一個(gè)密封對(duì)象同時(shí)也是不可擴(kuò)展的.
Object.isExtensible(sealed); // === false

// 一個(gè)密封對(duì)象也可以是一個(gè)凍結(jié)對(duì)象,但不是必須的.
Object.isFrozen(sealed); // === true 颠区，所有的屬性都是不可寫的
var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // === false削锰， 屬性"p"可寫

var s3 = Object.seal({ get p() { return 0; } });
Object.isFrozen(s3); // === true ，訪問(wèn)器屬性不考慮可寫不可寫,只考慮是否可配置

Object.keys(obj)

obj 要返回其枚舉自身屬性的對(duì)象
返回值為一個(gè)表示給定對(duì)象的所有可枚舉屬性的字符串?dāng)?shù)組 排列順序于for...in 循環(huán)遍歷該對(duì)象時(shí)返回的順序一致

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

// array like object with random key ordering
var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj)); // console: ['2', '7', '100']

// getFoo is a property which isn't enumerable
var myObj = Object.create({}, {
  getFoo: {
    value: function () { return this.foo; }
  } 
});
myObj.foo = 1;
console.log(Object.keys(myObj)); // console: ['foo']

Object.hasOwnProperty(prop)

prop要檢測(cè)的屬性 字符串 名稱或者Symbol
返回值 用來(lái)判斷某個(gè)對(duì)象是否含有指定的屬性的Boolean

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

//自身屬性于繼承屬性
o = new Object();
o.prop = 'exists';
o.hasOwnProperty('prop');//true
o.hasOwnProperty('toString');//false
o.hasOwnProperty('hasOwnProperty');//false

Object.isPrototypeOf(object)

object在該對(duì)象的原型鏈上搜尋
返回值：Boolean 表示調(diào)用對(duì)象是否在另一個(gè)對(duì)象的原型鏈上

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
//也可以用instanceOf 來(lái)操作測(cè)試構(gòu)造函數(shù)的prototype屬性是否出現(xiàn)在對(duì)象的原型鏈中的任何位置

propertyIsEnumerable()

obj.propertyIsEnumerable(prop);
返回值：返回一個(gè)Boolean 表示指定的屬性是否可枚舉

var o = {};
var a = [];
o.prop = 'is enumerable';
a[0] = 'is enumerable';
o.propertyIsEnumerable('prop');//true
a.propertyIsEnumerable(0);//true
//用戶自定義對(duì)象和引擎內(nèi)置對(duì)象
// 下面的例子演示了用戶自定義對(duì)象和引擎內(nèi)置對(duì)象上屬性可枚舉的區(qū)別
var a = ['is enumerable'];
a.propertyIsEnumerable(0);//true
a.propertyIsEnumerable('length');//false

toLocaleString()

obj.toLocaleString()
返回值：表示對(duì)象的字符串 返回調(diào)用toString()的結(jié)果
方法返回一個(gè)該對(duì)象的字符串表示毕莱。此方法被用于派生對(duì)象為了特定語(yǔ)言環(huán)境的目的而重載使用器贩。

Object.toString()

object.toString()
返回值：表示該對(duì)象的字符串
每個(gè)對(duì)象都有一個(gè)toString()方法，當(dāng)該對(duì)象被表示為一個(gè)文本值時(shí)央串，或者一個(gè)對(duì)象以預(yù)期的字符串方式引用時(shí)自動(dòng)調(diào)用磨澡。默認(rèn)情況下 toString()方法被每個(gè)Object對(duì)象繼承。如果次方法在定義對(duì)象中未被覆蓋质和，同String()返回‘[object type]’稳摄，其中type是對(duì)象的類型。

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

valueOf()

object.valueOf()
返回值：該對(duì)象的原始值
javascript 調(diào)用valueOf方法將對(duì)象轉(zhuǎn)換為原始值饲宿。你很少需要自己調(diào)用valueOf方法厦酬；當(dāng)遇到要預(yù)期的原始值的對(duì)象時(shí)，javascript會(huì)自動(dòng)調(diào)用它
默認(rèn)情況下 valueOf方法由Object后面的每個(gè)對(duì)象繼承瘫想。 每個(gè)內(nèi)置的核心對(duì)象都會(huì)覆蓋此方法以返回適當(dāng)?shù)闹嫡淘摹Ｈ绻麑?duì)象沒(méi)有原始值，則valueOf將返回對(duì)象本身国夜。
javascript許多內(nèi)置對(duì)象都重寫了該函數(shù)减噪，以實(shí)現(xiàn)更適合自身的功能需要。因此车吹，不同類型對(duì)象的valueOf()方法的返回值和返回值類型均可能不同筹裕。

Object.values(obj)

obj被返回可枚舉屬性值的對(duì)象
返回值：一個(gè)包含對(duì)象自身的所有可枚舉屬性的數(shù)組。
方法返回一個(gè)給定對(duì)象自身的所有可枚舉屬性值的數(shù)組窄驹，值的順序與使用for...in循環(huán)的順序相同(區(qū)別在于for-in循環(huán)枚舉原型鏈中的屬性)朝卒。

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

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

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

var my_obj = Object.create({},getFoo:{value:function(){return this.foo;}});
my_obj.foo = 'bar';
console.log(Object.values(my_obj));//['bar']

console.log(Object.values('foo'));//['f','o','o']