ES6—Symbol

作者：米书林
参考文章：《菜鸟教程》、《 ECMAScript 6 入门》（阮一峰）

概述

1.ES5除类数组对象（类数组对象名可以为数字，对象必须有length属性，可以用数组下标的方式访问对象属性，但不能通过点的方式访问）外，对象属性名都是字符串，这容易造成属性名的冲突。而且JavaScript是弱类型语言，属性名冲突不会报错，处于代码执行顺序后面的属性值会覆盖前面的属性值（属性值容易被篡改），这样对象的属性就不能保证是我们想要的；
2.ES6引入了Symbol数据类型很好的解决了对象属性名冲突的问题。
3.Symbol表示独一无二的值，它是原始数据类型，不能用New
4.ES6之后JavaScript就有了7种数据类型，分别是：Number(数字)、String(字符型)、Boolean(布尔值)、null、undefined、Object(对象)、Symbol(独一无二的值)

基本用法

Symbol 函数栈不能用 new 命令，因为 Symbol 是原始数据类型，不是对象。可以接受一个字符串作为参数，为新创建的 Symbol 提供描述，用来显示在控制台或者作为字符串的时候使用，便于区分。

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

特点

1.Symbol 函数栈不能用 new 命令，因为 Symbol 是原始数据类型，不是对象；
2.Symbol 表示独一无二的值，因此带有相同参数的两个Symbol 值也不相等；

// 没有参数的情况
let name1 = Symbol();
let name2 = Symbol();

name1 === name2  // false
name1 === name2 // false

// 有参数的情况
let name1 = Symbol('foo');
let name2 = Symbol('foo');

name1 === name2  // false
name1 === name2 // false

3.Symbol 不能进行隐式类型转换

let name = Symbol('foo');
console.log("你好，"+ name);
// 浏览器报错
// Uncaught TypeError: Cannot convert a Symbol value to a string

console.log(`你好,${ name}`);
// 浏览器报错
// Uncaught TypeError: Cannot convert a Symbol value to a string

console.log(name +1;)
// 浏览器报错
// Uncaught TypeError: Cannot convert a Symbol value to a number

4.Symbol 值可以显式转为字符串

let name = Symbol('foo');
console.log(String(name));  // "Symbol(foo)"
console.log(name.toString()); // "Symbol(foo)"

5.Symbol 值不能转化为数字

let name = Symbol('foo');
console.log(Number(name));  
// Uncaught TypeError: Cannot convert a Symbol value to a number

6.Symbol 值可以转换为布尔值

let name = Symbol('foo');
Boolean(name ) // true
!name // false

6.Symbol 变量不能作为webStorage的键使用

let ss = Symbol();
localStorage.setItem(ss,"哈哈哈");
// 浏览器报错：Uncaught TypeError: Cannot convert a Symbol value to a string

Symbol应用场景

1.作为对象属性名

1.1 Symbol作为对象属性名要点

1.不能用.运算符，要用方括号，原因：
-ES5中对象.运算符获取的属性名是字符串，.运算符会将属性名识别为字符串，新建一个属性名给对象，无法和Symbol属性区别
-中括号中带双引号的属性名表示字符串属性，不带双引号的属性名表示Symbol属性，以此区别二者

let sy = Symbol();
 
// 写法1
let syObject = {};
syObject[sy] = "symbol";
console.log(syObject);    // {Symbol(): "symbol"}
 
// 写法2
let syObject = {
  [sy]: "symbol"
};
console.log(syObject);    // {Symbol(): "symbol"}
 
// 写法3
let syObject = {};
Object.defineProperty(syObject, sy, {value: "symbol"});
console.log(syObject);   // {Symbol(): "symbol"}

// 不能用点
syObject[sy];  // "symbol"
syObject.sy;   // undefined 
// syObject.sy ==> syObject["sy"]

2.Symbol 值作为属性名时，该属性是公有属性不是私有属性，可以在类的外部访问。但是不会出现在 for...in 、 for...of 的循环中，也不会被 Object.keys() 、 Object.getOwnPropertyNames() 返回。如果要读取到一个对象的 Symbol 属性，可以通过Object.getOwnPropertySymbols() 和 Reflect.ownKeys() 取到。

let sy = Symbol();
let syObject = {};
syObject[sy] = "symbol";
console.log(syObject);
// {Symbol(): "symbol"}
 
for (let i in syObject) {
  console.log(i);
}    // 无输出
 
Object.keys(syObject);                     // []
Object.getOwnPropertyNames(syObject)  // []
Object.getOwnPropertySymbols(syObject);    // [Symbol()]
Reflect.ownKeys(syObject);                 // [Symbol()]

2.定义常量

用const定义的常量不能保证常量值是独一无二的，这在一些判断语句中会出现问题，例如

const COLOR_RED = "red";
const COLOR_YELLOW = "yellow";
const COLOR_BLUE = "blue";
const MY_BLUE = "blue";
 
function ColorException(message) {
   this.message = message;
   this.name = "ColorException";
}
 
function getConstantName(color) {
    switch (color) {
        case COLOR_RED :
            console.log(1);
            return "COLOR_RED";
        case COLOR_YELLOW :
            console.log(2);
            return "COLOR_YELLOW ";
        case COLOR_BLUE:
            console.log(3);
            return "COLOR_BLUE";
        case MY_BLUE:
            console.log(4);
            return "MY_BLUE";         
        default:
            console.log(5);  
            throw new ColorException("Can't find this color");
    }
}
 
try {
   
   var color = MY_BLUE;
   var color1 = COLOR_BLUE; 
   var colorName = getConstantName(color);
   var colorName1 = getConstantName(color1);
} catch (e) {
   var colorName = "unknown";
   console.log(e.message, e.name); // 传递异常对象到错误处理
}

上面代码，常量MY_BLUE和常量COLOR_BLUE都匹配到第一个被执行常量值为blue的常量，控制台打印两次3。
程序使用 Symbol 定义常量，这样就可以保证这一组常量的值都不相等

const COLOR_RED = Symbol("red");
const COLOR_YELLOW = Symbol("yellow");
const COLOR_BLUE = Symbol("blue");
const MY_BLUE = Symbol("blue");
 
function ColorException(message) {
   this.message = message;
   this.name = "ColorException";
}
 
function getConstantName(color) {
    switch (color) {
        case COLOR_RED :
            console.log(1);
            return "COLOR_RED";
        case COLOR_YELLOW :
            console.log(2);
            return "COLOR_YELLOW ";
        case COLOR_BLUE:
            console.log(3);
            return "COLOR_BLUE";
        case MY_BLUE:
            console.log(4);
            return "MY_BLUE";         
        default:
            console.log(5);  
            throw new ColorException("Can't find this color");
    }
}
 
try {
   var color = MY_BLUE; // blue 这样就能匹配到MY_BLUE
   var color1 = COLOR_BLUE; // 这样能匹配到COLOR_BLUE
   var colorName = getConstantName(color);
   var colorName1 = getConstantName(color1);
} catch (e) {
   var colorName = "unknown";
   console.log(e.message, e.name); // 传递异常对象到错误处理
}

上面代码控制台先后打印了4和3，说明我们的判断语句匹配的结果是正确的。

Symbol的方法

1.Symbol.for()

作用：用于将描述相同的Symbol变量指向同一个Symbol值；

let a1 = Symbol.for('a');
let a2 = Symbol.for('a');
a1 === a2  // true
typeof a1  // "symbol"
typeof a2  // "symbol"

let a3= Symbol("a");
a1 === a3      // false

Symbol()和Symbol.for()的相同点：
    1.它们定义的值类型都为"symbol"；
Symbol()和Symbol.for()的不同点：
    1.Symbol()定义的值每次都是新建，即使描述相同值也不相等；
    2.Symbol.for()定义的值会先检查给定的描述是否已经存在，如果不存在才会新建一个值，并把这个值登记在全局环境中供搜索，Symbol.for()定义相同描述的值时会被搜索到，描述相同则他们就是同一个值。

2.Symbol.keyFor()

作用：用来检测该字符串参数作为名称的 Symbol 值是否已被登记，返回一个已登记的 Symbol 类型值的 key

let a1 = Symbol.for("a");
Symbol.keyFor(a1);    // "a"

let a2 = Symbol("a");
Symbol.keyFor(a2);    // undefined

上述代码中a1已经用Symbol.for()登记过，因此返回的key为"a"，而a2没有被登记，因此返回undefined

Symbol的属性

1.Symbol.prototype.description

description用于返回Symbol数据的描述

// Symbol()定义的数据
let a = Symbol("acc");
a.description  // "acc"
Symbol.keyFor(a);  // undefined

// Symbol.for()定义的数据
let a1 = Symbol.for("acc");
a1.description  // "acc"
Symbol.keyFor(a1);  // undefined

// 未指定描述的数据
let a2 = Symbol();
a2.description  // undefined

description属性和Symbol.keyFor()方法的区别是：
description能返回所有Symbol类型数据的描述，而Symbol.keyFor()只能返回Symbol.for()在全局注册过的描述