Cette disharmonieeval()解析'{}'道理一样，js解析代码会优先把{看成和function{}的大括号一样，会分开解析先解析{（开始），在解析}（结束）。这样的话当然会报错了。
而eval()解析'{}'时是怎么办的，加个括号'({})';这样就会把{} est analysée dans son ensemble, puis elle devient un objet.
Quant à "Pourquoi les chaînes peuvent appeler des méthodes directement, mais pas les types numériques et booléens"
Les types booléens le peuvent,
Quant aux nombres, les méthodes ne peuvent pas être appelées directement, c'est aussi la raison de l'analyse js, comme

8.toString()//报错
(8).toString()// 正确
8.0.toString()// 正确

Alors pourquoi, parce qu'il n'y a pas de vrais entiers dans js, et que les entiers sont tous représentés par des nombres à virgule flottante, donc quand js analyse 8是发现后面还有.于是会把8.看成一个数，这样的话没加.的toStringbien sûr, c'est faux.
Donc ce n'est pas grave si c'est écrit comme ça

8..toString()// 正确

Tout d'abord, votre idée est fausse. Les objets Objet ordinaires peuvent appeler des méthodes Par exemple

var o = {};
o.toString(); // OK

Mais {}.toString() a une erreur de syntaxe, car {} dans {}.toString() sera lu dans un {}.toString()却是出现语法错误,因为{}.toString()中的{}将会被看成一个语句块,而不是对象直接量.
因为 JavaScript 将从左到右解析{}.toString(),当遇到{时,它将会看做一个语句块的开始,之后遇到},语句块结束,在遇到. bloc d'instructions

littéral d'objet.
Parce que JavaScript analysera {}.toString() de gauche à droite, lorsqu'il rencontrera {, ce sera considéré comme le début d'un bloc d'instructions. Après avoir rencontré >, le bloc d'instructions se termine. Lorsque vous rencontrez ., une erreur de syntaxe se produira.({}).toString()将可以正常工作.(注意包围在{}两边的括号).
因为当解析({}).toString()时,首先遇到( Et si vous utilisez ({}).toString() cela fonctionnera normalement (Notez les crochets entourant {}).
Parce que lors de l'analyse de When. ({}).toString(), première rencontre (, puis traite la partie entre parenthèses comme une expression

À propos de {}.toString(), quelqu'un l'a déjà dit très clairement. En effet, le moteur js traitera {} comme une marque de bloc lors de l'analyse. Cependant, je trouve que c'est très étrange. J'ai essayé plusieurs navigateurs sur mon Mac et il n'y a aucun problème avec le problème mentionné par l'affiche.

Ce que je veux ajouter, c'est la deuxième question de l'affiche, 为什么字符串可以直接调用方法，Number类型、Boolean类型却不行。 Je pense que vous avez dû faire une erreur quelque part.

var num = 1.2333;
var flag = true;
            
console.log({}.toString())   //[object, object]
console.log(num.toFixed(2));  //1.23
console.log(flag.toString()); //'true'   这里是字符串

Ici, num est un littéral numérique et flag est une valeur booléenne. Les deux peuvent appeler des méthodes. Si l'auteur s'y connaît en chaînes, il doit comprendre que les types de données de base n'ont pas d'attributs ni de méthodes, seuls les objets en ont.

Mais pourquoi pouvons-nous appeler des méthodes de types de données de base, tout comme appeler des méthodes d'objets ? (par exemple : 'a bc'.trim())

En effet, lorsqu'une méthode est appelée sur une valeur d'un type de données de base, js la convertira en un objet wrapper temporaire. Les littéraux de chaîne peuvent appeler des propriétés et des méthodes telles que des objets chaîne (new String('abc')), et les littéraux numériques peuvent appeler des propriétés et des méthodes telles que des objets numériques.

Bien entendu, cet objet packaging temporaire n'existe qu'au moment où le code est exécuté. Une fois la méthode exécutée, l’objet temporaire est immédiatement détruit.

Donc, ce que dit l'affiche, c'est qu'il est impossible d'appeler des méthodes sur des valeurs de type numérique et booléen.