Cette question est assez intéressante. Je ne l'ai jamais remarqué. Après avoir parcouru les informations, j'ai découvert que beaucoup de choses se sont produites par hasard, et puis ce problème est apparu. Pour être précis, c'était un 浏览器的默认行为和JavaScript的隐式类型变换problème.

Allons-y étape par étape, tout d’abord, quelle est la différence entre var和let ?

var声明的变量会被提升至当前函数作用域顶端，如果是在全局那么这个变量将会成为window的一个属性。
而对于let声明的变量，它会将变量提升至当前块级作用域，并且如果是在全局，当前变量也不会成为window.

Donc, dans l'ensemble, quelque chose comme ceci se produit :

var test1 = 'test1';
let test2 = 'test2';

console.log(window.test1);    // test1
console.log(window.test2);    // undefined

Alors, name为名的变量和别的变量有什么区别？
上面我们知道了，var name = 'test1';实际上可以等同于window.name = 'test1'，很容易就能想到，name est-il un mot réservé fixe ?

En regardant les spécifications, c’est vrai. Quelques interfaces de
window.name属性表示的是当前窗口上下文的名称。下面是window :

[ReplaceableNamedProperties] 
interface Window {
  // the current browsing context
  readonly attribute WindowProxy window;
  readonly attribute WindowProxy self;
  readonly attribute Document document;
           attribute DOMString name;
  //..
}

L'attribut name dans la dernière ligne ici n'a pas le préfixe readonly, indiquant qu'il est lisible et inscriptible, et son type de données est DOMString. name属性在这里的最后一行，没有readonly的前缀，说明它是可读可写的，它的数据类型则是DOMString。
DOMString是指UTF-16的字符串，在JavaScript中它会直接映射到StringDOMString fait référence à une chaîne UTF-16, qui est directement mappée à String en JavaScript.

Alors quand on donne window.name赋值的时候，这个值会被强制转换为String.

Nous pouvons essayer :

var name = { a:1, b:2 };
console.log(window.name);    // [object Object]

var name = [0, 1, 2, 3];
console.log(window.name);    // 0,1,2,3

Vous pourrez probablement le deviner en arrivant ici, var name = Symbol('test');的错误，应该是Symbol变量在做类型转换的时候出了问题。而实际报的错误也证实了我们的猜测：TypeError: Cannot convert a Symbol value to a string.

Cependant, cela ne semble pas correct. SymbolLes variables peuvent être converties en chaînes, par exemple :

let test = Symbol('test');

console.log(test.toString());    // Symbol(test)
console.log(String(test));       // Symbol(test)

Eh bien, c'est un cliché. La conversion de type implicite et la conversion explicite de JavaScript sont différentes pour certaines variables. Malheureusement, c'est le cas ici Symbol.

Symbol被隐式的转换时，它会首先调用其内部的ToPrimitive接口，拿到其原始值，然后在其中再调用ToString函数转换为字符串。注意，这里的这个ToString函数是其内部的抽象方法，和暴露在外的Symbol.prototype.toString()Lorsqu'il est implicitement converti, il appellera d'abord son interface interne ToPrimitive pour obtenir sa valeur d'origine, puis appellera la fonction ToString pour la convertir en chaîne. Notez que la fonction ToString est ici sa méthode abstraite interne et n'est pas la même chose que le Symbol.prototype.toString() exposé.

Pour la variable Symbol变量而言，当其调用ToString, une erreur sera signalée lors de l'appel de ToString. Je n'entrerai pas dans plus de détails. Si vous êtes intéressé, vous pouvez lire la spécification par vous-même : ToString (argument).

Je viens de l'essayer sur console, c'est effectivement un BUG très étonnant, ​​mais vous le ferez

var name = Symbol("test"); 
//改成
let name = Symbol("test"); //试试。。

Ensuite, j'ai été surpris de constater que le BUG avait de nouveau disparu. . Je suppose que cela a quelque chose à voir avec la façon dont le navigateur analyse la syntaxe, mais je ne comprends pas ces choses.

name est un attribut unique de window Si vous essayez de modifier la variable, vous n'obtiendrez pas d'erreur. . .

name est un attribut unique de window. Toute valeur attribuée à la variable name dans l'environnement global sera automatiquement convertie en chaîne. Cependant, le type Symbol ne peut pas être directement converti en chaîne, donc une erreur est signalée.

Vous pouvez

var name = 1;
console.log(name);

Vous le saurez.