Symbol 类型与Object类型

最新推荐文章于 2022-11-04 14:58:12 发布
最新推荐文章于 2022-11-04 14:58:12 发布
阅读量521 收藏 1
点赞数 1
分类专栏： javaScript系列 干货 web 文章标签： js javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45768871/article/details/110434595
版权
web 同时被 3 个专栏收录
84 篇文章 4 订阅
订阅专栏
javaScript系列
59 篇文章 1 订阅
订阅专栏
干货
40 篇文章 1 订阅
订阅专栏

有汗水，有仔细、有心，前面的路没有转角。——范华倩
在这里插入图片描述

文章目录

Symbol 类型

Symbol（符号）是 ECMAScript 6 新增的数据类型。符号是原始值，且符号实例是唯一、不可变的。
符号的用途是确保对象属性使用唯一标识符，不会发生属性冲突的危险。
尽管听起来跟私有属性有点类似，但符号并不是为了提供私有属性的行为才增加的（尤其是因为
Object API 提供了方法，可以更方便地发现符号属性）。相反，符号就是用来创建唯一记号，进而用作非
字符串形式的对象属性。

1. 符号的基本用法

符号需要使用Symbol()函数初始化。因为符号本身是原始类型，所以 typeof 操作符对符号返回symbol。


let sym = Symbol(); 
console.log(typeof sym); // symbol

调用Symbol()函数时，也可以传入一个字符串参数作为对符号的描述（description），将来可以通
过这个字符串来调试代码。但是，这个字符串参数与符号定义或标识完全无关：

let genericSymbol = Symbol(); 
let otherGenericSymbol = Symbol(); 
let fooSymbol = Symbol('foo'); 
let otherFooSymbol = Symbol('foo'); 
console.log(genericSymbol == otherGenericSymbol); // false 
console.log(fooSymbol == otherFooSymbol); // false

在这里插入图片描述

符号没有字面量语法，这也是它们发挥作用的关键。按照规范，你只要创建 Symbol()实例并将其
用作对象的新属性，就可以保证它不会覆盖已有的对象属性，无论是符号属性还是字符串属性。

let genericSymbol = Symbol(); 
console.log(genericSymbol); // Symbol() 
let fooSymbol = Symbol('foo'); 
console.log(fooSymbol); // Symbol(foo);

在这里插入图片描述

最重要的是，Symbol()函数不能与 new 关键字一起作为构造函数使用。这样做是为了避免创建符
号包装对象，像使用 Boolean、String 或 Number 那样，它们都支持构造函数且可用于初始化包含原
始值的包装对象：

let myBoolean = new Boolean(); 
console.log(typeof myBoolean); // "object" 
let myString = new String(); 
console.log(typeof myString); // "object" 
let myNumber = new Number(); 
console.log(typeof myNumber); // "object"

let mySymbol = new Symbol(); // TypeError: Symbol is not a constructor

在这里插入图片描述

如果你确实想使用符号包装对象，可以借用 Object()函数：

let mySymbol = Symbol(); 
let myWrappedSymbol = Object(mySymbol); 
console.log(typeof myWrappedSymbol); // "object"

在这里插入图片描述

2. 使用全局符号注册表

如果运行时的不同部分需要共享和重用符号实例，那么可以用一个字符串作为键，在全局符号注册
表中创建并重用符号。

为此，需要使用Symbol.for()方法：

let fooGlobalSymbol = Symbol.for('foo'); 
console.log(typeof fooGlobalSymbol); // symbol

在这里插入图片描述

Symbol.for()对每个字符串键都执行幂等操作。第一次使用某个字符串调用时，它会检查全局运
行时注册表，发现不存在对应的符号，于是就会生成一个新符号实例并添加到注册表中。后续使用相同
字符串的调用同样会检查注册表，发现存在与该字符串对应的符号，然后就会返回该符号实例。

let fooGlobalSymbol = Symbol.for('foo'); // 创建新符号
let otherFooGlobalSymbol = Symbol.for('foo'); // 重用已有符号
console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true

在这里插入图片描述

即使采用相同的符号描述，在全局注册表中定义的符号跟使用 Symbol()定义的符号也并不等同：

let localSymbol = Symbol('foo'); 
let globalSymbol = Symbol.for('foo'); 
console.log(localSymbol === globalSymbol); // false

在这里插入图片描述

全局注册表中的符号必须使用字符串键来创建，因此作为参数传给 Symbol.for()的任何值都会被转换为字符串。此外，注册表中使用的键同时也会被用作符号描述。

let emptyGlobalSymbol = Symbol.for(); 
console.log(emptyGlobalSymbol); // Symbol(undefined)

在这里插入图片描述
还可以使用 Symbol.keyFor()来查询全局注册表，这个方法接收符号，返回该全局符号对应的字符串键。如果查询的不是全局符号，则返回 undefined。

// 创建全局符号
let s = Symbol.for('foo'); 
console.log(Symbol.keyFor(s)); // foo 
// 创建普通符号
let s2 = Symbol('bar'); 
console.log(Symbol.keyFor(s2)); // undefined

在这里插入图片描述

如果传给 Symbol.keyFor()的不是符号，则该方法抛出TypeError：

Symbol.keyFor(123); // TypeError: 123 is not a symbol

在这里插入图片描述

3. 使用符号作为属性

凡是可以使用字符串或数值作为属性的地方，都可以使用符号。这就包括了对象字面量属性和
Object.defineProperty()/Object.defineProperties()定义的属性。对象字面量只能在计算属
性语法中使用符号作为属性。

let s1 = Symbol('foo'), 
 s2 = Symbol('bar'), 
 s3 = Symbol('baz'), 
 s4 = Symbol('qux'); 
let o = { 
 [s1]: 'foo val' 
}; 
// 这样也可以：o[s1] = 'foo val'; 
console.log(o); 
// {Symbol(foo): foo val} 
Object.defineProperty(o, s2, {value: 'bar val'}); 
console.log(o); 
// {Symbol(foo): foo val, Symbol(bar): bar val} 
Object.defineProperties(o, { 
 [s3]: {value: 'baz val'}, 
 [s4]: {value: 'qux val'} 
}); 
console.log(o);
// {Symbol(foo): foo val, Symbol(bar): bar val, 
// Symbol(baz): baz val, Symbol(qux): qux val}

在这里插入图片描述

类似于
Object.getOwnPropertyNames()返回对象实例的常规属性数组，Object.getOwnPropertySymbols()返回对象实例的符号属性数组。这两个方法的返回值彼此互斥。Object.getOwnPropertyDescriptors()会返回同时包含常规和符号属性描述符的对象。Reflect.ownKeys()会返回两种类型
的键：

let s1 = Symbol('foo'), 
 s2 = Symbol('bar'); 
let o = { 
 [s1]: 'foo val', 
 [s2]: 'bar val', 
 baz: 'baz val', 
 qux: 'qux val' 
}; 
console.log(Object.getOwnPropertySymbols(o)); 
// [Symbol(foo), Symbol(bar)] 
console.log(Object.getOwnPropertyNames(o)); 
// ["baz", "qux"] 
console.log(Object.getOwnPropertyDescriptors(o)); 
// {baz: {...}, qux: {...}, Symbol(foo): {...}, Symbol(bar): {...}} 
console.log(Reflect.ownKeys(o)); 
// ["baz", "qux", Symbol(foo), Symbol(bar)]

在这里插入图片描述

  • 因为符号属性是对内存中符号的一个引用，所以直接创建并用作属性的符号不会丢失。但是，如果
    没有显式地保存对这些属性的引用，那么必须遍历对象的所有符号属性才能找到相应的属性键：
let o = { 
 [Symbol('foo')]: 'foo val', 
 [Symbol('bar')]: 'bar val' 
}; 
console.log(o); 
// {Symbol(foo): "foo val", Symbol(bar): "bar val"} 
let barSymbol = Object.getOwnPropertySymbols(o) 
 .find((symbol) => symbol.toString().match(/bar/)); 
console.log(barSymbol); 
// Symbol(bar)

在这里插入图片描述

4. 常用内置符号

  • ECMAScript 6 也引入了一批常用内置符号（well-known symbol），用于暴露语言内部行为，开发者
    可以直接访问、重写或模拟这些行为。这些内置符号都以 Symbol 工厂函数字符串属性的形式存在。

  • 这些内置符号最重要的用途之一是重新定义它们，从而改变原生结构的行为。比如，我们知道
    for-of 循环会在相关对象上使用 Symbol.iterator 属性，那么就可以通过在自定义对象上重新定义
    Symbol.iterator 的值，来改变 for-of 在迭代该对象时的行为。

  • 这些内置符号也没有什么特别之处，它们就是全局函数 Symbol 的普通字符串属性，指向一个符号
    的实例。所有内置符号属性都是不可写、不可枚举、不可配置的。

  • 注意 在提到 ECMAScript 规范时，经常会引用符号在规范中的名称，前缀为@@。比如， @@iterator 指的就是 Symbol.iterator。

5. Symbol.asyncIterator

根据 ECMAScript 规范，这个符号作为一个属性表示“一个方法，该方法返回对象默认的 AsyncIterator。 由 for-await-of 语句使用”。换句话说，这个符号表示实现异步迭代器 API 的函数。
for-await-of循环会利用这个函数执行异步迭代操作。循环时，它们会调用以 Symbol.asyncIterator
为键的函数，并期望这个函数会返回一个实现迭代器 API 的对象。很多时候，返回的对象是实现该 API
的 AsyncGenerator：

class Foo { 
 async *[Symbol.asyncIterator]() {} 
} 
let f = new Foo(); 
console.log(f[Symbol.asyncIterator]()); 
// AsyncGenerator {<suspended>}

在这里插入图片描述

技术上，这个由 Symbol.asyncIterator 函数生成的对象应该通过其 next()方法陆续返回
Promise 实例。可以通过显式地调用 next()方法返回，也可以隐式地通过异步生成器函数返回：

class Emitter { 
 constructor(max) { 
	 this.max = max; 
	 this.asyncIdx = 0; 
 } 
 async *[Symbol.asyncIterator]() { 
	 while(this.asyncIdx < this.max) { 
		 yield new Promise((resolve) => resolve(this.asyncIdx++)); 
		 } 
	 } 
} 
async function asyncCount() { 
 let emitter = new Emitter(5); 
 for await(const x of emitter) { 
 	console.log(x); 
 } 
} 
asyncCount();

在这里插入图片描述

注意: Symbol.asyncIterator 是 ES2018 规范定义的，因此只有版本非常新的浏览器 支持它。

6. Symbol.hasInstance

根据 ECMAScript 规范，这个符号作为一个属性表示“一个方法，该方法决定一个构造器对象是否
认可一个对象是它的实例。由instanceof操作符使用”。instanceof操作符可以用来确定一个对象
实例的原型链上是否有原型。instanceof的典型使用场景如下：

function Foo() {} 
let f = new Foo(); 
console.log(f instanceof Foo); // true 
class Bar {} 
let b = new Bar(); 
console.log(b instanceof Bar); // true

在这里插入图片描述

在 ES6 中，instanceof 操作符会使用 Symbol.hasInstance 函数来确定关系。以 Symbol.
hasInstance 为键的函数会执行同样的操作，只是操作数对调了一下：

function Foo() {} 
let f = new Foo(); 
console.log(Foo[Symbol.hasInstance](f)); // true 
class Bar {} 
let b = new Bar(); 
console.log(Bar[Symbol.hasInstance](b)); // true

在这里插入图片描述

这个属性定义在 Function 的原型上，因此默认在所有函数和类上都可以调用。由于 instanceof
操作符会在原型链上寻找这个属性定义，就跟在原型链上寻找其他属性一样，因此可以在继承的类上通
过静态方法重新定义这个函数：

class Bar {} 
class Baz extends Bar { 
 static [Symbol.hasInstance]() { 
 return false; 
 } 
} 
let b = new Baz(); 
console.log(Bar[Symbol.hasInstance](b)); // true 
console.log(b instanceof Bar); // true 
console.log(Baz[Symbol.hasInstance](b)); // false 
console.log(b instanceof Baz); // false

在这里插入图片描述

7. Symbol.isConcatSpreadable

  • 根据 ECMAScript 规范，这个符号作为一个属性表示“一个布尔值，如果是 true，则意味着对象应
    该用Array.prototype.concat()打平其数组元素”。ES6 中的 Array.prototype.concat()方法会根据接收到的对象类型选择如何将一个类数组对象拼接成数组实例。覆盖 Symbol.isConcatSpreadable的值可以修改这个行为。
  • 数组对象默认情况下会被打平到已有的数组，false 或假值会导致整个对象被追加到数组末尾。类
    数组对象默认情况下会被追加到数组末尾，true 或真值会导致这个类数组对象被打平到数组实例。其
    他不是类数组对象的对象在 Symbol.isConcatSpreadable被设置为 true 的情况下将被忽略。
let initial = ['foo']; 
let array = ['bar']; 
console.log(array[Symbol.isConcatSpreadable]); // undefined 
console.log(initial.concat(array)); // ['foo', 'bar'] 

array[Symbol.isConcatSpreadable] = false; 
console.log(initial.concat(array)); // ['foo', Array(1)]

let arrayLikeObject = { length: 1, 0: 'baz' }; 
console.log(arrayLikeObject[Symbol.isConcatSpreadable]); // undefined 
console.log(initial.concat(arrayLikeObject)); // ['foo', {...}] 
arrayLikeObject[Symbol.isConcatSpreadable] = true; 
console.log(initial.concat(arrayLikeObject)); // ['foo', 'baz'] 

let otherObject = new Set().add('qux'); 
console.log(otherObject[Symbol.isConcatSpreadable]); // undefined 
console.log(initial.concat(otherObject)); // ['foo', Set(1)] 
otherObject[Symbol.isConcatSpreadable] = true; 
console.log(initial.concat(otherObject)); // ['foo']

在这里插入图片描述

8. Symbol.iterator

根据 ECMAScript 规范，这个符号作为一个属性表示“一个方法，该方法返回对象默认的迭代器。
由 for-of语句使用”。换句话说，这个符号表示实现迭代器 API 的函数。
for-of 循环这样的语言结构会利用这个函数执行迭代操作。循环时，它们会调用以 Symbol.iterator为键的函数，并默认这个函数会返回一个实现迭代器 API 的对象。很多时候，返回的对象是实现该 API
的 Generator：

class Foo { 
 *[Symbol.iterator]() {} 
} 
let f = new Foo(); 
console.log(f[Symbol.iterator]()); 
// Generator {<suspended>}

在这里插入图片描述

技术上，这个由Symbol.iterator 函数生成的对象应该通过其 next()方法陆续返回值。可以通
过显式地调用 next()方法返回，也可以隐式地通过生成器函数返回：

class Emitter { 
	 constructor(max) { 
		 this.max = max; 
		 this.idx = 0; 
	 } 
	 *[Symbol.iterator]() { 
		 while(this.idx < this.max) { 
			 yield this.idx++; 
	     } 
	 } 
} 
function count() { 
	 let emitter = new Emitter(5); 
	 for (const x of emitter) { 
		 console.log(x); 
	 } 
} 
count();

在这里插入图片描述

9. Symbol.match

根据 ECMAScript 规范，这个符号作为一个属性表示“一个正则表达式方法，该方法用正则表达式
去匹配字符串。由 String.prototype.match()方法使用”。String.prototype.match()方法会使
用以 Symbol.match 为键的函数来对正则表达式求值。正则表达式的原型上默认有这个函数的定义，
因此所有正则表达式实例默认是这个 String 方法的有效参数：

console.log(RegExp.prototype[Symbol.match]); 
// ƒ [Symbol.match]() { [native code] } 
console.log('foobar'.match(/bar/)); 
// ["bar", index: 3, input: "foobar", groups: undefined]

在这里插入图片描述

给这个方法传入非正则表达式值会导致该值被转换为 RegExp 对象。如果想改变这种行为，让方法
直接使用参数，则可以重新定义 Symbol.match 函数以取代默认对正则表达式求值的行为，从而让
match()方法使用非正则表达式实例。Symbol.match 函数接收一个参数，就是调用 match()方法的
字符串实例。返回的值没有限制：

class FooMatcher {
 static [Symbol.match](target) { 
	 return target.includes('foo'); 
 } 
} 
console.log('foobar'.match(FooMatcher)); // true 
console.log('barbaz'.match(FooMatcher)); // false 
class StringMatcher { 
 constructor(str) { 
 	this.str = str; 
 } 
 [Symbol.match](target) { 
	 return target.includes(this.str); 
 } 
} 
console.log('foobar'.match(new StringMatcher('foo'))); // true 
console.log('barbaz'.match(new StringMatcher('qux'))); // false

在这里插入图片描述

10. Symbol.replace

根据 ECMAScript 规范，这个符号作为一个属性表示“一个正则表达式方法，该方法替换一个字符
串中匹配的子串。由String.prototype.replace()方法使用”。String.prototype.replace()
方法会使用以 Symbol.replace为键的函数来对正则表达式求值。正则表达式的原型上默认有这个函
数的定义，因此所有正则表达式实例默认是这个 String 方法的有效参数：

console.log(RegExp.prototype[Symbol.replace]); 
// ƒ [Symbol.replace]() { [native code] } 
console.log('foobarbaz'.replace(/bar/, 'qux')); 
// 'fooquxbaz'

在这里插入图片描述

给这个方法传入非正则表达式值会导致该值被转换为 RegExp 对象。如果想改变这种行为，让方法
直接使用参数，可以重新定义 Symbol.replace 函数以取代默认对正则表达式求值的行为，从而让
replace()方法使用非正则表达式实例。Symbol.replace函数接收两个参数，即调用replace()方
法的字符串实例和替换字符串。返回的值没有限制：

class FooReplacer { 
 static [Symbol.replace](target, replacement) { 
 	return target.split('foo').join(replacement); 
 } 
} 
console.log('barfoobaz'.replace(FooReplacer, 'qux')); 
// "barquxbaz" 
class StringReplacer { 
 constructor(str) { 
	 this.str = str; 
 } 
 [Symbol.replace](target, replacement) { 
	 return target.split(this.str).join(replacement); 
 } 
} 
console.log('barfoobaz'.replace(new StringReplacer('foo'), 'qux')); 
// "barquxbaz"

在这里插入图片描述

11. Symbol.search

根据 ECMAScript 规范，这个符号作为一个属性表示“一个正则表达式方法，该方法返回字符串中
匹配正则表达式的索引。由 String.prototype.search()方法使用”。String.prototype.search()
方法会使用以 Symbol.search为键的函数来对正则表达式求值。正则表达式的原型上默认有这个函数
的定义，因此所有正则表达式实例默认是这个 String 方法的有效参数：

console.log(RegExp.prototype[Symbol.search]); 
// ƒ [Symbol.search]() { [native code] } 
console.log('foobar'.search(/bar/)); 
// 3

在这里插入图片描述

给这个方法传入非正则表达式值会导致该值被转换为 RegExp 对象。如果想改变这种行为，让方法
直接使用参数，可以重新定义 Symbol.search 函数以取代默认对正则表达式求值的行为，从而让
search()方法使用非正则表达式实例。Symbol.search 函数接收一个参数，就是调用 match()方法
的字符串实例。返回的值没有限制：

class FooSearcher { 
 static [Symbol.search](target) { 
	 return target.indexOf('foo'); 
 } 
}
console.log('foobar'.search(FooSearcher)); // 0 
console.log('barfoo'.search(FooSearcher)); // 3 
console.log('barbaz'.search(FooSearcher)); // -1 
class StringSearcher { 
 constructor(str) { 
 	this.str = str; 
 } 
 [Symbol.search](target) { 
	 return target.indexOf(this.str); 
 } 
} 
console.log('foobar'.search(new StringSearcher('foo'))); // 0 
console.log('barfoo'.search(new StringSearcher('foo'))); // 3 
console.log('barbaz'.search(new StringSearcher('qux'))); // -1

在这里插入图片描述

12. Symbol.species

根据 ECMAScript 规范，这个符号作为一个属性表示“一个函数值，该函数作为创建派生对象的构
造函数”。这个属性在内置类型中最常用，用于对内置类型实例方法的返回值暴露实例化派生对象的方
法。用 Symbol.species 定义静态的获取器（getter）方法，可以覆盖新创建实例的原型定义：

class Bar extends Array {} 
class Baz extends Array { 
 static get [Symbol.species]() { 
	 return Array; 
 } 
} 
let bar = new Bar(); 
console.log(bar instanceof Array); // true 
console.log(bar instanceof Bar); // true 
bar = bar.concat('bar'); 
console.log(bar instanceof Array); // true 
console.log(bar instanceof Bar); // true 
let baz = new Baz(); 
console.log(baz instanceof Array); // true 
console.log(baz instanceof Baz); // true 
baz = baz.concat('baz'); 
console.log(baz instanceof Array); // true 
console.log(baz instanceof Baz); // false

在这里插入图片描述

13. Symbol.split

根据 ECMAScript 规范，这个符号作为一个属性表示“一个正则表达式方法，该方法在匹配正则表
达式的索引位置拆分字符串。由 String.prototype.split()方法使用”。String.prototype.
split()方法会使用以 Symbol.split 为键的函数来对正则表达式求值。正则表达式的原型上默认有
这个函数的定义，因此所有正则表达式实例默认是这个 String 方法的有效参数：

console.log(RegExp.prototype[Symbol.split]); 
// ƒ [Symbol.split]() { [native code] } 
console.log('foobarbaz'.split(/bar/)); 
// ['foo', 'baz']

在这里插入图片描述

给这个方法传入非正则表达式值会导致该值被转换为RegExp对象。如果想改变这种行为，让方法
直接使用参数，可以重新定义 Symbol.split 函数以取代默认对正则表达式求值的行为，从而让 split()
方法使用非正则表达式实例。Symbol.split 函数接收一个参数，就是调用 match()方法的字符串实
例。返回的值没有限制：

class FooSplitter { 
 static [Symbol.split](target) { 
 	return target.split('foo'); 
 } 
} 
console.log('barfoobaz'.split(FooSplitter)); 
// ["bar", "baz"] 
class StringSplitter { 
 constructor(str) { 
	 this.str = str; 
 } 
 [Symbol.split](target) { 
	 return target.split(this.str); 
 } 
} 
console.log('barfoobaz'.split(new StringSplitter('foo'))); 
// ["bar", "baz"]

在这里插入图片描述

14. Symbol.toPrimitive

根据 ECMAScript 规范，这个符号作为一个属性表示“一个方法，该方法将对象转换为相应的原始
值。由 ToPrimitive 抽象操作使用”。**很多内置操作都会尝试强制将对象转换为原始值，包括字符串、
数值和未指定的原始类型。**对于一个自定义对象实例，通过在这个实例的 Symbol.toPrimitive属性
上定义一个函数可以改变默认行为。
根据提供给这个函数的参数（string、number 或 default），可以控制返回的原始值：

class Foo {} 
let foo = new Foo(); 
console.log(3 + foo); // "3[object Object]" 
console.log(3 - foo); // NaN 
console.log(String(foo)); // "[object Object]" 
class Bar { 
 constructor() { 
	 this[Symbol.toPrimitive] = function(hint) { 
	    switch (hint) { 
			 case 'number': 
			 	return 3; 
			 case 'string': 
			 	return 'string bar'; 
			 case 'default': 
			 default: 
				return 'default bar'; 
	   } 
 	} 
  } 
}
let bar = new Bar(); 
console.log(3 + bar); // "3default bar" 
console.log(3 - bar); // 0 
console.log(String(bar)); // "string bar"

在这里插入图片描述

16. Symbol.unscopables

根据 ECMAScript 规范，这个符号作为一个属性表示“一个对象，该对象所有的以及继承的属性，
都会从关联对象的 with 环境绑定中排除”。设置这个符号并让其映射对应属性的键值为true，就可以
阻止该属性出现在 with环境绑定中，如下例所示：

let o = { foo: 'bar' }; 
with (o) { 
 console.log(foo); // bar 
} 
o[Symbol.unscopables] = { 
 foo: true 
}; 
with (o) { 
 console.log(foo); // ReferenceError 
}

在这里插入图片描述

不推荐使用 with，因此也不推荐使用 Symbol.unscopables。

Object 类型

ECMAScript 中的对象其实就是一组数据和功能的集合。对象通过 new 操作符后跟对象类型的名称来创建。开发者可以通过创建 Object 类型的实例来创建自己的对象，然后再给对象添加属性和方法:

let o = new Object();

这个语法类似 Java，但 ECMAScript 只要求在给构造函数提供参数时使用括号。如果没有参数，如

上面的例子所示，那么完全可以省略括号（不推荐）：

let o = new Object; // 合法，但不推荐

Object 的实例本身并不是很有用，但理解与它相关的概念非常重要。类似 Java 中的 java.lang.

Object，ECMAScript 中的 Object 也是派生其他对象的基类。Object 类型的所有属性和方法在派生

的对象上同样存在。

每个 Object 实例都有如下属性和方法。

constructor：用于创建当前对象的函数。在前面的例子中，这个属性的值就是 Object()

函数。

hasOwnProperty(propertyName)：用于判断当前对象实例（不是原型）上是否存在给定的属

性。要检查的属性名必须是字符串（如 o.hasOwnProperty(“name”)）或符号。

 `isPrototypeOf(object)：用于判断当前对象是否为另一个对象的原型。（第 8 章将详细介绍

原型。）

propertyIsEnumerable(propertyName)：用于判断给定的属性是否可以使用（本章稍后讨

论的）for-in 语句枚举。与 hasOwnProperty()一样，属性名必须是字符串。

toLocaleString()：返回对象的字符串表示，该字符串反映对象所在的本地化执行环境。

toString()：返回对象的字符串表示。

valueOf()：返回对象对应的字符串、数值或布尔值表示。通常与 toString()的返回值相同。

因为在 ECMAScript 中 Object 是所有对象的基类，所以任何对象都有这些属性和方法。第 8 章将

介绍对象间的继承机制。

注意 严格来讲，ECMA-262 中对象的行为不一定适合 JavaScript 中的其他对象。比如浏
览器环境中的 BOM 和 DOM 对象，都是由宿主环境定义和提供的宿主对象。而宿主对象
不受 ECMA-262 约束，所以它们可能会也可能不会继承 Object。

结语

学和行本来是有联系着的，学了必须要想，想通了就要行，要在行的当中才能看出自己是否真正学到了手。否则读书虽多，只是成为一座死书库。 ——谢觉哉，
在这里插入图片描述

妙趣前端
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES6新特性-图解
JackieDYH的博客
03-08 309
深入理解ES6新特性之Set结构
道阻且长
04-30 399
深入理解ES6新特性之Set结构
ES 6新特性（07）
5coder的大前端进阶之路-个人博客网站：blog.5coder.cn
11-07 3573
Part1 · JavaScript【深度剖析】 ES 6新特性 查看我整理的ES新特性思维导图，参照思维导图可以宏观角度来学习ES6的新特性。传送门：ES新特性思维导图 文章说明：本专栏内容为本人参加【拉钩大前端高新训练营】的学习笔记以及思考总结，学徒之心，仅为分享。如若有误，请在评论区支出，如果您觉得专栏内容还不错，请点赞、关注、评论。 共同进步！ 上一篇：【ECMAScript模板字符串】、【ES6参数】、【展开数组、对象】、【箭头函数】、【对象】、【代理Proxy】、【class类】、【se
ES6、 ES7、 ES8、 ES9、 ES10 新特性概览
明天也要努力的博客
01-28 1349
ECMA规范最终由 TC39 敲定。TC39由包括浏览器厂商在内的各方组成，他们开会推动JavaScript提案沿着一条严格的发展道路前进。 从提案到入选ECMA规范主要有以下几个阶段：ES6的特性比较多，在 ES5 发布近 6 年（2009-11 至 2015-6）之后才将其标准化， 两个发布版本之间时间跨度很大，所以ES6中的特性比较多。1.1 类（class） 对熟悉 Java，object-c，c# 等纯面向对象语言的开发者来说，都会对class有一种特殊的情怀。 ES6 引入了class（类），让
谈谈ES6新增了哪些特性
祎祎的博客
11-10 7299
一、什么是ES6？ ES全称为ECMAScript，它是由国际标准化组织ECMA（全称：European Computer Manufacturers Association）欧洲计算机制造商协会制定的一项脚本语言的标准化规范。JavaScript就实现了这套标准。ES6中的6代表的是版本，从2015年6月份发布的版本及其后续版本统称为ES6，从2015年开始，每年的6月份都会发布新版本。目前各大浏览器产商也都已经支持ES6。 二、 ES6的新特性有哪些？ 1.新增了块级作用域（let，const） 2.提
ES6+的新特性
m0_51636525的博客
06-07 635
ES6中对对象字面量进行了增强，主要包括下面几部分：属性的简写：Property Shorthand在对象里面赋值，或者在函数返回对象的时候，经常会有a: a的代码出现，可以简写。 方法的简写：Method Shorthand一种语法糖写法，更简洁。running是简写之前的，playing是简写之后的。 这种写法不同于箭头函数，箭头函数是没有this的，而这种函数的简写是有this的。计算属性名：Computed Property Names可以将key的值作为属性名 2.解构Destruct
ES6新特性之Symbol类型用法分析
12-11
本文实例讲述了ES6新特性之Symbol类型用法。分享给大家供大家参考，具体如下： Symbol类型 1. 为了避免属性名的冲突，ES6新增了Symbol类型。Symbol可以产生一个独一无二的值。 let s1 = Symbol('a'); let s2 = ...
Javascript ES6中数据类型Symbol的使用详解
11-29
它是JavaScript语言的第七种数据类型，前6种分别是：Undefined、Null、Boolean、String、Number、Object。 语法 Symbol([description]) Parameters description : 可选的字符串。可用于调试但不访问符号本身的符号的...
ES6中Symbol类型用法实例详解
11-26
本文实例讲述了ES6中的Symbol类型。分享给大家供大家参考，具体如下： Symbol是在ES6中新加入的类型。 正如我们所知，JavaScript中有以下几种类型： Undefined ,Null ,Boolean ,Number ,String, Object。 但是上述...
js 数据类型判断的方法
01-18
一般用于判断基本数据类型，用于判断引用数据类型和null时会发生意外的错误 typeof 1 // number typeof '1' // string typeof true // boolean typeof Symbol('1') // symbol typeof undefined // undefined typeof...
JS数据类型判断的几种常用方法
11-19
JavaScript 中常见数据类型有Number、String、Boolean、Object、Array、Json、Function、Date、RegExp、Error、undefined、Null等十几种。ES6还有新增的数据类型有Symbol、Set、Map等。在实际应用中，我们经常需要...
【JavaScript】数据类型—Object、Symbol类型
南栀的博客
09-11 333
Object Symbol
JS 语言基础笔记——第三篇（Symbol类型、Object类型）
weixin_50936255的博客
05-27 288
这里写目录标题前言一、Symbol类型二、Object类型每个 Object 实例都有如下属性和方法 前言 本篇笔记 JS 语言基础 第三篇。 主要内容有： ES6 新增简单数据类型 Symbol； 复杂数据类型 Object。 一、Symbol类型 二、Object类型 对象其实就是一组数据或功能的集合。对象通过 new 操作符后跟对象类型的名称来创建。 let obj = new Object(); let obg1 = new Object; // 合法，但不推荐 ECMAScript中的
ES6-Symbol 笔记 | Symbol 值作为对象的属性名 | Object.getOwnPropertySymbols()
dxy1128的博客
11-04 837
Symbol 数据类型是ES6新出的一种数据类型，这种数据类型的特点就是没有重复的数据，可以作为Object 的 key（属性值）。 本篇博客为博主本人整理的Symbol数据类型的笔记，参考文档为《阮一峰的ECMAScript 6 入门》。
Symbol的简单学习
cjx1259972299的博客
12-04 561
ES6 引入了一种新的原始数据类型 Symbol，表示独一无二的值。
关于阅读 ES6- Symbol 整理的问题
千里之行，始于足下！
05-03 594
1、ES6为什么引入 Symbol ？ 答：ES5中的对象的属性名是字符串，属性名不能重复，否则会覆盖。 当你使用别人定义的对象，并想往里面添加新的方法， 如果方法名和对象中的属性名进行重复，就会造成覆盖的后果， 因此Symbol就是为了解决这个问题而产生的。 let obj = { [Symbol(‘a’)]: 111, [Symbol(‘a’)]: 222, } 2、Symbol类型 答：Symbol值通过Symbol()函数进行生成，可作为对象的属性名。 Symbol类型的属性名是独一无二的，不
ES6新增数据类型（Symbol）
qq_46366496的博客
09-01 779
ES6新增数据类型（Symbol） 基本(原始)类型和引用类型介绍 在了解Symbol之前，我们需要了解下JS的数据类型，在JS中数据类型分为两类：基本(原始)类型和引用类型。 基本(原始)类型：数值型（Number)，字符类型（String），布尔值型（Boolean），null 和 underfined 引用类型：对象（Object） 那es6新增的Symbol是什么类型呢？ 这里Symbol也是基本类型； 概述 ES6 引入了一种新的原始数据类型 Symbol ，表示独一无二的值，最大的用法是用来
cuda学习
weixin_45806592的博客
09-11 623
什么是cuda cuda是带有并行内核的串行代码，全部由c/c++编写，串行代码在host端串行执行，并行内核代码在device短的多线程中执行。 cuda是用于在英伟达gpu上编程的编译器和工具 支持gpu的异构计算 cuda API扩展了c/c++编程语言 快速SIMD并行性 从硬件上提供了高级别的抽象 cuda编程流程 从host端将数据拷贝到device端 呼叫gpu告诉gpu启动 在gpu上运行计算 将计算完后的device上的数据拷贝到host端 kernel是CUDA中一个重要的概念
TradingView---JS Api
热门推荐
程序员的诗意人生---Jesse
04-28 1万+
这是啥? 一套JS方法（特定的公共接口）。我该怎么使用它? 您应该创建一个JS对象，它将以某种方式接收数据，并响应Charting Library请求。数据缓存（历史和股票信息）在图表库中实现。当你创建一个实现描述接口的对象时，只需通过datafeed 参数将其传递给图表库Widget的构造函数。Methods1.     onReady2.     searchSymbolsByName3.  ...
Symbol数据类型怎么判断？
最新发布
09-09
Symbol数据类型可以通过以下方法进行判断： 1. 使用typeof操作符判断变量的类型，如果变量的类型为"symbol"，则表示它是一个Symbol类型的值。 2. 使用Object.prototype.toString.call()方法判断变量的类型，如果返回结果为"[object Symbol]"，则表示它是一个Symbol类型的值。 3. 利用Symbol的静态属性Symbol.hasInstance，通过instanceof运算符判断变量是否是Symbol的实例，如果返回结果为true，则表示它是一个Symbol类型的值。 4. 使用Symbol.for()全局方法创建的Symbol值可以通过Symbol.keyFor()方法判断是否存在于全局注册表中，如果返回结果为undefined，则表示它是一个独立的Symbol值，否则表示它是一个已注册的Symbol值。 综上所述，可以使用typeof、Object.prototype.toString.call()、instanceof和Symbol.keyFor()方法来判断Symbol数据类型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值