Nommage d'une fonction anonyme

Est-il possible de faire en quelque sorte de définir un nom pour les fonctions anonymes?

Il n'est pas nécessaire d'ajouter les noms de fonction à l'espace de noms pour les fonctions anonymes, mais je voudrais éviter de voir une grande quantité de (?) dans mon débogueur javascript donc je peux garder la trace de pile d'appel informatif.

Aussi je peux passer à la normale déclaré fonctions comme arguments à la place des fonctions anonymes, ou vais-je marcher dans d'étranges erreurs. Il semble fonctionner.

$("object").bind("click", function() { alert("x"); });

$("object").bind("click", function debuggingName() { alert("x"); });

[Modifier]

Je voulais dire quelque chose le long de l'aime de

$("object").bind("click", function() { Function.Name = "debuggingName"; alert("x"); });

un nom de fonction anonyme est une contradiction dans les termes!!
Êtes-vous certains d'erreur lorsque vous utilisez votre deuxième construire au-dessus?
Je veux juste mettre quelque chose dans une fonction anonyme que le débogueur peut récupérer et afficher utile de débogage nom de la fonction. Je veux les utiliser exactement comme je voudrais utiliser les fonctions anonymes
avez-vous essayé $("objet").bind("click", function MY_NOT_SO_ANONYMOUS_FUNCTION_NAME () { alert("x"); });
comment est-ce différent du deuxième exemple que j'ai? Oui, j'ai. c'est probablement la meilleure façon de le gérer.
Désolé, je dois avoir manqué que vous avez déjà écrit que. C'est exactement le même que votre deuxième exemple.

InformationsquelleAutor Raynos | 2010-10-04

19

Votre deuxième exemple est à l'aide d'un fonction nommée expression, qui fonctionne bien dans la plupart des navigateurs, mais a des problèmes c'est à dire que vous devriez être au courant avant de l'utiliser. Je recommande la lecture de kangax l'excellent article sur ce sujet.
- Merci, j'avais peur qu'en passant d'une fonction nommée expression pourrait provoquer des erreurs.
- Oh, c'est un joli article. Je n'ai pas d'avis il n'y a actaully une différence entre nommé les expressions de fonction et de la déclaration de la fonction.
- Oui, j'étais en train d'écrire un commentaire souligné 🙂
- Bien que actaully je crois que mon deuxième exemple ci-dessus est une instruction de fonction. Si vous comptez attribution de la déclaration de la fonction d'arguments[1] comme une fonction nommée expression. Et je commençais à obtenir une sensation que j'ai compris javascript.
- Votre deuxième exemple est certainement une fonction nommée expression. Il ressemble à une déclaration de fonction, sauf pour le contexte: une déclaration de fonction n'est pas valide là où une expression est attendue (comme lors du passage d'un paramètre de la fonction, que votre exemple n'). Une instruction de fonction est tout autre chose: c'est une extension de Mozilla à ECMAScript pour éviter une déclaration de fonction à l'intérieur d'un if bloc d'être une erreur de syntaxe. kangax de l'article couvre que trop: kangax.github.com/nfe/#function-statements
- Oh bah j'ai lu l'article de mal. Oui, c'est une expression de fonction. La curiosité, le membre de phrase "le nom de la fonction de l'expression" s'appliquent à de tels états var nom = function truc() {} ? Ou, généralement, quand les expressions de fonction considéré comme "nommé"
- Oui, le côté droit de var name = function thing() {} est une fonction nommée expression. var name = function() {} est juste une expression de fonction. La distinction entre fonction nommée expressions, les instructions de fonction et les déclarations de fonction est basé sur le contexte. Si c'est un endroit où l'interprète s'attend à une expression (par exemple dans une déclaration de variable), puis il va être nommé en fonction de l'expression. Si elle est dans le code mondial ou à l'intérieur d'une fonction (mais pas à l'intérieur d'un bloc, dans les deux cas), c'est une déclaration de fonction. Si c'est à l'intérieur d'un bloc (par exemple, un if bloc), c'est une instruction de fonction.
InformationsquelleAutor Tim Down
1

Vous pourriez faire quelque chose comme ceci avec une flèche fonctions, il fonctionne pour moi sur le Nœud.
```
const createTask = ([name, type = 'default']) => {
  const fn = () => { ... }

  Object.defineProperty(fn, 'name', {
    value: name,
    configurable: true,
  })

  return fn
}
```
MDN est quelque peu trompeur ici:

Vous ne pouvez pas modifier le nom d'une fonction, cette propriété est en lecture seule...

De le changer, vous pouvez utiliser Objet.defineProperty() si.

Cette réponse fournit plus de détails.

InformationsquelleAutor Jack Steam
0

J'ai l'habitude de faire:
$("objet").bind("click"
le nom de la fonction() {
alert("x");
});

et ne courez pas dans les problèmes.

Cela est encouragé dans certaines des plus grandes bibliothèques:

https://groups.google.com/forum/m/#!topic/firebug/MgnlqZ1bzX8

http://blog.getfirebug.com/2011/04/28/naming-anonymous-javascript-functions/

InformationsquelleAutor Andrew Luhring
0

Si dynamique nom de la fonction est la question. Vous pouvez essayer ceci:
```
function renameFunction(name, fn) {
    return (new Function("return function (call) { return function " + name +
       " () { return call(this, arguments) }; };")())(Function.apply.bind(fn));
} 

renameFunction('dynamicName',function() { debugger })();
```
source: Nate Ferrero à Comment définir dynamiquement une fonction/nom de l'objet en Javascript comme il est affiché dans le navigateur Chrome
- Je viens de voir une meilleure solution pour que sur stackoverflow.com/questions/5871040/...
- Ne jamais faire cela. Il est idiot et verbeux.
InformationsquelleAutor Shai Ben-Yehuda

Avec ECMAScript2015 (ES2015, ES6) spécification de langage, il est possible de le faire sans l'utilisation de lent et dangereux eval fonction et sans Objet.defineProperty méthode qui corrompt à la fois la fonction de l'objet et ne fonctionne pas dans certains aspects cruciaux de toute façon.

Voir, par exemple, ce nameAndSelfBind fonction qui est capable à la fois le nom d'une fonction anonyme, et de le renommer les fonctions nommées, ainsi que la liaison de leur propre corps pour eux-mêmes comme ce et de stocker les références aux traités fonctions pour être utilisé à l'extérieur de son champ d'application (JSFiddle):

(function()
{
//an optional constant to store references to all named and bound functions:
const arrayOfFormerlyAnonymousFunctions = [],
removeEventListenerAfterDelay = 3000; //an auxiliary variable for setTimeout
//this function both names argument function and makes it self-aware,
//binding it to itself; useful e.g. for event listeners which then will be able
//self-remove from within an anonymous functions they use as callbacks:
function nameAndSelfBind(functionToNameAndSelfBind,
name = 'namedAndBoundFunction', //optional
outerScopeReference)            //optional
{
const functionAsObject = {
[name]()
{
return binder(...arguments);
}
},
namedAndBoundFunction = functionAsObject[name];
//if no arbitrary-naming functionality is required, then the constants above are
//not needed, and the following function should be just "var namedAndBoundFunction = ":
var binder = function() 
{ 
return functionToNameAndSelfBind.bind(namedAndBoundFunction, ...arguments)();
}
//this optional functionality allows to assign the function to a outer scope variable
//if can not be done otherwise; useful for example for the ability to remove event
//listeners from the outer scope:
if (typeof outerScopeReference !== 'undefined')
{
if (outerScopeReference instanceof Array)
{
outerScopeReference.push(namedAndBoundFunction);
}
else
{
outerScopeReference = namedAndBoundFunction;
}
}
return namedAndBoundFunction;
}
//removeEventListener callback can not remove the listener if the callback is an anonymous
//function, but thanks to the nameAndSelfBind function it is now possible; this listener
//removes itself right after the first time being triggered:
document.addEventListener("visibilitychange", nameAndSelfBind(function(e)
{
e.target.removeEventListener('visibilitychange', this, false);
console.log('\nEvent listener 1 triggered:', e, '\nthis: ', this,
'\n\nremoveEventListener 1 was called; if "this" value was correct, "'
+ e.type + '"" event will not listened to any more');
}, undefined, arrayOfFormerlyAnonymousFunctions), false);
//to prove that deanonymized functions -- even when they have the same 'namedAndBoundFunction'
//name -- belong to different scopes and hence removing one does not mean removing another,
//a different event listener is added:
document.addEventListener("visibilitychange", nameAndSelfBind(function(e)
{
console.log('\nEvent listener 2 triggered:', e, '\nthis: ', this);
}, undefined, arrayOfFormerlyAnonymousFunctions), false);
//to check that arrayOfFormerlyAnonymousFunctions constant does keep a valid reference to
//formerly anonymous callback function of one of the event listeners, an attempt to remove
//it is made:
setTimeout(function(delay)
{
document.removeEventListener('visibilitychange',
arrayOfFormerlyAnonymousFunctions[arrayOfFormerlyAnonymousFunctions.length - 1],
false);
console.log('\nAfter ' + delay + 'ms, an event listener 2 was removed;  if reference in '
+ 'arrayOfFormerlyAnonymousFunctions value was correct, the event will not '
+ 'be listened to any more', arrayOfFormerlyAnonymousFunctions);
}, removeEventListenerAfterDelay, removeEventListenerAfterDelay);
})();

InformationsquelleAutor DDRRSS

-3

Une fonction anonyme est une fonction sans nom, il est exécuté à partir d'où il est défini. Alternativement, vous pouvez définir la fonction de débogage avant de l'utiliser.
```
function debuggingName() { 
alert("x"); 
}
$("object").bind("click", debuggingName);
```
InformationsquelleAutor Q_Mlilo

Vous devez vous connecter pour publier un commentaire.