Savoir si la fonction est anonyme ou est définie dans un objet

Question

J'essaie d'écrire une méthode d'aide en JavaScript. Il devrait agir différemment si l'on envoie une fonction ou une référence à une fonction.

Je veux vous l'utiliser comme ceci:

helper('div', function() { return false; }) 
helper('div', obj.fn) 

Ce que je ne peux pas comprendre est la suivante: comment l'intérieur de la fonction d'aide faire la différence entre les deux?

Je pense qu'il est dû à cette JavaScript évalue d'abord la obj.fn avant qu'elle ne l'envoie dans. La seule solution que j'ai trouvé est d'envoyer le obj.fn comme obj, à savoir

helper('div', { fn: obj.fn }) 

Je peut faire la différence entre les deux avec typeof. Mais j'aime vraiment un moyen de le faire sans la déclaration d'objet supplémentaire.

Answer 1

Vous pouvez utiliser toString() pour savoir si la fonction est anonyme en supposant qu'elle est déclarée comme une fonction nommée et non une fonction sans nom attribué à une variable:

function jim() { var h = "hello"; } 
function jeff(func) 
{ 
    var fName; 
    var inFunc = func.toString(); 
    var rExp = /^function ([^\s]+) \(\)/; 
    if (fName = inFunc.match(rExp)) 
     fName = fName[1]; 

    alert(fName); 
} 

vous donnera la nom de la fonction le cas échéant.

jeff(function() { blah(); }); // alert: null; 
jeff(function joe() { blah(); }); // alert: "joe"; 
jeff(jack); // "jack" if jack is function jack() { }, null if jack = function() {} 

Ma précédente édition fait référence à une bizarrerie IE qui n'existait pas dans d'autres navigateurs et n'est plus valide dans IE de la version 9. Toutefois, vous pouvez affecter encore des fonctions nommées comme propriétés de l'objet en utilisant une fonction nommée expression:

var obj = { 
    fn: function namedFunction() { } 
}; 

cela fonctionne dans tous les navigateurs, mais IE 8 et inférieure ne respectent pas la spécification qui dit que la fonction est disponible uniquement par ce nom dans son propre bloc.

Answer 2

MISE À JOUR * (ENCORE): Je pensais que la méthode toString() pourrait être votre seul moyen d'avancer ici. Il ne traite cependant pas différemment une référence d'un objet anonyme.

Ce code démontre que:

function acceptparam(fn){ 

      console.log("fn.constructor = " + fn.constructor); 
      console.log("typeof fn = " + typeof fn); 
      console.log("fn toString " + fn.toString()); 

      console.log("fn.prototype = " + fn.prototype); 
      console.log("fn.prototype.constructor = " + fn.prototype.constructor); 
      console.log("this[0] = " + this[0]); 
      console.log("---"); 

     } 

     function empty(){ 
      return ; 
     } 

     var x = { 
      y : function(){return;} 
     } 

     acceptparam(empty); 
     acceptparam(function(){return;}); 
     acceptparam(x.y); 

question très intéressante, sans mettre en œuvre votre propre solution, je ne pense pas que vous pouvez le faire, ce poste aide à expliquer pourquoi. C'est à propos de la relation parent-enfant que d'être à sens unique.

http://codingforums.com/showthread.php?t=134855

Answer 3

Je pensais que j'ajouterais une autre réponse alternative, principalement parce que je ne voulais pas ajouter à la soupe qui est mon autre réponse, mais aussi parce que cela ne s'est pas bien passé avec les électeurs de stackoverflow qui ne le font pas laisser ;-)

commentaires constructifs comme alternative à ce que vous essayez de faire, vous pouvez ajouter un troisième paramètre à la fonction d'aide:

function helper (tagName, fn, method) 
{ 
    if (method) 
     fn = fn[method]; 

    //- Do rest of helper function here 
} 
//- Now if we pass an object method to helper function we can identify it properly 
helper('div', obj, "fn"); // method is obj.fn 
helper('div', function() { blah(); }); // Still works fine 

le simple fait une suggestion et fonctionne aussi bien ou même mieux que votre travail actuel.