对象的扩展
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环境排除。