À partir de ES2015 (ES6), les fonctions ont des noms propres (y compris un nom officiel name ), et les noms sont attribués lors de la création de la fonction de diverses manières, en plus de la déclaration de fonction évidente et de l'expression de fonction nommée, comme l'attribution à des variables (le nom de la fonction est défini sur le nom de la variable), l'attribution à des propriétés d'objet (le nom de la fonction est défini sur le nom de la propriété), et même des valeurs par défaut pour les paramètres de fonction (le nom de la fonction est défini sur le nom du paramètre). Mais l'affectation à une propriété d'un objet existant (par exemple, pas dans un initialisateur d'objet) n'affecte pas le nom de cette propriété à la fonction. Pourquoi ? Il doit sûrement y avoir un spécifique raison pour laquelle ce n'était pas souhaitable/possible. Quelle était cette raison ?
Pour être clair : je ne demande pas comment contourner ce problème. Je demande ce qui empêche ce cas apparemment évident d'être traité alors que tant d'autres (y compris les valeurs de paramètres par défaut !) le sont. Il doit y avoir une bonne raison.
S'il vous plaît, ne spéculez pas et ne faites pas de théories. Le TC39 avait une raison de ne pas l'inclure. J'aimerais savoir quelle était cette raison. J'ai parcouru le Notes de réunion du TC39 mais je ne l'ai pas encore trouvé. Le plus proche que j'ai trouvé jusqu'à présent est Allen Wirfs-Brock. en réponse à Bergi pour dire qu'il n'y avait pas de consensus pour le faire pour ce formulaire en raison de "diverses objections", mais malheureusement, il n'a pas dit quelles étaient ces objections.
Détails :
Tous les éléments suivants attribuent le nom foo à la fonction sur un navigateur conforme :
// Requires a compliant browser
// Assigning to a variable or constant...
// ...whether in the initializer...
{
let foo = function() { };
console.log("1:", foo.name); // "foo"
}
{
const foo = function() { };
console.log("2:", foo.name); // "foo"
}
// ...or later...
{
let foo;
foo = function() { };
console.log("3:", foo.name); // "foo"
}
// As an initializer for an object property
{
const obj = {
foo: function() { }
};
console.log("4:", obj.foo.name); // "foo"
}
// Or as a method
{
const obj = {
foo() { }
};
console.log("5:", obj.foo.name); // "foo"
}
// Even if it's a computed property name
{
let name = "f";
const obj = {
[name + "o" + "o"]() { }
};
console.log("6:", obj.foo.name); // "foo"
}
// As a default value for a parameter
(function(foo = function() { }) {
console.log("7:", foo.name); // "foo"
})();
// ...and a bunch of othersMais l'assignation à une propriété sur un objet existant, en dehors d'un initialisateur d'objet, ne le fait pas :
const obj = {};
obj.foo = function() { };
console.log("Nope:", obj.foo.name);Pour autant que je sache, cela est couvert par cet article de la spécification, qui ne définit explicitement le nom de la fonction que si la fonction IsIdentifierRef de la LeftHandSideExpression est vrai (ce qui apparemment ce n'est pas le cas pour les références des propriétés).
Je répète donc ce qui précède : Pourquoi pas ? Il doit sûrement y avoir un spécifique raison pour laquelle ce n'était pas souhaitable/possible. Quelle était cette raison ?
