ES6 对象扩展 JavaScript

2023年5月4日 167次阅读 来源: sponing

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);
  • 自定义的属性放在扩展运算符后面，则扩展运算符内部的同名属性会被覆盖掉。
    原文作者：sponing
    原文地址: https://www.jianshu.com/p/1f6c10235130
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞