var foo = 'bar';
var baz = {foo};
baz //{foo:'bar'}

//等同于
var baz = {foo:foo}; 说明，ES6允许在对象之中，只写属性名，不写属性值。这时，属性值等于属性名所代表的变量，下面是另一个例子。

function f(x,y){
	return {x,y}
}
//等同于

function f(x,y){
	return {x:x,y:y};
}

f(1,2) //Object{x:1,y:2} 除了属性简写，方法也可以简写

var 0 ={
	method(){
		return "Hello!";	
	}
};

//等同于

var 0 = {
	method: function(){
		return "Hello!";
	}
}; 下面是一个实例的例子。

var birth = '2000/01/01';

var Person ={
	name:'张三',
	birth,
	//等同于调用birth:birth,
	
	//等同于hello:function()...
	hello(){ console.log('我的名字是',this.name);}
} 这种写法用于函数的返回值，将会非常方便。

function getPoint(){
	var x =1;
	var y =10;
	return {x,y};
}

getPoint();
//{x:1,y:10} CommonJS模块输出变量，就非常合适使用简洁写法。

var ms = {};

function getItem (key){
	return key in ms ? ms[key] :null;
}

function setItem (key,value){
	ms[key] = value;
}

function clear(){
	ms = {};
}

module.exports ={
	getItem:getItem,
	setItem:setItem,
	clear:clear
}; 属性的赋值器(setter)和取值器(getter)，都是采用这种写法

var cart ={
	_wheels :4,
	
	get wheels(){
		return this._wheels;
	},

	set wheels(value){
		if(value <this._wheels){
			throw new Error('数值太小了！');
		}
		this._wheels = value;
	}
}

//方法一
obj.foo = true;

//方法二
obj['a' + 'bc'] = 123; 上面代码的方法一是直接用标识符作为属性名，方法二是用表达式作为属性名，这时要表达式放在方括号之内。 但是，如果使用字面量方式定义对象(使用大括号)，在ES6中只能使用方法一(标示符)定义属性

var obj = {
	foo:true,
	abc:123
}; ES6允许字面量定义对象时，用方法二(表达式)作为对象的属性名，即把对象表达式放在方括号内。

let propKey = 'foo';

let obj = {
	[propKey]:true,
	['a' +  'bc'] :123
};

var lastWord = 'last word';

var a = {
	'first word' : 'hello',
	[lastWord] :'world'
};
a['first word'] //"hello"
a[lastWord] //"world"
a['last word'] //"world"

let  obj  = {
	['h' + 'ello'](){
		return 'hi';
	}
};
object.hello() //hi

//报错
var foo = 'bar';
var bar = 'abc';
var baz = {[foo]};

//正确
var foo = 'bar';
var baz = {[foo]:'abc'}

var person = {
	sayName(){
		console.log(this.name);
	},
	get firstName(){
		return "Nicholas";
	}
};
person.sayName.name // "sayName"
pserson.firstName.name // "get firstName" 方法的name属性返回函数名(即方法名)，如果使用了取值函数，则会在方法名前加上get。如果是存执函数，方法名前会加上set。

(new Function()).name //"anonymous"

var doSomething = function(){
	//...
};
doSometthing.bind().name //"bound doSomething"

const key1 = Symbol('description');
const key2 = Symbol();
let obj = {
	[key1](){},
	[key2](){},
};
obj[key1].name //"[description]"
obj[key2].name //"" 上面代码中，key1对应的Symbol值有描述，key2没有

Object.is('foo','foo')
//true
Object.is({},{})
//false 不同之处只有两个：一是+0不等于-0，而是NaN等于自身。

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

Object.defineProperty(Object,'is',{
	value:function(x,y){
		if(x === y){
			//针对+0不等于-0的情况
			return x !== 0 || 1/x === 1/y;
		}
		//针对NaN的情况
		return x !== x && y !==y;
	},
	configurable :true,
	enumerable: false,
	writable.true
});

var target = {a:1};

var source1 = {b:2};

var source2 = {c:3};

Object.assign(target,source1,source2);
target //{a:1,b:2,c:3} Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。

var target = {a:1,b:1};

var source1 = {b:2,c:2};
var source2 = {c;3};

Object.assign(target,source,sources2);
target //{a:1,b:2,c:3} 如果只有一个参数，Object.assign会直接返回该参数。

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

typeof Object.assign(2) //"object" 由于undefined和null无法转成对象，所以如果它们作为参数，就会报错

Object.assign(undefined)//报错
Object.assign(null)//报错 如果非对象参数出现在源对象的位置(即非首参数),那么处理规则有所不同，首先这些参数都会转成对象，如果无法转成对象，就会跳过，这意味着，如果undefined和null不在首参数，就不会报错。

let obj = {a;1};
Object.assign(obj,undefined) ===obj //true
Object.assign(obj,null) === obj //true 其他类型的值(即数值、字符串和布尔值)不在首参数，也不会报错。但是，除了字符串会以数组形式，拷贝入目标对象，其他值都不会产生效果。

var v1 = 'abc';
var v2 = true;
var v3 = 10;

var obj = Object.assign({},v1,v2,v3);
console.log(obj);  //{'0':'a','1':'b','2':'c'} 上面代码中，v1、v2、v3分别是字符串、布尔值和数值，结果字符串合入目标对象(以字符数组的形式)，数值和布尔值都会被忽略。这是因为只有字符串的包装对象，会产生可枚举属性。

Object(true) //{[[PrimitiveValue]]:true}
Object(10)   //{[[PrimitiveValue]]:10}
Object('abc') //{0:'a','1':"b",2:"c",length:3,[[PrimitiveValue]]:"abc"} 布尔值、数值、字符串分别转成对应的包装对象，可以看到它们的原始值都在包装对象的内部属性[[PrimitiveValue]]上面，这个属性是不会被Object.assign拷贝的，只有字符串的包装对象，会产生可枚举的实义属性，那些属性则会被拷贝。

Object.assign({b:'c'},
	Object.defineProperty({},'invisible',{
		enumerable:false,
		value:'hello'
	})
)
//{b:'c'} 上面代码中，Object.assign要拷贝的对象只有一个不可枚举属性invisible，这个属性并没有被拷贝进去。

Object.assign({a:'b'},{ [Symbol('c')]: 'd' })
//{a:'b',Symbol(c):'d'}

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

obj1.a.b = 2;
obj2.a.b //2 上面代码中，源对象obj1的a属性的值是一个对象，Object.assign拷贝得到的是这个对象的引用。

var target = {a:{b:'c',d:'e'}}
var source = {a:{b:'hello'}}
Object.assign(target,source)
//{a:{b:'hello'}} 上面代码中，target对象的a属性被source对象的a属性整个替换掉了，而不会得到{a:{b:'hello',d:'e'}}的结果。这通常不是开发者想要的，需要特别小心

Object.assign([1,2,3],[4,5])
//[4,5,3]

	let obj = {foo:123};
	Object.getOwnPropertyDescriptor(obj,'foo')
	//{
	//	value:123,
	//	writable:true,
	//  enumerable:true,
	//  configurable:true
	//} 描述对象的enumerable属性，称为"可枚举性"，如果该属性为 false，就表示某些操作会忽略当前属性。

Object.getOwnPropertyDescriptor(class{foo(){}}.prototype,'foo').enumerable
//false 总的来说，操作中引入继承的属性会让问题复杂化，多数时候，我们只关心对象自身的属性。所以，尽量不要用for ...in 循环，而是用Object.keys()代替。

var obj = { foo:"bar",baz:42};
Object.keys(obj)
//["foo","baz"] 目前ES7又有提案，就是引入Object.values()和Object.entries()和Object.keys配套

let {keys,value,entries} = object;
let obj = {a:1,b:2,c:3};

for (let key of keys(obj)){
	console.log(key) //'a','b','c'
}

for (let value of values(obj)){
	console.log(value);//1,2,3
}

for (let [key,value] of entries(obj)){
	console.log([key,value]);//['a',1],['b',2],['c',3]
}

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.avlue只返回对象自身可遍历的属性

var obj = object.create({},{p:{value:42}});
Object.values(obj) //[] 上面，Object.create方法的第二个参数添加的对象属性(属性p),如果不显式声明，默认不可遍历的。Object.values不会返回这个属性。Object.values会过滤属性名为Symbol值的属性。

Object.values({[Symbol()]:123,foo:'abc'});
//['abc']	 如果Object.values方法的参数是一个字符串，会返回各个字符组成的一个数组。

Object.values('foo')
//['f','o','o'] 上面代码中，字符串会先转成一个类似数组的对象，字符串的每个字符，就是该对象的一个属性。因此，Object.values返回每个属性的键值，就是各个字符组成的一个数组。

Object.values(42) //[]
Object.values(true) //[]

var obj = {foo:'bar',baz:42};
Object.entries(obj)
//[["foo","bar"],["baz",42]] 返回值不一样，该方法的行为与Object.values基本一致。 如果原对象的属性名是一个Symbol值，该属性会被省略。

Object.entries({[Symbol()]:123,foo:'abc'});
//[['foo','abc']] 上面代码中，原对象有两个属性，Object.entries只输出属性名非Symbol值的属性。将来可能会有Reflect.ownEntries()方法，返回对象自身的所有属性。

let obj = {one:1,two:2};
for (let [k,v] of Obejct.entries(obj)){
	console.log(`${JSON.stringify(k)}:${JSON.stringify(v)}`);
}
//"one":1
//"two":2 Object.entries方法的一个用处是，将对象转为真正的Map结构。

var obj = {foo:'bar',baz:42 };
var map = new Map(Object.entries(obj));
map //Map{foo:"bar",baz:42} 自己实现Object.entries方法，非常简单

//Generator函数的版本
function* entries(obj){
	for (let key of Object.keys(obj)){
		yield [key,obj[key]];
	}
}
//非Generator函数的版本
function entries(obj){
	let arr =[];
	for (let key of Object.keys(obj)){
		arr.push([key,obj[key]]);
	}
	return arr;
}

var obj = {p:'a'};

Object.getOwnPropertyDescriptor(obj,'p')
//Object{ value :"a",
//	writable:true,
//	enumerable:true,
//	configurable:true
//} ES7有一个提案，提出了Object.getOwnPropertyDescriptor方法，返回指定对象所有自身属性(非继承属性)的描述对象。

const obj = {
	foo:123,
	get bar() { return 'abc'}
};

Object.getOwnPropertyDescriptors(obj)
//{ foo:
//		{ value:123,
//		  writable:true,
//		  enumerable:true,
//		  configurable:true},
//				
//	bar:
//		{   get :[Function:bar],
//			set : undefined,
//			enumerable:true,
//			configurable:true
//		}
//} Object.getOwnPropertyDescriptors方法返回一个对象，所有原对象的属性名都是该对象的属性名，对应的属性值是该属性的描述对象。该方法的实现非常日容易。

function getOwnPropertyDescriptors(obj){
	const result = {};
	for (let key of Reflect.ownKeys(obj)){
		result[key] = Object.getOwnPropertyDescriptor(obj,key);
	}
	return result;
} 该方法主要是为了解决Object.assign()无法正确拷贝get属性和set属性的问题。

const source = {
	set foo(value){
		console.log(value);
	}
};

const target1 = {};
Object.assign(target1,source);

Object.getOwnPropertyDescriptor(target1,'foo')

//{ valuse : undefined,
//	writable:true,
//	enumerable:true,
//	configurable:true } Object.getOwnPropertyDescriptors方法返回一个对象，所有原对象的属性名都是该对象的属性名，对应的属性值就是该属性的描述对象。

function getOwnPropertyDescriptors(obj){
	const result ={};
	for (let key of Reflect.ownKeys(obj)){
		result[key] = Object.getOwnPropertyDescriptor(obj,key);
	}
	return result;
} 该方法的提出是为了解决Object.assign()无法正确拷贝get属性和set属性的问题。

const source ={
	set foo(value){
		console.log(value);
	}
};
const target1 = {};
Object.assign(target1,source);

Object.getOwnPropertyDescriptor(target1,'foo')
//{	value:undefined,
//	writable:true,
//	enumerable:true,
// configurable:true
//	} 上面的代码中，source对象的foo属性的值是一个赋值函数，Object.assign方法将这个属性拷贝给target1对象，结果该属性的值变成了undefined。这是因为Obejct.assign方法总是拷贝一个属性的值，而不会拷贝它背后的赋值方法或取值方法。

const source = {
	set foo(value){
		console.log(value);
	}	
};

const target2 = {};
Object.defineProperties(target2,Object.getOwnPropertyDescriptors(source));
Object.getOwnPropertyDescriptor(target2,'foo')
//{	get: undefined,
//	set:[Function:foo],
//	enumerable:true,
//	configurable:true
//} 上面代码中，将两个对象合并的逻辑提炼出来，就是下面这样。

const shallowMerge = (target,source) => Object.defineProperties(
	target,
	Object.getOwnPropertyDescriptors(source)
); Object.getOwnPropertyDescriptors方法的另一个用处，是配合Object.create方法，将对象属性克隆岛一个新对象。着属于浅拷贝。

const clone = Object.create(Object.getPrototupeOf(obj),
	Object.getOwnPropertyDescriptors(obj));
	//或者
	const shallowClone = (obj) => Object.create(
		Object.getPrototypeOf(obj),
		Object.getOwnPropertyDescriptors(obj)
	); 上面代码会克隆对象obj。

const obj = {
	__proto__ : prot,
	foo:123,
}; ES6规定__proto__只有浏览器部署，其他环境不用部署，如果去除__proto__，上面代码就要改成下面这样。

const obj = Object.create(prot);
obj.foo = 123 ;
//或者
const obj = Object.assign(
	Object.create(prot),
	{
		foo:123,
	}
); 有了Object.getOwnPropertyDescriptors，我们就有了另一种写法。

const obj = Object.create(
	prot,
	Object.getOwnPropertyDescriptors({
		foo:123,
	})
); Object.getOwnPropertyDescriptors也可以用来实现Mixin(混入)模式。

let min = (object) => ({
	with : (...mixins) => mixins.reduce(
		(c,mixin) => Object.create(
			c,Object.getOwnPropertyDescriptors(mixin)
		),object)
});

//multiple mixins example
let a = {a:'a'};
let b = {b:'b'};
let c = {c:'c'};
let d = min(c).with(a,b); 对象a和b被混入了c对象