一、destructuring
ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构Destructuring。
//es5
if(1){
let cat = 'ken';
let dog = 'lili';
let zoo = {cat: cat, dog: dog};
console.log(zoo) ; //Object {cat: "ken", dog: "lili"}
}
//用ES6完全可以像下面这么写:
if(1){
let cat = 'ken';
let dog = 'lili';
let zoo = {cat, dog};
console.log(zoo) ; //Object {cat: "ken", dog: "lili"}
}
//反过来可以这么写:
if(1){
let dog = {type: 'animal', many: 2};
let { type, many} = dog;
console.log(type, many) ; //animal 2
}
二、属性名表达式
用方法、表达式作为对象的属性名;表达式还可以用于定义方法名。
JavaScript语言定义对象的属性,有两种方法。
let obj1 = {};
// 方法一
obj1.foo = true;
// 方法二
obj1['a'+'bc'] = 123;
console.log(obj1);
上面代码的方法一是直接用标识符作为属性名,方法二是用表达式作为属性名,这时要将表达式放在方括号之内。
如果使用字面量方式定义对象(使用大括号),在ES5中只能使用方法一(标识符)定义属性。
var obj2 = {
foo: true,
abc: 123
}
ES6允许字面量定义对象时,用方法(表达式)作为对象的属性名,即把表达式放在方括号内。
let propKey = 'foo';
let obj3 = {
[propKey]: true,
['a'+'bc']: 123
};
console.log(obj3);
//表达式还可以用于定义方法名。
let ello='i';
let obj4 = {
['h'+ello]() {
return 'hi nick';
}
};
console.log(obj4.hi()); // hi nick
三、Object.is()
Object.is()用来比较两个值是否严格相等。它与严格比较运算符(===)的行为基本一致,不同之处只有两个:一是+0不等于-0,二是NaN等于自身。
console.log(+0 === -0);//true
console.log(NaN === NaN); // false
console.log(Object.is(+0, -0)); // false
console.log(Object.is(NaN, NaN)); // true
四、Object.assign()
Object.assign方法用来将源对象(source)的所有可枚举属性,复制到目标对象(target)。
它至少需要两个对象作为参数,第一个参数是目标对象,后面的参数都是源对象。只要有一个参数不是对象,就会抛出TypeError错误。
let target = { a: 1 };
let source1 = { b: 2 };
let source2 = { c: 3 };
Object.assign(target, source1, source2);
console.log(target); // {a:1, b:2, c:3}
注意:如果目标对象与源对象有同名属性,或多个源对象有同名属性,则后面的属性会覆盖前面的属性。
let target1 = { a: 1, b: 1 };
let source11 = { b: 2, c: 2 };
let source21 = { c: 3 };
Object.assign(target1, source11, source21);
console.log(target1); // {a:1, b:2, c:3}
console.log(Object.assign({'name':'张三'},{'name':'nick','age':26,'sex':'男','sex':{'gander':'handsome'}}));
Object.assign只拷贝自身属性,不可枚举的属性(enumerable为false)和继承的属性不会被拷贝。
let obj1=Object.assign({b: 'c'},
Object.defineProperty({}, 'invisible', {
enumerable: false,
value: 'hello'
})
);
console.log(obj1);// { b: 'c' }
let obj2 =Object.assign({b: 'c'},
Object.defineProperty({}, 'invisible', {
enumerable: true,
value: 'hello'
})
);
console.log(obj2);// {b: "c", invisible: "hello"}
属性名为Symbol值的属性,也会被Object.assign拷贝。
let obj3=Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' })
console.log(obj3);// { a: 'b', Symbol(c): 'd' }
注意:Object.assign可以用来处理数组,但是会把数组视为对象。
Object.assign([1, 2, 3], [4, 5]);// [4, 5, 3]
其中,4覆盖1,5覆盖2,因为它们在数组的同一位置,所以就对应位置覆盖了。
Object.assign还有很多用处,下面就看一下吧:
为对象添加属性
class Point {
constructor(x, y) {
Object.assign(this, {x, y});
}
}
这样就给Point类的对象实例添加了x、y属性。
为对象添加方法
let SomeClass={test:'nick'};
SomeClass.prototype={};
Object.assign(SomeClass.prototype, {
someMethod:function(arg1, arg2) {
},
anotherMethod:function () {
}
});
console.log(SomeClass);
等同于下面的写法
let SomeClass2={test:'nick2'};
SomeClass2.prototype={};
SomeClass2.prototype.someMethod = function (arg1, arg2) {
};
SomeClass2.prototype.anotherMethod = function () {
};
console.log(SomeClass2);
上面代码使用了对象属性的简洁表示法,直接将两个函数放在大括号中,再使用assign方法添加到SomeClass.prototype之中。
克隆对象
function clone1(origin) {
return Object.assign({}, origin);
}
上面代码将原始对象拷贝到一个空对象,就得到了原始对象的克隆。
不过,采用这种方法克隆,只能克隆原始对象自身的值,不能克隆它继承的值。如果想要保持继承链,可以采用下面的代码。
function clone2(origin) {
let originProto = Object.getPrototypeOf(origin);
return Object.assign(Object.create(originProto), origin);
}
在JS里子类利用Object.getPrototypeOf去调用父类方法,用来获取对象的原型。用它可以模仿Java的super。
多个对象合并到某个对象
const merge1 =(target, ...sources) => Object.assign(target, ...sources);
多个对象合并到一个新对象
const merge2 = (...sources) => Object.assign({},...sources);
为属性指定默认值
const DEFAULTS = {
logLevel: 0,
outputFormat: 'html'
};
function processContent(options) {
let options1 = Object.assign({}, DEFAULTS, options);
}
上面代码中,DEFAULTS对象是默认值,options对象是用户提供的参数。Object.assign方法将DEFAULTS和options合并成一个新对象,如果两者有同名属性,则option的属性值会覆盖DEFAULTS的属性值。
注: 由于存在深拷贝的问题,DEFAULTS对象和options对象的所有属性的值,都只能是简单类型,而不能指向另一个对象。否则,将导致DEFAULTS对象的该属性不起作用。
此篇全部代码:

es6-object
此篇终,待续……