将Symbols引入ES6的动机是什么?

在Javascript中引入符号的最初动机是启用私人属性。

不幸的是，他们最终被严重降级。它们不再是私有的，因为你可以通过反射找到它们，例如，使用Object.getOwnPropertySymbols或代理。

它们现在被称为独特的符号，它们的唯一用途是避免属性之间的名称冲突。例如，ECMAScript本身现在可以通过某些方法引入扩展钩子，您可以将这些方法放在对象上(例如，定义它们的迭代协议)，而不会冒它们与用户名冲突的风险。

这种强烈的动机是否足以为语言添加符号还有待商榷。

符号不能保证真正的隐私，但可以用来区分对象的公共属性和内部属性。让我们举一个例子，在这个例子中，我们可以使用Symbol来拥有私有属性。

让我们举一个对象的属性不是私有的例子。

var Pet = (function() {
function Pet(type) {
this.type = type;
}
Pet.prototype.getType = function() {
return this.type;
}
return Pet;
}());


var a = new Pet('dog');
console.log(a.getType());//Output: dog
a.type = null;
//Modified outside
console.log(a.getType());//Output: null

上面，Pet类属性type不是私有的。为了使它私有，我们必须创建一个闭包。下面的例子说明了如何使用闭包将type设为私有。

var Pet = (function() {
function Pet(type) {
this.getType = function(){
return type;
};
}
return Pet;
}());


var b = new Pet('dog');
console.log(b.getType());//dog
b.type = null;
//Stays private
console.log(b.getType());//dog

上述方法的缺点:我们为每个创建的Pet实例引入了一个额外的闭包，这可能会损害性能。

现在我们引入Symbol。这可以帮助我们在不使用额外不必要的闭包的情况下使属性为私有。代码示例如下:

var Pet = (function() {
var typeSymbol = Symbol('type');
function Pet(type) {
this[typeSymbol] = type;
}
Pet.prototype.getType = function(){
return this[typeSymbol];
}
return Pet;
}());


var a = new Pet('dog');
console.log(a.getType());//Output: dog
a.type = null;
//Stays private
console.log(a.getType());//Output: dog

以下是我的看法。通过防止对象的键/属性通过一些流行的方法(如object .keys()和JSON.stringify())暴露，符号提供了“额外的隐私级别”。

var age = Symbol();  // declared in another module perhaps?
class Person {
constructor(n,a){
this.name = n;
this[age] = a;
}
introduce(){
console.log(`My name is ${this.name}. I am ${this[age]-10}.`);
}
}
var j = new Person('Jane',45);
j.introduce();  // My name is Jane. I am 35.
console.log(JSON.stringify(j)); // {"name":"Jane"}
console.log(Object.keys(j)); // ["name"]
console.log(j[age]); // 45   (well…only if you know the age in the first place…)

尽管给定了对象本身，这些属性仍然可以通过反射、代理、object . getownpropertysymbols()等来公开，但是没有通过一些直接方法来访问它们的自然方法，从OOP的角度来看，这些方法有时已经足够了。

符号是一种新的特殊类型的对象，可以用作对象中的唯一属性名。使用符号而不是字符串允许不同的模块创建互不冲突的属性。符号也可以有效地设置为私有，这样它们的属性就不能被尚未直接访问符号的任何人访问。

符号是一个新的原始的，就像数字、字符串和布尔原语一样。与其他原语不同，符号没有文字语法(例如，string有'') -创建它们的唯一方法是使用Symbol构造函数，方法如下:

let symbol = Symbol();

实际上，符号只是将属性附加到对象上的一种略有不同的方式——你可以轻松地将众所周知的符号作为标准方法提供，就像Object.prototype.hasOwnProperty一样，它出现在从Object继承的所有东西中。

下面是Symbol原语类型的一些好处。

符号具有内建的可调试性

符号可以给出一个描述，这实际上只是用于调试，以便在将它们记录到控制台时更容易一些。

符号可以用作对象键

这就是符号真正有趣的地方。它们与物体紧密地交织在一起。符号可以被分配为对象的键，这意味着您可以为一个对象分配无限数量的唯一符号，并保证这些符号永远不会与字符串键或其他唯一符号冲突。

符号可以用作唯一值

让我们假设您有一个日志库，其中包括多个日志级别，如logger.levels.DEBUG、logger.levels.INFO、logger.levels.WARN等。在ES5代码中，你可以创建这些字符串(logger.levels.DEBUG === 'debug')或数字(logger.levels.DEBUG === 10)。这两种方法都不理想，因为这些值不是唯一的值，但符号是唯一的值!因此logger.levels简单地变成:

log.levels = {
DEBUG: Symbol('debug'),
INFO: Symbol('info'),
WARN: Symbol('warn'),
};
log(log.levels.DEBUG, 'debug message');
log(log.levels.INFO, 'info message');

阅读更多在这个伟大的文章。

这篇文章是关于Symbol()，提供了实际的例子，我可以找到/制作和事实&我能找到的定义。

TLDR;

Symbol()是数据类型，随着ECMAScript 6 (ES6)的发布而引入。

关于这个符号有两个奇怪的事实。

• 第一个数据类型，也是JavaScript中唯一没有文字的数据类型

• 任何变量，用Symbol()定义，得到唯一的内容，但它不是真正的私人。

• 任何数据都有它的自己的符号，对于相同的数据，符号将是相同的。更多信息在下面的段落，否则它不是一个TLRD;：）

如何初始化符号?

1. 获取具有可调试值的唯一标识符

你可以这样做:

var mySymbol1 = Symbol();

或者这样:

var mySymbol2 = Symbol("some text here");

"some text here"字符串不能从符号中提取，它只是用于调试目的的描述。它不会改变符号的行为。虽然，你可以console.log它(这是公平的，因为该值是用于调试的，这样就不会将该日志与其他日志条目混淆):

console.log(mySymbol2);
// Symbol(some text here)

2. 为某些字符串数据获取一个符号

在这种情况下，符号的值是实际上，这样两个符号可能是非唯一的。

var a1 = Symbol.for("test");
var a2 = Symbol.for("test");
console.log(a1 == a2); //true!

让我们称这些符号为“第二类”。符号。它们与“第一种”并不相交。符号(即用Symbol(data)定义的那些)。

接下来的两段只涉及第一种符号。

使用Symbol而不是旧的数据类型有什么好处?

让我们首先考虑一个对象，一个标准数据类型。我们可以在那里定义一些键值对，并通过指定键来访问这些值。

var persons = {"peter":"pan","jon":"doe"};
console.log(persons.peter);
// pan

如果有两个叫彼得的人呢?

这样做:

var persons = {"peter":"first", "peter":"pan"};

没有什么意义。

所以，这似乎是两个完全不同的人有相同的名字的问题。然后让我们引用出新的Symbol()。这就像现实生活中的一个人——任何人都是独特的，但他们的名字可以是相等的。让我们来定义两个“人”。

 var a = Symbol("peter");
var b = Symbol("peter");

现在我们有了两个名字相同的人。我们的人真的不同吗?他们是;你可以检查这个:

 console.log(a == b);
// false

我们如何从中受益?

我们可以在你的对象中为不同的人做两个条目，它们无论如何都不会被弄错。

 var firstPerson = Symbol("peter");
var secondPerson = Symbol("peter");
var persons = {[firstPerson]:"first", [secondPerson]:"pan"};

< p > 注意:
不过，值得注意的是，使用JSON.stringify对对象进行字符串化将删除所有以Symbol作为键初始化的对。
执行Object.keys也不会返回这样的Symbol()->value对

使用这种初始化，绝对不可能将条目误认为第一人称和第二人称。为它们调用console.log将正确地输出它们的第二个名称。

 console.log(persons[a]);
// first
console.log(persons[b]);
// pan

在对象中使用时，与定义不可枚举属性相比有何不同?

事实上，已经存在一种方法来定义一个属性，以隐藏Object.keys和枚举。下面就是:

var anObject = {};
var fruit = "apple";


Object.defineProperty( anObject, fruit, {
enumerable: false,
value: "green"
});

Symbol()带来了什么不同?不同之处在于，你仍然可以用通常的方式获得由Object.defineProperty定义的属性:

console.log(anObject[fruit]); //green
console.log(anObject["apple"]); //green
console.log(anObject.apple); //green

如果如前一段所述使用Symbol定义:

fruit = Symbol("apple");

只有知道它的变量，你才有能力接收它的值。

console.log(anObject[fruit]); //green
console.log(anObject["apple"]); //undefined
console.log(anObject.apple); //undefined

此外，在"apple"键下定义另一个属性将使对象丢弃旧的属性(如果硬编码，则可能抛出错误)。所以，再也没有苹果了!真遗憾。参考上一段，符号是唯一的，将键定义为Symbol()将使其唯一。

类型转换和检查

• 与其他数据类型不同，Symbol()不可能转换为任何其他数据类型。

• 有可能“使”;通过调用Symbol(data)来创建基于基元数据类型的符号。

• 在检查类型方面，没有任何变化。

   function isSymbol ( variable ) {
  return typeof someSymbol === "symbol";
  }
  
  
  var a_Symbol = Symbol("hey!");
  var totally_Not_A_Symbol = "hey";
  
  
  console.log(isSymbol(a_Symbol)); //true
  console.log(isSymbol(totally_Not_A_Symbol)); //false
  

JS符号是一种新的原始数据类型。它们是作为唯一id的令牌。可以使用Symbol构造函数创建符号。以MDN上的这个片段为例:

// The symbol constructor takes one optional argument,
// the descriptions which is used for debugging only.
// Here are two symbols with the same description
let Sym1 = Symbol("Sym");
let Sym2 = Symbol("Sym");
  

console.log(Sym1 == Sym2); // returns "false"
// Symbols are guaranteed to be unique.
// Even if we create many symbols with the same description,
// they are different values.

使用符号作为唯一的对象属性键通常很方便，例如:

let obj = {};
let prop = Symbol();


obj[prop] = 123;  // the symbol prop is assigned 123
obj.prop  = 456;  // the string prop is assigned 456


console.log(obj.prop, obj[prop]); // logs 456, 123

符号有两个主要的用例:

1. "隐藏"对象属性。如果要将属性添加到“属于”另一个脚本或库的对象中，可以创建一个属性 符号，并将其用作属性键。符号属性则不然 出现在for..in中，所以它不会被意外地一起处理 与其他属性。它也不会被直接访问，因为 另一个脚本没有我们的符号。所以性质是

   所以我们可以“秘密地”将一些东西隐藏到我们需要的对象中，但是 其他人不应该看到，使用符号属性。

JavaScript使用的许多系统符号都可以通过Symbol.*访问。我们可以用它们来改变一些内置的 行为。例如，...... Symbol.iterator用于可迭代对象，Symbol.toPrimitive用于设置

Source .