程序员

ES6 对象扩展 JavaScript

1. 属性的简介表示法

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

//等同于
var baz = {foo: foo};

var obj = {
    class() {}
};
//等同于
var obj = {
    ‘class’: function() {}
}

ES6允许在对象之中,只写属性名,不写属性值。此时,属性值等于属性名所代表的变量。如果某方法的值是一个Generator函数,函数名前面需要加上星号。

2. 属性名表达式

  • JavaScript语言定义对象的属性有两种方法。

    //方法一
    obj.foo = true;
    //方法二
    obj['a' + 'bc'] = 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"

注意:属性名表达式与简介表示法,不能同时使用,会报错。

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

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

3. 方法的name属性

  • 函数的name属性,返回函数名。对象方法也有name属性。
var person = {
    sayName() {
        console.log(this.name);
    },
    get firstName() {
        return "Nicholas";
    }
};

person.sayName.name  //"sayName"
person.firstName.name  //"get firstName"

方法的name属性返回函数名。如果使用了取值函数,则会在方法名前加上get。如果是存值函数,则加上set。

  • 有两种特殊情况:
    • bind方法创造的函数,name属性返回“bound”加上原函数的名字;
    • Function构造函数创造的函数,name属性返回“anonymous”
(new Function()).name  //"anonymous"

var doSomething = function() {}
doSomething.bind().name  //"bound doSomething
  • 如果对象的方法是一个Symbol值,name属性返回的是这个Symbol值得描述。
const key1 = Symbol('description');
const key2 = Symbol();
let obj = {
    [key1]() {},
    [key2]() {}
};
obj[key1].name  //"description"
obj[key2].name  //""

4. Object.is()

  • ES6提出了同值相等算法,用来比较两个值是否严格相等,与严格比较运算符(===)的行为基本一致。
Object.is('foo', 'foo')  //true
Object.is({}, {})   //false
  • 与===不同之处:
+0 === -0  //true
NaN === NaN  //false

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

5. Object.assign()

基本用法

  • 该方法用于对象的合并,将源对象的所有可枚举属性,赋值到目标对象。第一个参数是目标对象,后面的参数都是源对象。

如果目标对象与源对象有同名属性,或多个源对象有同名属性。则后面的覆盖前面的属性。

  • 如果只有一个参数,则会直接返回该参数。

  • 如果只有一个参数,其参数不是对象,则先转成对象,然后返回。
    由于undefined和null无法转为对象,所以它们作为参数时报错。

  • 如果非对象参数出现在源对象的位置,如果该参数无法转为对象,则跳过。不报错。
  • 其他类型的值(即数值、字符串和布尔值)不在首参数,不会报错。但是,除了字符串会以数组形式拷贝入目标对象,其他值都不会产生效果。
  • 属性名为Symbol的属性,也会被Object.assign拷贝。

注意点

  • 该方法是浅拷贝。如果源对象某个属性的值是对象,则目标对象拷贝得到的是这个对象的引用。
  • 对于嵌套的对象,遇到同名属性,替换而不添加。
  • 该方法把数组视为对象。即相同index的值会被替换。

6. 属性的可枚举性

  • Object.getOwnPropertyDescriptor方法可以获取该属性的描述对象。
  • enumerable属性称为“可枚举性”,如果为false,表示某些操作会忽略当前属性。会忽略它为false的属性:
    • for…in循环:只遍历对象自身的和继承的可枚举的属性(不含Symbol属性)。
    • Object.keys():返回对象自身的所有可枚举的属性的键名(不含Symbol属性)。
    • JSON.stringify():只串行化对象自身的可枚举的属性。
    • Object.assign():只拷贝对象自身的可枚举的属性。

7. 属性的遍历

  • for…in:同上
  • Object.keys(obj):同上
  • Object.getOwnPropertyNames(obj):返回一个数组,包含对象自身的所有属性(不含Symbol属性,但是包括不可枚举属性)。
  • Object.getOwnPropertySymbols(obj):- Object.getOwnPropertySymbols
    返回一个数组,包含对象自身的所有Symbol属性。
  • Reflect.ownKeys(obj):Reflect.ownKeys
    返回一个数组,包含对象自身的所有属性,不管是属性名是Symbol或字符串,也不管是否可枚举。
  • 以上的5种方法遍历对象的属性,都遵守同样的属性遍历的次序规则。
    • 首先遍历所有属性名为数值的属性,按照数字排序。
    • 其次遍历所有属性名为字符串的属性,按照生成时间排序。
    • 最后遍历所有属性名为Symbol值的属性,按照生成时间排序。
Reflect.ownKeys({ [Symbol()]:0, b:0, 10:0, 2:0, a:0 })    
// ['2', '10', 'b', 'a', Symbol()]

8. proto属性,

Object.setPrototypeOf(),Object.getPrototypeOf()
  • proto属性
    前后各有两个下划线,用来读取或设置当前对象的prototype对象。
    实际上,proto调用的是object.prototype.proto
  • Object.setPrototypeOf()
    • 与上一个作用相同,设置一个对象的prototype对象。
  • Object.values(),Object.entries()
    • Object.keys():返回一个数组,成员是参数对象自身(不含继承)的所有可遍历属性的键名。
    • Object.values()返回一个数组,成员是参数对象自身(不含继承)的 * 所有可遍历属性的键值。顺序与属性的遍历顺序一致(上)
    • 该方法会过滤属性名为Symbol的属性。
    • 如果参数是一个字符串,返回各个字符组成的数组。
    • 参数是数值或布尔值,返回空值。
  • Object.entries
    • 返回一个数组,成员是参数对象自身(不含继承)的所有可遍历属性的键值对数组。
    • 除了返回值不同,方法的行为同上。
    • 可以将对象转为真正的Map结构。
var obj = { foo: 'bar', baz: 42 };
var map = new Map(Object.entries(obj));
map // Map { foo: "bar", baz: 42 }

10. 对象的扩展运算符

  • 解构赋值

    • 等号右边为对象。是null或undefined时报错。
    • 解构赋值必须是最后一个参数,否则报错。

    • 解构赋值的拷贝是浅拷贝。如果一个键的值是复合类型的值,则拷贝的是这个值的引用。

    • 解构赋值不会拷贝继承自原型对象的属性。
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }

let { x, y, ...z } = null; // 运行时错误
let { x, y, ...z } = undefined; // 运行时错误
  • 扩展运算符
    • 可以用于合并两个对象。
      (…)用于去除参数对象的所有可遍历属性,拷贝到当前对象之中。等同于Object.assign方法。
let ab = {...a, ...b};
//等同于
let ab = Object.assign({},a,b);
  • 自定义的属性放在扩展运算符后面,则扩展运算符内部的同名属性会被覆盖掉。