var cat= {
	name:'mini',
	age:2,
	color:'yellow',
	desc:'cute'
}
console.log(Object.keys(cat)); // ["name", "age", "color", "desc"]

var data = {a: 1, b: 2, c: 3, d: 4};
Object.keys(data).filter(function(x) { return 1 ;})
//期待輸出：[“c”,”d”]

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

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

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

var parent = {
    x : 1,
    y : 1
}
var child = Object.create(parent,{
    z : {                           // z會(huì)成為創(chuàng)建對(duì)象的屬性
        writable:true,
        configurable:true,
        value: "newAdd"
    }
});
console.log(child)//{z: "newAdd"}z: "newAdd"__proto__: x: 1y: 1__proto__: Object
Object.create()創(chuàng)建繼承
function A(){
  this.a = 1;
  this.b = 2;
}
A.prototype.drive = function(){
  console.log('drivvvvvvvvvv');
}
//方式1
function B(){}
B.prototype = Object.create(new A()); //這里采用了new 一個(gè)實(shí)例
//方式2
function C(){
  A.call(this);
}
C.prototype = Object.create(A.prototype) //

var obj = {
    name:'fei'
}
    console.log(obj.hasOwnProperty('name'))//true
    console.log(obj.hasOwnProperty('toString'))//false

function A(a,aa) {
  this.a = a;
  this.aa = aa;
  this.getA = function() {
    return this.a;
  }
}
// 原型方法
A.prototype.aaa = function () {};

var B = new A('b', 'bb');
B.myMethodA = function() {};
// 不可枚舉方法
Object.defineProperty(B, 'myMethodB', {
  enumerable: false,
  value: function() {}
});

Object.getOwnPropertyNames(B); // ["a", "aa", "getA", "myMethodA", "myMethodB"]
Object.getOwnPropertyNames和Object.keysq區(qū)別
Object.getOwnPropertyNames和Object.keys的區(qū)別，即Object.keys只適用于可枚舉的屬性，而Object.getOwnPropertyNames返回對(duì)象自動(dòng)的全部屬性名稱。

'use strict';
(function(){
    if(!Object.getOwnPropertyNames){
        console.log('瀏覽器不支持getOwnPropertyNames');
        return;
    }

    //人類的構(gòu)造函數(shù)
    var person = function(name, age, sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.sing = function(){
            console.log('sing');
        }
    }
    //new 一個(gè)ladygaga
    var gaga = new person('ladygaga', 26, 'girl');

    //給嘎嘎發(fā)放一個(gè)不可枚舉的身份證
    Object.defineProperty(gaga, 'id', {
        value : '1234567890',
        enumerable : false
    });

    //查看gaga的個(gè)人信息
    var arr = Object.getOwnPropertyNames(gaga);
    document.write(arr); //output: name,age,sex,sing,id

    document.write('</br>');
    
　　 //注意和getOwnPropertyNames的區(qū)別，不可枚舉的id沒(méi)有輸出
    var arr1 = Object.keys(gaga);
    document.write(arr1); //output: name,age,sex,sing
})();

var target = { a: 1 };
var source1 = { b: 2 };
var source2 = { c: 3 };
Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}

var obj = {a: 1};  
Object.assign(obj) === obj // true  

var obj1 = {a: {b: 1}};  
var obj2 = Object.assign({}, obj1);  
obj1.a.b = 2;  
obj2.a.b // 2  

class Point {  
    constructor(x, y) {  
        Object.assign(this, {x, y});  
    }  
}

Object.assign(SomeClass.prototype, {  
    someMethod(arg1, arg2) {  
    ···  
    },  
    anotherMethod() {  
    ···  
    }  
});  
//  等同于下面的寫法  
SomeClass.prototype.someMethod = function (arg1, arg2) {  
···  
};  
SomeClass.prototype.anotherMethod = function () {  
···  
}; 

function clone(origin) {  
    return Object.assign({}, origin);  
} 

const merge =(target, ...sources) => Object.assign(target, ...sources);  
//如果希望合并后返回一個(gè)新對(duì)象，可以改寫上面函數(shù)，對(duì)一個(gè)空對(duì)象合并。

const merge =(...sources) => Object.assign({}, ...sources);  

const DEFAULTS = {  
    logLevel: 0,  
    outputFormat: 'html'  
};  
function processContent(options) {  
    let options = Object.assign({}, DEFAULTS, options);  
} 

var obj = new Object; //obj = {}
obj.name = "張三"; //添加描述
obj.say = function(){}; //添加行為

Object.defineProperty(obj, prop, descriptor)

var obj = {
test:"hello"
}
//對(duì)象已有的屬性添加特性描述Object.defineProperty(obj,"test",{
configurable:true | false,
enumerable:true | false,
value:任意類型的值,
writable:true | false
});
//對(duì)象新添加的屬性的特性描述Object.defineProperty(obj,"newKey",{
configurable:true | false,
enumerable:true | false,
value:任意類型的值,
writable:true | false
});
//value: 設(shè)置屬性的值
//writable: 值是否可以重寫。true | false
//enumerable: 目標(biāo)屬性是否可以被枚舉。true | false
//configurable: 目標(biāo)屬性是否可以被刪除或是否可以再次修改特性 true | false

//存取器描述
//使用存取器描述屬性的特性的時(shí)候，允許設(shè)置以下特性屬性， 當(dāng)使用了getter或setter方法，不允許使用writable和value這兩個(gè)屬性

var obj = {};
Object.defineProperty(obj,"newKey",{
get:function (){} | undefined,
set:function (value){} | undefined
configurable: true | false
enumerable: true | false
});
//getter/setter
//getter 是一種獲得屬性值的方法
//setter是一種設(shè)置屬性值的方法。
//使用get/set屬性來(lái)定義對(duì)應(yīng)的方法

var obj = {};
var initValue = 'hello';
Object.defineProperty(obj,"newKey",{
get:function (){
//當(dāng)獲取值的時(shí)候觸發(fā)的函數(shù)
return initValue;
},
set:function (value){
//當(dāng)設(shè)置值的時(shí)候觸發(fā)的函數(shù),設(shè)置的新值通過(guò)參數(shù)value拿到
initValue = value;
}
});
//獲取值console.log( obj.newKey ); //hello

//設(shè)置值
obj.newKey = 'change value';

console.log( obj.newKey ); //change value