ES6 对象的扩展、对象的新增方法、Symbol

对象的扩展

1、属性的简洁表示法

（1）在{}里直接写入变量和函数

            var foo = "bar";
            const baz = {
    
    foo};
            console.log(baz);		//foo:"bar"

（2）函数直接返回对象

            function f(x,y){
    
    
                return {
    
    x,y};
            }
            console.log(f(1,2));	//{
    
    x:1,y:2}

（3）简写的对象方法不能用作构造函数

2、属性名表达式

1、定义对象的属性：
（1）用标识符做属性名
obj.foo=true;
（2）用表达式作为属性名
obj[‘a’+‘bc’]=123;
2.（1）如果使用字面量方法定义对象（使用{}），ES5只支持第一种方法定义属性
（2）ES6允许第二种方法定义属性

let propKey = 'foo';

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

（3）表达式用于方法名

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

obj.hello() // hi

3、方法的name属性

属性的name属性返回函数名，而对象方法也是函数，因此也有name属性。

const person = {
    
    
  sayName() {
    
    
    console.log('hello!');
  },
};

person.sayName.name   // "sayName"

• 如果使用了取值函数（getter）和村指函数（setter），则name属性也不是在该方法上面，而在该方法描述对象的get和set属性，返回值是方法名前加上get和set。

const obj = {
    
    
  get foo() {
    
    },
  set foo(x) {
    
    }
};

obj.foo.name		//报错

const descriptor = Object.getOwnPropertyDescriptor(obj, 'foo');

descriptor.get.name // "get foo"
descriptor.set.name // "set foo"

• bind方法创造的函数，name属性返回bound加上原函数的名字，Function构造函数构造额函数，name属性返回anonymous.

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

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

4.属性的枚举性和遍历

1、可枚举性
对象的每个属性都有一个描述对象（Descriptor），用来控制该属性的行为，Object.getOwnPropertyDescriptor方法用来获取该属性的描述对象。

let obj = {
    
     foo: 123 };
Object.getOwnPropertyDescriptor(obj, 'foo')
//  {
    
    
//    value: 123,
//    writable: true,
//    enumerable: true,
//    configurable: true
//  }

描述对象的enumerable属性，称为“可枚举性”，如果该属性为false，就表示某些操作会忽略当前属性。目前，有四个操作会忽略enumerable为false的属性。

for…in循环：只遍历对象自身的和继承的可枚举的属性。
Object.keys()：返回对象自身的所有可枚举的属性的键名。
JSON.stringify()：只串行化对象自身的可枚举的属性。
Object.assign()： 忽略enumerable为false的属性，只拷贝对象自身的可枚举的属性。
这四个操作之中

• 属性的遍历
  （1）for…in
  （2）Object.keys(obj)
  （3）Object.getOwnPropertySymbols(obj)
  （4）Obkect.getOwnPropertyNames(obj)
  （5）Reflect.ownkeys(obj)

5.super关键字

super，指向当前对象的原型对象。

const proto = {
    
    
  foo: 'hello'
};

const obj = {
    
    
  foo: 'world',
  find() {
    
    
    return super.foo;
  }
};

Object.setPrototypeOf(obj, proto);
obj.find() // "hello"，通过super.foo引用了原型对象proto的foo属性

super关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。

• JavaScript 引擎内部，super.foo等同于Object.getPrototypeOf(this).foo（属性）或Object.getPrototypeOf(this).foo.call(this)（方法）。

6、对象的扩展运算符

1、解构赋值
对象的解构赋值用于从一个对象取值，相当于将目标对象自身的所有可遍历的、但尚未被读取的属性，分配到指定的对象上面。所有的键和它们的值，都会拷贝到新对象上面。

let {
    
     x, y, ...z } = {
    
     x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // {
    
     a: 3, b: 4 }

• 由于解构赋值要求等号右边是一个对象，所以如果等号右边是undefined或null，就会报错，因为它们无法转为对象。

let {
    
     ...z } = null; // 运行时错误
let {
    
     ...z } = undefined; // 运行时错误

• 解构赋值必须是最后一个参数，否则会报错。

let {
    
     ...x, y, z } = someObject; // 句法错误
let {
    
     x, ...y, ...z } = someObject; // 句法错误

• 解构赋值的拷贝是浅拷贝，即如果一个键的值是复合类型的值（数组、对象、函数）、那么解构赋值拷贝的是这个值的引用，而不是这个值的副本。

let obj = {
    
     a: {
    
     b: 1 } };
let {
    
     ...x } = obj;
obj.a.b = 2;
x.a.b // 2

• 扩展运算符后面必须是一个变量名，而不能是一个解构赋值表达式。

let {
    
     x, ...{
    
     y, z } } = o;

2、扩展运算符
对象的扩展运算符（…）用于取出参数对象的所有可遍历属性，拷贝到当前对象之中。

let z = {
    
     a: 3, b: 4 };
let n = {
    
     ...z };
n // {
    
     a: 3, b: 4 }

• 由于数组是特殊的对象，所以对象的扩展运算符也可以用于数组。

let foo = {
    
     ...['a', 'b', 'c'] };
foo// {
    
    0: "a", 1: "b", 2: "c"}

• 如果扩展运算符后面是一个空对象，则没有任何效果

{
    
    ...{
    
    }, a: 1}
// {
    
     a: 1 }

• 如果扩展运算符后面不是对象，则会自动将其转为对象。
• 由于该对象没有自身属性，所以返回一个空对象。

// 等同于 {
    
    ...Object(true)}
{
    
    ...true} // {
    
    }

// 等同于 {
    
    ...Object(undefined)}
{
    
    ...undefined} // {
    
    }

// 等同于 {
    
    ...Object(null)}
{
    
    ...null} // {
    
    }

• 如果扩展运算符后面是字符串，它会自动转成一个类似数组的对象，因此返回的不是空对象。

{
    
    ...'hello'}
// {
    
    0: "h", 1: "e", 2: "l", 3: "l", 4: "o"}

• 对象的扩展运算符等同于使用Object.assign()方法。

let aClone = {
    
     ...a };
// 等同于
let aClone = Object.assign({
    
    }, a);

• 扩展运算符可以用于合并两个对象

let ab = {
    
     ...a, ...b };
// 等同于
let ab = Object.assign({
    
    }, a, b);

7、链判断运算符

编程实务中，如果读取对象内部的某个属性，往往需要判断一下该对象是否存在。ES2020引入“链判断运算符”：(?.)

//在链式调用的时候判断，左侧的对象是否为null或undefined。
//如果是的，就不再往下运算，而是返回undefined。

const firstName = message?.body?.user?.firstName || 'default';
const fooValue = myForm.querySelector('input[name=foo]')?.value
-------------------------------------------------------
iterator.return如果有定义，就会调用该方法，
否则iterator.return直接返回undefined，不再执行?.后面的部分。

iterator.return?.()

• 链判断运算符的三种用法：

obj?.prop // 对象属性
obj?.[expr] // 同上
func?.(…args) // 函数或对象方法的调用

• 注意：
  （1）短路机制： ?.运算符相当于一种短路机制，只要不满足条件，就不再往下执行。
  （2）delete 运算符
  （3）括号的影响：如果属性链有圆括号，链判断运算符对圆括号外部没有影响，只对圆括号内部有影响。
  （4）右侧不得为十进制数值

8、Null判断运算符

读取对象属性的时候，如果某个属性的值是null或undefined，有时候需要为它们指定默认值。ES2020 引入了一个新的 Null 判断运算符??。它的行为类似||，但是只有运算符左侧的值为null或undefined时，才会返回右侧的值。

const headerText = response.settings.headerText ?? 'Hello, world!';
const animationDuration = response.settings.animationDuration ?? 300;
const showSplashScreen = response.settings.showSplashScreen ?? true;

这个运算符的一个目的，就是跟链判断运算符?.配合使用，为null或undefined的值设置默认值。

const animationDuration = response.settings?.animationDuration ?? 300;

• 必须用括号表明优先级，否则会报错。

对象的新增方法

1.Object.is()

它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。

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

2.Object.assign()

1.基本用法：用于对象的合并，将源对象的所有可枚举属性，复制到目标对象，添加到尾部。

const target = {
    
     a: 1 };

const source1 = {
    
     b: 2 };
const source2 = {
    
     c: 3 };

Object.assign(target, source1, source2);
target // {
    
    a:1, b:2, c:3}

• 如果只有一个参数，Object.assign()会直接返回该参数。

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

• 如果该参数不是对象，则会先转成对象，然后返回。
• 由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。如果无法转成对象且不在首位置，就会跳过。这意味着，如果undefined和null不在首参数，就不会报错。
• 其他类型的值（即数值、字符串和布尔值）不在首参数，也不会报错。但是，除了字符串会以数组形式，拷贝入目标对象，其他值都不会产生效果。

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

const obj = Object.assign({
    
    }, v1, v2, v3);
console.log(obj); // {
    
     "0": "a", "1": "b", "2": "c" }

• Object.assign()只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（enumerable: false）。
• 注意：
  （1）浅拷贝：Object.assign()方法实行的是浅拷贝，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。

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

obj1.a.b = 2;
obj2.a.b // 2

（2）同名属性的替换：对于这种嵌套的对象，一旦遇到同名属性，Object.assign()的处理方法是替换，而不是添加。

const target = {
    
     a: {
    
     b: 'c', d: 'e' } }
const source = {
    
     a: {
    
     b: 'hello' } }
Object.assign(target, source)

（3）数组的处理：Object.assign()可以用来处理数组，但是会把数组视为对象。

Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3]，Object.assign()把数组视为属性名为 0、1、2 的对象，因此源数组的 0 号属性4覆盖了目标数组的 0 号属性1。

（4）取值函数的处理：Object.assign()只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。

const source = {
    
    
  get foo() {
    
     return 1 }
};
const target = {
    
    };

Object.assign(target, source)
// {
    
     foo: 1 }

• 常见用途：
  （1）为对象添加属性：

class Point {
    
    
  constructor(x, y) {
    
    
    Object.assign(this, {
    
    x, y});
  }
}

（2）为对象添加方法

Object.assign(SomeClass.prototype, {
    
    
  someMethod(arg1, arg2) {
    
    
    ···
  },
  anotherMethod() {
    
    
    ···
  }
});

（3）克隆对象：

function clone(origin) {
    
    
  return Object.assign({
    
    }, origin);
}

（4）合并多个对象

const merge =
  (...sources) => Object.assign({
    
    }, ...sources);

（5）为属性指定默认值

const DEFAULTS = {
    
    
  logLevel: 0,
  outputFormat: 'html'
};

function processContent(options) {
    
    
  options = Object.assign({
    
    }, DEFAULTS, options);
  console.log(options);
  // ...
}

3.Object.getOwnPropertyDescriptor()

1.用于：会返回某个对象属性的描述对象。

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

Object.getOwnPropertyDescriptors(obj)

Object.getOwnPropertyDescriptors()方法返回一个对象，所有原对象的属性名都是该对象的属性名，对应的属性值就是该属性的描述对象。

function getOwnPropertyDescriptors(obj) {
    
    
  const result = {
    
    };
  for (let key of Reflect.ownKeys(obj)) {
    
    
    result[key] = Object.getOwnPropertyDescriptor(obj, key);
  }
  return result;
}

4.__proto__属性，Object.setPrototypeOf()，Object.getPrototypeOf()

1._ proto _:用来读取或设置当前对象的原型对象。

// es5 的写法
const obj = {
    
    
  method: function() {
    
     ... }
};
obj.__proto__ = someOtherObj;

// es6 的写法
var obj = Object.create(someOtherObj);
obj.method = function() {
    
     ... };

2.Object.setPrototypeOf()

用来设置一个对象的原型对象，返回参数对象本身。它是 ES6 正式推荐的设置原型对象的方法。

let proto = {
    
    };
let obj = {
    
     x: 10 };
Object.setPrototypeOf(obj, proto);

proto.y = 20;
proto.z = 40;

obj.x // 10
obj.y // 20
obj.z // 40

3.Object.getPrototypeOf()

用于读取一个对象的原型对象。

function Rectangle() {
    
    
  // ...
}

const rec = new Rectangle();

Object.getPrototypeOf(rec) === Rectangle.prototype
// true

Object.setPrototypeOf(rec, Object.prototype);
Object.getPrototypeOf(rec) === Rectangle.prototype
// false

5.Object.keys(),Object.values(),Object.entries()

1.Object.keys()

返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键名。

var obj = {
    
     foo: 'bar', baz: 42 };
Object.keys(obj)
// ["foo", "baz"]

2.Object.values()

方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键值。

const obj = {
    
     foo: 'bar', baz: 42 };
Object.values(obj)
// ["bar", 42]

• 返回数组的元素的顺序，按照键的数值大小，从小到大排列

const obj = {
    
     100: 'a', 2: 'b', 7: 'c' };
Object.values(obj)
// ["b", "c", "a"]

• Object.values会过滤属性名为 Symbol 值的属性。
• 如果Object.values方法的参数是一个字符串，会返回各个字符组成的一个数组。

3.Object.entires()

返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键值对数组。

const obj = {
    
     foo: 'bar', baz: 42 };
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]

• 用法：
  （1）Object.entries的基本用途是遍历对象的属性。
  （2）Object.entries方法的另一个用处是，将对象转为真正的Map结构。

const obj = {
    
     foo: 'bar', baz: 42 };
const map = new Map(Object.entries(obj));
map // Map {
    
     foo: "bar", baz: 42 }

6.Object.fromEntires()

Object.entries()的逆操作，用于将一个键值对数组转为对象。

Object.fromEntries([
  ['foo', 'bar'],
  ['baz', 42]
])
// {
    
     foo: "bar", baz: 42 }

该方法的主要目的，是将键值对的数据结构还原为对象，因此特别适合将 Map 结构转为对象。

const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);

Object.fromEntries(entries)
// {
    
     foo: "bar", baz: 42 }

三、Symbol

1.概述

symbol：表示独一无二的值。它是一种类似于字符串的数据类型。
它是 JavaScript 语言的第七种数据类型，前六种是：undefined、null、布尔值（Boolean）、字符串（String）、数值（Number）、对象（Object）。
1.Symbol对象的创建：

let s = Symbol();
let s1 = Symbol('foo');
let s2 = Symbol('bar');

s	//Symbol()
s1 // Symbol(foo)
s2 // Symbol(bar)

s1.toString() // "Symbol(foo)"
s2.toString() // "Symbol(bar)"

• Symbol 值不能与其他类型的值进行运算，会报错。
• Symbol 值可以显式转为字符串。

let sym = Symbol('My symbol');

String(sym) // 'Symbol(My symbol)'
sym.toString() // 'Symbol(My symbol)'

• Symbol 值也可以转为布尔值，但是不能转为数值。

let sym = Symbol();
Boolean(sym) // true
!sym  // false

if (sym) {
    
    
  // ...
}

Number(sym) // TypeError
sym + 2 // TypeError

2.Symbol.prototype.descript()

创建 Symbol 的时候，可以添加一个描述。

//sym的描述就是字符串foo。

const sym = Symbol('foo');
sym.description // "foo"

3.作为属性名的Symbol

由于每一个 Symbol 值都是不相等的，这意味着 Symbol 值可以作为标识符，用于对象的属性名，就能保证不会出现同名的属性。

let mySymbol = Symbol();

// 第一种写法
let a = {
    
    };
a[mySymbol] = 'Hello!';

// 第二种写法
let a = {
    
    
  [mySymbol]: 'Hello!'
};

// 第三种写法
let a = {
    
    };
Object.defineProperty(a, mySymbol, {
    
     value: 'Hello!' });

// 以上写法都得到同样结果
a[mySymbol] // "Hello!"

• Symbol 值作为对象属性名时，不能用点运算符。因此，在对象的内部，使用 Symbol 值定义属性时，Symbol 值必须放在方括号之中。

const mySymbol = Symbol();
const a = {
    
    };

a.mySymbol = 'Hello!';
//为点运算符后面总是字符串，所以不会读取mySymbol作为标识名所指代的那个值，导致a的属性名实际上是一个字符串，而不是一个 Symbol 值
a[mySymbol] // undefined
a['mySymbol'] // "Hello!"

let s = Symbol();
let obj = {
    
    
  [s]: function (arg) {
    
     ... }
};
obj[s](123);

4.属性名的遍历

Object.getOwnPropertySymbols()方法，可以获取指定对象的所有 Symbol 属性名。该方法返回一个数组，成员是当前对象的所有用作属性名的 Symbol 值。

const obj = {
    
    };
let a = Symbol('a');
let b = Symbol('b');

obj[a] = 'Hello';
obj[b] = 'World';

const objectSymbols = Object.getOwnPropertySymbols(obj);

objectSymbols
// [Symbol(a), Symbol(b)]

• Reflect.ownKeys()方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。

let obj = {
    
    
  [Symbol('my_key')]: 1,
  enum: 2,
  nonEnum: 3
};

Reflect.ownKeys(obj)
//  ["enum", "nonEnum", Symbol(my_key)]

6.Symbol.for(),Symbol.kayFor()

1、Symbol.for()
用法：重新使用同一个 Symbol 值。可以接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建一个以该字符串为名称的 Symbol 值，并将其注册到全局。

//s1和s2都是 Symbol 值，但是它们都是由同样参数的Symbol.for方法生成的，所以实际上是同一个值。
let s1 = Symbol.for('foo');
let s2 = Symbol.for('foo');

s1 === s2 // true

2、Symbol.kayFor()
用法：返回一个已登记的 Symbol 类型值的key。

let s1 = Symbol.for("foo");
Symbol.keyFor(s1) // "foo"

//变量s2没有用 Symbol.for登记Symbol值，所以返回undefined。
let s2 = Symbol("foo");
Symbol.keyFor(s2) // undefined

7.内置的Symbol值

1、Symbol.hasInstance
该属性指向一个内部方法。当其他对象使用instanceof运算符，判断是否为该对象的实例时，会调用这个方法。比如，foo instanceof Foo在语言内部，实际调用的是Foo[Symbol.hasInstance] (foo)。

class MyClass {
    
    
  [Symbol.hasInstance](foo) {
    
    
    return foo instanceof Array;
  }
}

[1, 2, 3] instanceof new MyClass() // true

2、Symbol.isConcatSpreadable
该属性等于一个布尔值，表示该对象用于Array.prototype.concat()时，是否可以展开。

• 数组的默认行为是可以展开，Symbol.isConcatSpreadable默认等于undefined。该属性等于true时，也有展开的效果。
  类似数组的对象正好相反，默认不展开。它的Symbol.isConcatSpreadable属性设为true，才可以展开。

let arr1 = ['c', 'd'];
['a', 'b'].concat(arr1, 'e') // ['a', 'b', 'c', 'd', 'e']
arr1[Symbol.isConcatSpreadable] // undefined

let arr2 = ['c', 'd'];
arr2[Symbol.isConcatSpreadable] = false;
['a', 'b'].concat(arr2, 'e') // ['a', 'b', ['c','d'], 'e']

3、Symbol.species
该属性指向一个构造函数。创建衍生对象时，会使用该属性。

class MyArray extends Array {
    
    
}

const a = new MyArray(1, 2, 3);
const b = a.map(x => x);
const c = a.filter(x => x > 1);

b instanceof MyArray // true
c instanceof MyArray // true
//a,b,c都是MyArray实例

//给MyArray设置Symbol.species属性
class MyArray extends Array {
    
    
  static get [Symbol.species]() {
    
     return Array; }
}

4、Symbol.match
该属性指向一个函数。当执行str.match(myObject)时，如果该属性存在，会调用它，返回该方法的返回值。

String.prototype.match(regexp)
// 等同于
regexp[Symbol.match](this)

class MyMatcher {
    
    
  [Symbol.match](string) {
    
    
    return 'hello world'.indexOf(string);
  }
}

'e'.match(new MyMatcher()) // 1

5、Symbol.replace
该属性指向一个方法，当该对象被String.prototype.replace方法调用时，会返回该方法的返回值。

String.prototype.replace(searchValue, replaceValue)
// 等同于
searchValue[Symbol.replace](this, replaceValue)

6、Symbol.search()
该属性指向一个方法，当该对象被String.prototype.search方法调用时，会返回该方法的返回值。

String.prototype.search(regexp)
// 等同于
regexp[Symbol.search](this)

class MySearch {
    
    
  constructor(value) {
    
    
    this.value = value;
  }
  [Symbol.search](string) {
    
    
    return string.indexOf(this.value);
  }
}
'foobar'.search(new MySearch('foo')) // 0

7、Symbol.split
该属性指向一个方法，当该对象被String.prototype.split方法调用时，会返回该方法的返回值。

String.prototype.split(separator, limit)
// 等同于
separator[Symbol.split](this, limit)

8、Symbol.iterator
对象的Symbol.iterator属性，指向该对象的默认遍历器方法。

const myIterable = {
    
    };
myIterable[Symbol.iterator] = function* () {
    
    
  yield 1;
  yield 2;
  yield 3;
};

[...myIterable] // [1, 2, 3]

9、Symbol.toPrimitive
该属性指向一个方法。该对象被转为原始类型的值时，会调用这个方法，返回该对象对应的原始类型值。

Symbol.toPrimitive被调用时，会接受一个字符串参数，表示当前运算的模式，一共有三种模式：

Number：该场合需要转成数值
String：该场合需要转成字符串
Default：该场合可以转成数值，也可以转成字符串

10、Symbol.toStringTag
指向一个方法。在该对象上面调用Object.prototype.toString方法时，如果这个属性存在，它的返回值会出现在toString方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制[object Object]或[object Array]中object后面的那个字符串。

({
    
    [Symbol.toStringTag]: 'Foo'}.toString())
// "[object Foo]"

11、Symbol.unscopables
该属性指向一个对象。该对象指定了使用with关键字时，哪些属性会被with环境排除。