理解ES6 第三章：对象 ---Object.assign给对象添加多个属性， super, 原型。。。

关注

翻译最新推荐文章于 2026-09-29 12:33:05 发布 8.5k 阅读 AI 写同款· GEO 优化 ›

【深入理解ECMAScript 6】对象的扩展（属性表示法、Object方法、super关键字、对象的扩展运算符） ES6 对象的扩展文章目录ES6 对象的扩展一、属性表示法1、ES52、ES6二、Object的方法1、Object.is()ES5ES62、Object.assign()三、super关键字四、对象的扩展运算符一、属性表示法 1、ES5 let name = '张无忌' function sayMe() { console.log('this is 张无忌'); } // ES5 定义对象属性方法的方式 var obj = { name: name, //第二个name表示变量名阅读详情

英文电子书点此阅读《understanding es6》

- - 对象

对象

快速初始化属性

不用再专门定义Key-value，直接给出Key，es6会自动在上下文找同名的变量作为value

function createPerson(name, age) {
    return {
        name,
        age
    };
}

简洁的函数定义（只能用于对象method，不能用于全局）

var person = {
    name: "Nicholas",
    sayName() {
        console.log(this.name);
    }
};

可以计算的属性名

var suffix = " name";

var person = {
    ["first" + suffix]: "Nicholas",
    ["last" + suffix]: "Zakas"
};

Object.is()

主要是修正了之前的quirks。比如 +0和-0，再比如 NaN === NaN
基本等于”===”，会比较类型和值。仅在正负0和NaN上表现的不一致。
貌似没啥用。。。

console.log(+0 == -0);              // true
console.log(+0 === -0);             // true
console.log(Object.is(+0, -0));     // false

console.log(NaN == NaN);            // false
console.log(NaN === NaN);           // false
console.log(Object.is(NaN, NaN));   // true

Object.assign()

比Object.create() 更好用，用于merge多个对象
后者会覆盖前者，shallow copy, 简单复制，不是可迭代的。
会把后者(supplier)的访问器特性（getter/setter类型的）以数据特性的形式赋予前者（receiver）

同名属性

ES5 的严格模式下，一个对象中的有同名属性会报错，但在ES6中不管是严格属性还是非严格属性都不会，后出现的会覆盖（overwrite）前者的值。

自有属性的枚举顺序

数字类型在前，以升序排列
string类型和symbol类型的以被添加的顺序排列（怎么赋予的，怎么展示的）

var obj = {
    60:222,
    'work':'coding',
    '3tt':'number in string',
     2:25
}

obj[4]= 'bulabula'
obj[2] = 50

Object.getOwnPropertyNames(obj) //Array(5) ["2", "4", "60", "work", "3tt"]

Object.setPrototypeOf()

改变了对象的原型

let person = {
    getGreeting() {
        return "Hello";
    }
};

let dog = {
    getGreeting() {
        return "Woof";
    }
};

// prototype is person
let friend = Object.create(person);
console.log(friend.getGreeting());                      // "Hello"
console.log(Object.getPrototypeOf(friend) === person);  // true

// set prototype to dog
Object.setPrototypeOf(friend, dog);
console.log(friend.getGreeting());                      // "Woof"
console.log(Object.getPrototypeOf(friend) === dog);     // true

super reference 继承更高一级的类

super是一个指针，指向了当前对象的原型，即Object.getPrototypeOf(this)的值。但使用时必须要在对象内部的简洁方法中才可以使用，就是 someFunction(){} 这样的写法（吐槽一下，这是为毛啊。。。。用non-concise methods写居然还报语法错误）。

接上段person的代码————

let friend = {
    getGreeting() {
        // in the previous example, this is the same as:
        // Object.getPrototypeOf(this).getGreeting.call(this)
        return super.getGreeting() + ", hi!";
    }
};

Object.setPrototypeOf(friend, person)

let relative = Object.create(friend)

relative.getGreeting()  // Hello, hi!

// 这里如果friend 里的 getGreeting 方法没有用super定义，而是直接绑定的 this 就会因为迭代引用自身而导致栈溢出报错。而super的指向不是动态的，不管有多少子孙后代对象继承了getGreeting 方法，super 始终是person 对象。