Controlla se una variabile è di tipo funzione

Supponiamo che io abbia una variabile, che è definita come segue:

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

Voglio una funzione che controlla se il tipo di variabile è simile alla funzione. cioè:

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

Come posso verificare se la variabile aè di tipo Functionnel modo sopra definito?

Il modo in cui il carattere di sottolineatura è più efficiente, ma il modo migliore per verificare, quando l'efficienza non è un problema, è scritto sulla pagina del carattere di sottolineatura collegata da @Paul Rosania.

Ispirato dal trattino basso, la funzione finale isFunction è la seguente:

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

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

Underscore.js utilizza un test più elaborato ma altamente performante:

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

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

EDIT: test aggiornati suggeriscono che typeof potrebbe essere più veloce, vedi http://jsperf.com/alternative-isfunction-implementations/4

Esistono diversi modi, quindi li riassumerò tutti

1. Il modo migliore è:

   function foo (v) {if (v instanceof Function) {/ * fare qualcosa * /}};
   
   

   La soluzione più performante (nessun confronto di stringhe) ed elegante - l'operatore instanceof è supportato nei browser da molto tempo, quindi non preoccuparti - funzionerà in IE 6.
2. Il prossimo modo migliore è:

   function foo (v) {if (typeof v === "function") {/ * do qualcosa * /}};
   
   

   svantaggio di typeof è che è suscettibile a fallimento silenzioso, cattivo, quindi se hai un errore di battitura (ad esempio "fiction") - in questo caso `if` restituirà solo falso e non saprai di avere un errore fino a dopo in il tuo codice
3. Il prossimo modo migliore è:

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

   Questo non ha alcun vantaggio rispetto alla soluzione n. 1 o n. 2, ma è molto meno leggibile. Una versione migliorata di questo è

   funzione isFunction (x) {
       return Object.prototype.toString.call (x) == '[Funzione oggetto]';
   }
   
   

   ma molto meno semantico della soluzione n. 1

Riferimento jQuery (obsoleto dalla versione 3.3)

$.isFunction(functionName);

Riferimento AngularJS

angular.isFunction(value);

Riferimento di Lodash

_.isFunction(value);

Riferimento di sottolineatura

_.isFunction(object); 

Node.js obsoleto dal riferimento v4.0.0

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

@grandecomplex: c'è una buona dose di verbosità nella tua soluzione. Sarebbe molto più chiaro se scritto in questo modo:

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

Prova l' instanceofoperatore: sembra che tutte le funzioni ereditino dalla 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

Qualcosa con più supporto del browser e include anche funzioni asincrone potrebbe essere:

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

e poi testalo come:

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

Un altro modo semplice:

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

Per coloro che sono interessati allo stile funzionale o cercano un approccio più espressivo da utilizzare nella meta-programmazione (come il controllo del tipo), potrebbe essere interessante vedere Ramda libreria per svolgere tale compito.

Il codice successivo contiene solo funzioni pure e inutili:

const R = require('ramda');

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

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

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

A partire da ES2017, le asyncfunzioni sono disponibili, quindi possiamo anche verificarle:

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

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

E poi combinali insieme:

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

Naturalmente, la funzione deve essere protetta contro nulle undefinedvalori, quindi per renderla "sicura":

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

E, completare lo snippet per riassumere:

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 ));

Tuttavia, si noti che questa soluzione potrebbe mostrare prestazioni inferiori rispetto ad altre opzioni disponibili a causa dell'ampio utilizzo di funzioni di ordine superiore.

Se usi Lodash puoi farlo con _.isFunction .

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

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

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

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

Questo metodo restituisce truese value è una funzione, altrimenti false.

Ho scoperto che durante il test funzioni native del browser in IE8, usando toString, instanceofe typeofnon ha funzionato. Ecco un metodo che funziona perfettamente in IE8 (per quanto ne so):

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

In alternativa, puoi controllare le funzioni native usando:

"getElementById" in document

Tuttavia, ho letto da qualche parte che questo non funzionerà sempre in IE7 e sotto.

Quanto segue sembra funzionare anche per me (testato da node.js):

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

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

Penso che puoi semplicemente definire un flag sul prototipo Function e verificare se l'istanza che vuoi testare ha ereditato

definire una bandiera:

Function.prototype.isFunction = true; 

e poi controlla se esiste

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

Il rovescio della medaglia è che un altro prototipo può definire la stessa bandiera e quindi è inutile, ma se hai il pieno controllo sui moduli inclusi è il modo più semplice

Dal nodo v0.11 è possibile utilizzare la funzione util standard:

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

dovresti usare l' typeOfoperatore in js.

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

La soluzione, come hanno mostrato alcune risposte precedenti, è usare typeof. il seguente è uno snippet di codice in 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]();
  }