Vérifiez si une variable est de type fonction

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 ressemble à une fonction. c'est à dire :

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

Comment puis-je vérifier si la variable aest de type Functionde la manière définie ci-dessus?

Bien sûr, la méthode de soulignement est plus efficace, mais la meilleure façon de vérifier, lorsque l'efficacité n'est pas un problème, est écrite sur la page de soulignement liée par @Paul Rosania.

Inspirée par le soulignement, la fonction finale isFunction est la suivante:

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

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

Underscore.js utilise un test plus élaboré mais très performant:

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

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

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

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

1. Le meilleur moyen est:

   function foo (v) {if (v instanceof Function) {/ * faire quelque chose * /}};
   
   

   Solution la plus performante (pas de comparaison de chaînes) et élégante - l'opérateur instanceof est pris en charge par les navigateurs depuis très longtemps, alors ne vous inquiétez pas - cela fonctionnera dans IE 6.
2. Le meilleur moyen suivant est:

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

   L'inconvénient typeofest qu'il est susceptible d'échec silencieux, mauvais, donc si vous avez une faute de frappe (par exemple "finction") - dans ce cas, le "if" retournera juste faux et vous ne saurez que vous avez une erreur que plus tard dans votre code
3. La deuxième meilleure façon est:

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

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

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

   mais toujours beaucoup moins sémantique que la solution # 1

jQuery (obsolète depuis la version 3.3) Référence

$.isFunction(functionName);

Référence AngularJS

angular.isFunction(value);

Référence Lodash

_.isFunction(value);

Référence de soulignement

_.isFunction(object); 

Node.js déconseillé depuis la référence v4.0.0

var util = require('util');
util.isFunction(object);

@grandecomplex: Votre solution est assez verbeuse. Ce serait beaucoup plus clair s'il était écrit comme ceci:

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

Essayez l' instanceofopérateur: il semble que toutes les fonctions héritent de la Functionclasse:

// Test data
var f1 = function () { alert("test"); }
var o1 = { Name: "Object_1" };
F_est = function () { };
var o2 = new F_est();

// Results
alert(f1 instanceof Function); // true
alert(o1 instanceof Function); // false
alert(o2 instanceof Function); // false

Quelque chose avec plus de support du navigateur et qui inclut également des fonctions asynchrones pourrait être:

const isFunction = value => value && (Object.prototype.toString.call(value) === "[object Function]" || "function" === typeof value || value instanceof Function);

puis testez-le comme:

isFunction(isFunction); //true
isFunction(function(){}); //true
isFunction(()=> {}); //true
isFunction(()=> {return 1}); //true
isFunction(async function asyncFunction(){}); //true
isFunction(Array); //true
isFunction(Date); //true
isFunction(Object); //true
isFunction(Number); //true
isFunction(String); //true
isFunction(Symbol); //true
isFunction({}); //false
isFunction([]); //false
isFunction("function"); //false
isFunction(true); //false
isFunction(1); //false
isFunction("Alireza Dezfoolian"); //false

Une autre manière simple:

var fn = function () {}
if (fn.constructor === Function) {
  // true
} else {
  // false
}

Pour ceux qui s'intéressent au style fonctionnel ou qui recherchent une approche plus expressive à utiliser dans la méta-programmation (comme la vérification de type), il pourrait être intéressant de voir la bibliothèque Ramda pour accomplir une telle tâche.

Le code suivant ne contient que des fonctions pures et sans point:

const R = require('ramda');

const isPrototypeEquals = R.pipe(Object.getPrototypeOf, R.equals);

const equalsSyncFunction = isPrototypeEquals(() => {});

const isSyncFunction = R.pipe(Object.getPrototypeOf, equalsSyncFunction);

Depuis ES2017, des asyncfonctions sont disponibles, nous pouvons donc également les vérifier:

const equalsAsyncFunction = isPrototypeEquals(async () => {});

const isAsyncFunction = R.pipe(Object.getPrototypeOf, equalsAsyncFunction);

Et puis combinez-les ensemble:

const isFunction = R.either(isSyncFunction, isAsyncFunction);

Bien sûr, la fonction doit être protégé contre nullet undefinedvaleurs, afin de le rendre « sûr »:

const safeIsFunction = R.unless(R.isNil, isFunction);

Et, un extrait complet pour résumer:

const R = require('ramda');

const isPrototypeEquals = R.pipe(Object.getPrototypeOf, R.equals);

const equalsSyncFunction = isPrototypeEquals(() => {});
const equalsAsyncFunction = isPrototypeEquals(async () => {});

const isSyncFunction = R.pipe(Object.getPrototypeOf, equalsSyncFunction);
const isAsyncFunction = R.pipe(Object.getPrototypeOf, equalsAsyncFunction);

const isFunction = R.either(isSyncFunction, isAsyncFunction);

const safeIsFunction = R.unless(R.isNil, isFunction);

// ---

console.log(safeIsFunction( function () {} ));
console.log(safeIsFunction( () => {} ));
console.log(safeIsFunction( (async () => {}) ));
console.log(safeIsFunction( new class {} ));
console.log(safeIsFunction( {} ));
console.log(safeIsFunction( [] ));
console.log(safeIsFunction( 'a' ));
console.log(safeIsFunction( 1 ));
console.log(safeIsFunction( null ));
console.log(safeIsFunction( undefined ));

Cependant, notez que cette solution pourrait afficher moins de performances que les autres options disponibles en raison de l'utilisation intensive de fonctions d'ordre supérieur.

Si vous utilisez Lodash, vous pouvez le faire avec _.isFunction .

_.isFunction(function(){});
// => true

_.isFunction(/abc/);
// => false

_.isFunction(true);
// => false

_.isFunction(null);
// => false

Cette méthode retourne truesi value est une fonction, sinon false.

J'ai trouvé que lors du test des fonctions de navigateur natif dans IE8, en utilisant toString, instanceofet typeofne fonctionne pas. Voici une méthode qui fonctionne bien dans IE8 (pour autant que je sache):

function isFn(f){
    return !!(f && f.call && f.apply);
}
//Returns true in IE7/8
isFn(document.getElementById);

Alternativement, vous pouvez vérifier les fonctions natives en utilisant:

"getElementById" in document

Cependant, j'ai lu quelque part que cela ne fonctionnera pas toujours dans IE7 et ci-dessous.

Ce qui suit semble également fonctionner pour moi (testé depuis node.js):

var isFunction = function(o) {
     return Function.prototype.isPrototypeOf(o);
};

console.log(isFunction(function(){})); // true
console.log(isFunction({})); // false

Je pense que vous pouvez simplement définir un indicateur sur le prototype de fonction et vérifier si l'instance que vous souhaitez tester a hérité de celle

définir un drapeau:

Function.prototype.isFunction = true; 

puis vérifiez s'il existe

var foo = function(){};
foo.isFunction; // will return true

L'inconvénient est qu'un autre prototype peut définir le même drapeau et que cela ne vaut rien, mais si vous avez un contrôle total sur les modules inclus, c'est le moyen le plus simple

Depuis le noeud v0.11, vous pouvez utiliser la fonction util standard:

var util = require('util');
util.isFunction('foo');

vous devez utiliser l' typeOfopérateur dans js.

var a=function(){
    alert("fun a");
}
alert(typeof a);// alerts "function"

La solution, comme certaines réponses précédentes l'ont montré, consiste à utiliser typeof. ce qui suit est un extrait de code dans NodeJs,

    function startx() {
      console.log("startx function called.");
    }

 var fct= {};
 fct["/startx"] = startx;

if (typeof fct[/startx] === 'function') { //check if function then execute it
    fct[/startx]();
  }