ES6学习笔记--Symbol

创建符号值

Symbol没有字面量形式,这在JS的基本类型中是独一无二的.可以用全局函数来创建符号值

let firstName=Symbol();
let person={};
person[firstName]='Polo';
console.log(person[firstName]); // 'Polo'

//es6扩展了typeof运算符,可以识别symbol基本类型
console.log(typeof firstName); // 'symbol;

符号值是基本类型,因此调用new Symbol()会抛出错误

共享符号值

使用Symbol.for方法,创建共享符号值,该方法仅接受当字符串类型的参数,作为目标符号值得标识符,同时此参数也会成为该符号的描述信息

let uid=Symbol.for('uid');
let obj={};
obj[uid]=12334;
console.log(obj[uid]); // 12334
console.log(uid);      // symbol(uid)

Symbol.for() 方法首先会搜索全局符号注册表，看是否存在一个键值为 "uid" 的符号值。若是，该方法会返回这个已存在的符号值；否则，会创建一个新的符号值，并使用该键值将其记录到全局符号注册表中，然后返回这个新的符号值。这就意味着此后使用同一个键值去调用 Symbol.for() 方法都将会返回同一个符号值，就像下面这个例子：

let uid=Symbol.for('uid');
let obj={};
obj[uid]=12334;
let uid2=Symbol.for('uid');
console.log(uid===uid2);    //true
console.log(obj[uid2]);     //12334
console.log(uid2);          //symbol(uid)

Symbol.keyFor方法,在全局符号注册表中根据符号值检索出对应的键值

let uid = Symbol.for("uid");
console.log(Symbol.keyFor(uid));    // "uid"

检索符号属性

Object.keys()返回对象所有可枚举属性名称

Object.getOwnPropertyNames() 返回所有属性名称而无视其是否可枚举

然而以上两个方法都不能返回符号类型的属性,

ES6中新增Object.getOwnPropertySymbols(),返回符号类型的属性

ES6知名符号

ES6 定义了“知名符号”来代表 JS 中一些公共行为，而这些行为此前被认为只能是内部操作。每一个知名符号都对应全局 Symbol 对象的一个属性

这些知名符号是：

• Symbol.hasInstance ：供 instanceof 运算符使用的一个方法，用于判断对象继承关系。
• Symbol.isConcatSpreadable ：一个布尔类型值，在集合对象作为参数传递给
• Array.prototype.concat() 方法时，指示是否要将该集合的元素扁平化。
• Symbol.iterator ：返回迭代器（参阅第七章）的一个方法。
• Symbol.match ：供 String.prototype.match() 函数使用的一个方法，用于比较字符串。
• Symbol.replace ：供 String.prototype.replace() 函数使用的一个方法，用于替换子字符串。
• Symbol.search ：供 String.prototype.search() 函数使用的一个方法，用于定位子字符串。
• Symbol.species ：用于产生派生对象（参阅第八章）的构造器。
• Symbol.split ：供 String.prototype.split() 函数使用的一个方法，用于分割字符串。
• Symbol.toPrimitive ：返回对象所对应的基本类型值的一个方法。
• Symbol.toStringTag ：供 String.prototype.toString() 函数使用的一个方法，用于创建对象的描述信息。
• Symbol.unscopables ：一个对象，该对象的属性指示了哪些属性名不允许被包含在 with 语句中。

Symbol.hasInstance

用于判断指定对象是否为本函数的一个实例。这个方法定义在 Function.prototype 上，因此所有函数都继承了面对 instanceof 运算符时的默认行为。 Symbol.hasInstance 属性自身是不可写入、不可配置、不可枚举的，从而保证它不会被错误地重写。

obj instanceof Array;
//等价于
Array[Symbol.hasInstance](obj);

ES6 从本质上将 instanceof 运算符重定义为上述方法调用的简写语法.

例如，假设你想定义一个函数，使得任意对象都不会被判断为该函数的一个实例，你可以采用硬编码的方式让该函数的 Symbol.hasInstance 方法始终返回 false

function MyObj(){
}
Object.defineProperty(MyObj,Symbol.hasInstance,{
    value:function(v){
        return false;
    }
});
let obj=new MyObj();
console.log(obj instanceof MyObj);  // false

Symbol.isConcatSpreadable

该属性是一个布尔类型的属性，它表示目标对象拥有长度属性与数值类型的键、并且数值类型键所对应的属性值在参与 concat() 调用时需要被分离为个体。它只出现在特定类型的对象上，用来标示该对象在作为 concat() 参数时应如何工作，从而有效改变该对象的默认行为。

let collection = {
    0: "Hello",
    1: "world",
    length: 2,
    [Symbol.isConcatSpreadable]: true
};

let messages = [ "Hi" ].concat(collection);

console.log(messages.length);    // 3
console.log(messages);           // ["hi","Hello","world"]

Symbol.toPrimitive

该属性规定了在对象被转换为基本类型值的时候会发生什么。

当需要转换时， Symbol.toPrimitive 会被调用，并按照规范传入一个提示性的字符串参数。该参数有 3 种可能：

• 当参数值为 "number" 的时候， Symbol.toPrimitive 应当返回一个数值；
• 当参数值为 "string" 的时候，应当返回一个字符串；
• 而当参数为 "default" 的时候，对返回值类型没有特别要求。

function Temperature(degrees) {
    this.degrees = degrees;
}

Temperature.prototype[Symbol.toPrimitive] = function(hint) {

    switch (hint) {
        case "string":
            return this.degrees + "\u00b0"; // 温度符号

        case "number":
            return this.degrees;

        case "default":
            return this.degrees + " degrees";
    }
};

let freezing = new Temperature(32);

console.log(freezing + "!");            // "32 degrees!"
console.log(freezing / 2);              // 16
console.log(String(freezing));          // "32°"

Symbol.toStringTag

该属性定义了Object.prototype.toString.call()被调用时应该返回什么值,同样可以在自定义对象上定该属性值.

function Person(name) {
    this.name = name;
}

Person.prototype[Symbol.toStringTag] = "Person";

let me = new Person("Nicholas");

console.log(me.toString());                         // "[object Person]"
console.log(Object.prototype.toString.call(me));    // "[object Person]"