Comment puis-je vérifier si une variable javascript est le type de fonction?

Question

Supposons que j'ai une variable qui est définie comme suit:

var a = function(){/* Statements */};

Je veux une fonction qui vérifie si le type de la variable est fonction. c'est à dire :

function foo(v){if(v is function type?){/* do something */}};
foo(a);

Comment puis-je vérifier si la variable 'a' est de type fonction de la façon définie ci-dessus?

Answer 1

if (typeof(v) == "function") {
// do something
}

Answer 2

Assurez-vous les traits de soulignement est plus efficace, mais le meilleur moyen de vérifier, lors de l'efficience n'est pas un problème, il est écrit sur le trait de soulignement de la page liée par @Paul Rosania.

function isFunctionA(object) {
 return object && getClass.call(object) == '[object Function]';
}

Ainsi, la finale isFunction fonction est la suivante:

function isFunction(functionToCheck) {
 var getType = {};
 return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
}

typeof devrait seulement être utilisé pour vérifier si les variables ou propriétés ne sont pas définis.

Par exemple,

if (typeof thing !== "undefined") {
  // do something with global property "thing"
}

Answer 3

Il y a plusieurs façons donc je vais les résumer tous

1. La meilleure façon est:

   
    la fonction foo(v){if(v instanceof Fonction){/* faire quelque chose */}};
   
   

   Plus performant (pas de chaîne comparizon) et de l'élégance de la solution. l'opérateur instanceof a été pris en charge dans les navigateurs depuis très longtemps, afin de ne pas wory - il fonctionnera dans IE 6.
2. La prochaine meilleure façon est:

   
    la fonction foo(v){if(typeof v === "function"){/* faire quelque chose */}};
   
   

   inconvénient de l' typeof , c'est qu'il est sensible à l'échec silencieux, mauvais, donc si vous avez une faute de frappe (par exemple, "finction") - dans ce cas la si retournera false et vous n'aurez pas savoir que vous avez une erreur jusqu'à ce que plus tard dans votre code
3. la prochaine meilleure façon est:

   
    fonction isFunction(functionToCheck) {
    var getType = {};
    retour functionToCheck && getType.toString.appel(functionToCheck) === '[la Fonction de l'objet]';
   }
   
   

   Cela n'a aucun avantage sur la solution #1 ou #2, mais beaucoup moins lisible. version améliorée de ce est

   
    fonction isFunction(x) {
    de retour de l'Objet.le prototype.toString.appel(x) == '[la Fonction de l'objet]';
   }
   
   

   mais tout de même beaucoup moins sémantique que la solution n ° 1

Answer 4

Underscore.js utilise un système plus complexe, mais très performants de test:

_.isFunction = function(obj) {
  return !!(obj && obj.constructor && obj.call && obj.apply);
};

Voir: http://jsperf.com/alternative-isfunction-implementations

EDIT: mise à jour des tests suggèrent que typeof peut-être plus rapide, voir http://jsperf.com/alternative-isfunction-implementations/4

Answer 5

@grandecomplex: Il y a une bonne quantité de verbosité à votre solution. Il serait beaucoup plus clair si l'écrit comme ceci:

function isFunction(x) {
  return Object.prototype.toString.call(x) == '[object Function]';
}